🚀 *Gen AI Engineer Telugu (Production Focused)* Python re group() and groups() Methods Explained
The group() and groups() methods are used with match objects to extract captured groups from regex patterns. They work on the result of re.search(), re.match(), or re.finditer().
>>> import re
>>> result = re.search(r".+\s(.+ex).+(\d\d\s.+).", string)
>>> result.groups()
#('index', '19 February')
>>> result.group(1)
'index'
>>> result.group(2)
'19 February'
>>> result.group()
'The Euro STOXX 600 index, which tracks all stock markets across Europe including the FTSE, fell by 11.48% – the worst day since it launched in 1998. The panic selling prompted by the coronavirus has wiped £2.7tn off the value of STOXX 600 shares since its all-time peak on 19 February.'
>>> result.group(0)
'The Euro STOXX 600 index, which tracks all stock markets across Europe including the FTSE, fell by 11.48% – the worst day since it launched in 1998. The panic selling prompted by the coronavirus has wiped £2.7tn off the value of STOXX 600 shares since its all-time peak on 19 February.'
>>> result.group(1, 2)
('index', '19 February')
>>> result = re.findall(r".+\s(.+ex).+(\d\d\s.+).", string)
>>> result
[('index', '19 February')]
>>> result.group()
Traceback (most recent call last):
File "<pyshell#130>", line 1, in <module>
result.group()
AttributeError: 'list' object has no attribute 'group'
>>> result.groups()
Traceback (most recent call last):
File "<pyshell#131>", line 1, in <module>
result.groups()
AttributeError: 'list' object has no attribute 'groups'The Pattern: r".+\s(.+ex).+(\d\d\s.+)."
Breakdown:
1. .+ - Greedy Match
. = any character except newline
+ = one or more times
Matches: As many characters as possible until the next part
2. \s - Whitespace Character
\s = any whitespace (space, tab, newline)
Matches: A single whitespace character
3. (.+ex) - First Capture Group
.+ = one or more of any character
ex = literal characters "ex"
( ) = capture this group
Matches: Any text that ends with "ex" (e.g., "index", "complex", "regex")
4. .+ - Greedy Match
Matches: More characters until the next part
5. (\d\d\s.+) - Second Capture Group
\d\d = exactly two digits (e.g., "11", "25", "99")
\s = whitespace character
.+ = one or more of any character
( ) = capture this group
Matches: Two digits followed by space and then more text
6. . - Final Character
. = any character except newline
Matches: One final character at the endgroup() Method
- Returns specific captured group(s) from a match
group(0)returns the entire matchgroup(1)returns the first capture group,group(2)the second, etc.
groups() Method
- Returns all captured groups as a tuple
- Returns empty tuple if no groups were captured
string = "The Euro STOXX 600 index, which tracks all stock markets across Europe including the FTSE, fell by 11.48% – the worst day since it launched in 1998. The panic selling prompted by the coronavirus has wiped £2.7tn off the value of STOXX 600 shares since its all-time peak on 19 February."
Example 1: Basic Group Extraction
python
import re
text = "John Doe, age 30, email: john.doe@email.com"
# Pattern with multiple capture groups
pattern = r'(\w+)\s+(\w+),\s+age\s+(\d+),\s+email:\s+([\w.]+@[\w.]+)'
///
The Pattern: r'(\w+)\s+(\w+),\s+age\s+(\d+),\s+email:\s+([\w.]+@[\w.]+)'
Breakdown by Capture Groups:
1. (\w+) - First Capture Group (First Name)
\w+ = one or more word characters (letters, digits, underscores)
( ) = capture this group
Matches: First name (e.g., "John")
2. \s+ - Whitespace
\s+ = one or more whitespace characters (spaces, tabs)
Matches: The space between first and last name
3. (\w+) - Second Capture Group (Last Name)
\w+ = one or more word characters
( ) = capture this group
Matches: Last name (e.g., "Doe")
4. ,\s+age\s+ - Literal Text
, = literal comma
\s+ = one or more whitespace characters
age = literal word "age"
\s+ = one or more whitespace characters
Matches: ", age " (with possible spaces)
5. (\d+) - Third Capture Group (Age)
\d+ = one or more digits
( ) = capture this group
Matches: Age (e.g., "30")
6. ,\s+email:\s+ - Literal Text
, = literal comma
\s+ = one or more whitespace characters
email: = literal "email:"
\s+ = one or more whitespace characters
Matches: ", email: " (with possible spaces)
7. ([\w.]+@[\w.]+) - Fourth Capture Group (Email)
[\w.]+ = one or more word characters or dots (username part)
@ = literal @ symbol
[\w.]+ = one or more word characters or dots (domain part)
( ) = capture this group
Matches: Email address (e.g., "john.doe@email.com")
///
match = re.search(pattern, text)
if match:
print("Entire match:", match.group(0))
print("First name:", match.group(1))
print("Last name:", match.group(2))
print("Age:", match.group(3))
print("Email:", match.group(4))
print("\nAll groups as tuple:", match.groups())
# Access multiple groups at once
print("First and last name:", match.group(1, 2))
else:
print("No match found")
Output:
text
Entire match: John Doe, age 30, email: john.doe@email.com
First name: John
Last name: Doe
Age: 30
Email: john.doe@email.com
All groups as tuple: ('John', 'Doe', '30', 'john.doe@email.com')
First and last name: ('John', 'Doe')
Example 2: Date Parsing with Groups
python
import re
dates = [
"2023-12-25",
"12/25/2023",
"25-12-2023",
"Invalid date"
]
# Different date formats with capture groups
patterns = [
r'(\d{4})-(\d{2})-(\d{2})', # YYYY-MM-DD
r'(\d{2})/(\d{2})/(\d{4})', # MM/DD/YYYY
r'(\d{2})-(\d{2})-(\d{4})' # DD-MM-YYYY
]
for date in dates:
matched = False
for pattern in patterns:
match = re.search(pattern, date)
if match:
print(f"Date: {date}")
print(f"Groups: {match.groups()}")
print(f"Year: {match.group(1)} in pattern: {pattern}")
print("---")
matched = True
break
if not matched:
print(f"No valid date format found for: {date}")
print("---")
Output:
text
Date: 2023-12-25
Groups: ('2023', '12', '25')
Year: 2023 in pattern: (\d{4})-(\d{2})-(\d{2})
---
Date: 12/25/2023
Groups: ('12', '25', '2023')
Year: 12 in pattern: (\d{2})/(\d{2})/(\d{4})
---
Date: 25-12-2023
Groups: ('25', '12', '2023')
Year: 25 in pattern: (\d{2})-(\d{2})-(\d{4})
---
No valid date format found for: Invalid date
---
Example 3: Advanced Group Usage with finditer()
python
import re
html_content = """
<div class="product">
<h3>Laptop</h3>
<p class="price">$999.99</p>
<p class="rating">4.5 stars</p>
</div>
<div class="product">
<h3>Smartphone</h3>
<p class="price">$599.50</p>
<p class="rating">4.2 stars</p>
</div>
"""
# Extract product information using named groups (Python 3.6+)
pattern = r'<h3>(?P<name>.*?)</h3>.*?<p class="price">\$(?P<price>.*?)</p>.*?<p class="rating">(?P<rating>.*?) stars</p>'
print("Product Information:")
for match in re.finditer(pattern, html_content, re.DOTALL):
print(f"Product: {match.group('name')}")
print(f"Price: ${match.group('price')}")
print(f"Rating: {match.group('rating')}/5")
print(f"All groups: {match.groups()}")
print(f"Group dict: {match.groupdict()}")
print("---")
# Example with optional groups
text = "Colors: red, green, blue"
pattern = r'Colors:\s*(?:(\w+)(?:,\s*(\w+))?(?:,\s*(\w+))?)?'
match = re.search(pattern, text)
if match:
print("Color groups:", match.groups())
print("Non-empty colors:", [color for color in match.groups() if color])
Output:
text
Product Information:
Product: Laptop
Price: $999.99
Rating: 4.5/5
All groups: ('Laptop', '999.99', '4.5')
Group dict: {'name': 'Laptop', 'price': '999.99', 'rating': '4.5'}
---
Product: Smartphone
Price: $599.50
Rating: 4.2/5
All groups: ('Smartphone', '599.50', '4.2')
Group dict: {'name': 'Smartphone', 'price': '599.50', 'rating': '4.2'}
---
Color groups: ('red', 'green', 'blue')
Non-empty colors: ['red', 'green', 'blue']
Key Differences:
| Method | Returns | Usage |
|---|---|---|
group() | Specific group(s) | match.group(0), match.group(1), match.group(1, 2) |
groups() | All groups as tuple | match.groups() |
groupdict() | Named groups as dict | match.groupdict() |
Important Notes:
- Group numbering starts at 1:
group(1)is the first capture group - group(0): Always returns the entire matched string
- None groups: If a group didn’t participate in match, it returns
None - Named groups: Use
(?P<name>pattern)syntax and access withgroup('name')
python
# Named groups example
text = "John: 30"
match = re.search(r'(?P<name>\w+):\s*(?P<age>\d+)', text)
if match:
print(match.group('name')) # John
print(match.group('age')) # 30
print(match.groupdict()) # {'name': 'John', 'age': '30'}
These methods are essential for extracting specific parts of matched patterns in regular expressions!
