Python Match.group() Method

last modified April 20, 2025

Introduction to Match.group

The Match.group method is a fundamental part of Python's re module. It returns one or more subgroups of a match from a regular expression pattern.

When using capturing groups in regex patterns, Match.group allows you to access the matched text for each group. Groups are created using parentheses in the pattern.

The method can return a single group by number, multiple groups as a tuple, or all groups when called without arguments. It's essential for extracting structured data from text.

Basic Syntax

The syntax for Match.group is flexible:

group([group1, ...])

Called without arguments, it returns the entire match. With one argument, returns that group's match. Multiple arguments return a tuple of matches.

Basic Group Extraction

Let's start with a simple example of extracting a single group.

basic_group.py

#!/usr/bin/python

import re

text = "Date: 2023-12-25"
pattern = re.compile(r'Date: (\d{4})-(\d{2})-(\d{2})')

match = pattern.search(text)
if match:
    print(f"Full match: {match.group(0)}")
    print(f"Year: {match.group(1)}")
    print(f"Month: {match.group(2)}")
    print(f"Day: {match.group(3)}")

This example shows how to extract date components using numbered groups. Group 0 always contains the entire matched text.

pattern = re.compile(r'Date: (\d{4})-(\d{2})-(\d{2})')

The pattern defines three capturing groups for year, month, and day. Each group matches a specific number of digits.

print(f"Year: {match.group(1)}")

We access each group by its position. Group 1 contains the year, group 2 the month, and group 3 the day.

Named Groups

Named groups make patterns more readable and maintainable.

named_groups.py

#!/usr/bin/python

import re

text = "Temperature: 23.5°C"
pattern = re.compile(r'Temperature: (?P<value>\d+\.\d+)°(?P<unit>[CF])')

match = pattern.search(text)
if match:
    print(f"Value: {match.group('value')}")
    print(f"Unit: {match.group('unit')}")
    print(f"All groups: {match.groupdict()}")

Named groups use (?P<name>...) syntax. They can be accessed by name or position, and groupdict returns all named groups as a dictionary.

Multiple Groups

You can retrieve multiple groups at once by passing several arguments.

multiple_groups.py

#!/usr/bin/python

import re

text = "Coordinates: 40.7128° N, 74.0060° W"
pattern = re.compile(r'(\d+\.\d+)° ([NS]), (\d+\.\d+)° ([EW])')

match = pattern.search(text)
if match:
    lat, ns, lon, ew = match.group(1, 2, 3, 4)
    print(f"Latitude: {lat}° {ns}")
    print(f"Longitude: {lon}° {ew}")

This extracts latitude and longitude components in one call. The method returns a tuple of matches in the specified order.

Optional Groups

Handling patterns where some groups might not match requires care.

optional_groups.py

#!/usr/bin/python

import re

texts = ["Phone: 123-4567", "Phone: 123-4567 ext. 890"]
pattern = re.compile(r'(\d{3})-(\d{4})(?: ext\. (\d{3}))?')

for text in texts:
    match = pattern.search(text)
    if match:
        print(f"Main number: {match.group(1)}-{match.group(2)}")
        print(f"Extension: {match.group(3) or 'None'}")

The extension group is optional. When not matched, group(3) returns None. The (?:...) creates a non-capturing group.

Nested Groups

Groups can be nested, with numbering following their opening parentheses.

nested_groups.py

#!/usr/bin/python

import re

text = "Version: 2.1.4 (build 3256)"
pattern = re.compile(r'Version: ((\d+)\.(\d+)\.(\d+)) \(build (\d+)\)')

match = pattern.search(text)
if match:
    print(f"Full version: {match.group(1)}")
    print(f"Major: {match.group(2)}, Minor: {match.group(3)}")
    print(f"Patch: {match.group(4)}, Build: {match.group(5)}")

The outer group captures the complete version string, while inner groups capture individual components. Group numbering follows opening parentheses.

Backreferences in Substitutions

Groups enable powerful text transformations using backreferences.

backreferences.py

#!/usr/bin/python

import re

text = "Smith, John; Doe, Jane"
pattern = re.compile(r'(\w+), (\w+)')

# Swap last and first names
result = pattern.sub(r'\2 \1', text)
print("Reversed names:", result)

This swaps last and first names using backreferences in the substitution. \1 refers to the first group, \2 to the second.

Best Practices

When using Match.group, follow these best practices:

Use named groups for better readability and maintainability
Check if a group matched before accessing it (may be None)
Document your group numbering scheme in complex patterns
Consider using groupdict for named groups
Use non-capturing groups (?:...) when you don't need the match

Performance Considerations

Accessing groups by index is slightly faster than by name. However, the difference is negligible in most cases.

Complex patterns with many groups may impact performance. Balance readability with efficiency based on your use case.

Source

Python Match.group() documentation

This tutorial covered the essential aspects of Python's Match.group method. Mastering group extraction will make your regex code more powerful and maintainable.

Author

My name is Jan Bodnar, and I am a passionate programmer with extensive programming experience. I have been writing programming articles since 2007. To date, I have authored over 1,400 articles and 8 e-books. I possess more than ten years of experience in teaching programming.

List all Python tutorials.

Ebooks