How to use regular expressions with the re module in Python?

Regular expressions are implemented in Python through the re module for searching, matching and manipulating strings. 1. Use re.search() to find the first match in the entire string, and re.match() only matches at the beginning of the string; 2. Use brackets () to capture the matching subgroups, which can be named to improve readability; 3. re.findall() returns all non-overlapping matches, and re.finditer() returns the iterator of the matching object; 4. re.sub() replaces the matching text and supports dynamic function replacement; 5. Common patterns include \d, \w, \s, etc., and you can use re.IGNORECASE, re.MULTILINE, re.DOTALL, re.VERBOSE and other flags to adjust your behavior; 6. Frequently used patterns should be compiled through re.compile() to improve performance. It is recommended to use raw strings for all operations to avoid escape problems, and ultimately achieve efficient and flexible string processing.

Regular expressions (regex) in Python are handled through the built-in re module. They allow you to search, match, and manipulate strings based on patterns. Here's how to use them effectively.

Basic Pattern Matching with re.search() and re.match()

The most common functions are re.search() and re.match() .

• re.search(pattern, string) scans through the entire string and returns the first match.
• re.match(pattern, string) checks only at the beginning of the string.

 import re

text = "Contact us at support@example.com"

# Search for an email pattern anywhere in the string
match = re.search(r'\b[A-Za-z0-9._% -] @[A-Za-z0-9.-] \.[AZ|az]{2,}\b', text)
If match:
    print("Found:", match.group()) # Output: support@example.com

Note: Always use raw strings ( r"" ) with regex to avoid issues with backslashes.

Extracting Data with Groups

You can capture parts of a match using parentsheses () .

 log_line = "192.168.1.1 - - [23/Jan/2023:10:00:00] \"GET /index.html\" 200"
pattern = r'(\d \.\d \.\d \.\d ).*?\[(.*?)\].*?"(GET|POST) (.*?)"'

match = re.search(pattern, log_line)
If match:
    ip = match.group(1) # 192.168.1.1
    date = match.group(2) # 23/Jan/2023:10:00:00
    method = match.group(3) # GET
    path = match.group(4) # /index.html

You can also name groups for clarity:

 pattern = r&#39;(?P<ip>\d \.\d \.\d \.\d ).*?\[(?P<date>.*?)\].*?"(?P<method>GET|POST) (?P<path>.*?)"&#39;
match = re.search(pattern, log_line)
If match:
    print(match.group(&#39;ip&#39;)) # 192.168.1.1
    print(match.group(&#39;method&#39;)) # GET

Finding All Matches with re.findall() and re.finditer()

• re.findall() returns a list of all non-overlapping matches.
• re.finditer() returns an iterator of match objects (more memory efficient for large texts).

 text = "Emails: alice@test.com, bob@domain.org, charlie@test.com"

# Find all emails
emails = re.findall(r'\b[A-Za-z0-9._% -] @[A-Za-z0-9.-] \.[A-Za-z]{2,}\b', text)
print(emails) # ['alice@test.com', 'bob@domain.org', 'charlie@test.com']

# Using finder to get positions
for match in re.finditer(r'test\.com', text):
    print(f"Found at {match.start()}-{match.end()}")

Replacing Text with re.sub()

Use re.sub() to replace patterns in a string.

 text = "Call me at 555-123-4567 or 555-987-6543"

# Replace all phone numbers with [PHONE]
cleaned = re.sub(r'\d{3}-\d{3}-\d{4}', '[PHONE]', text)
print(cleaned) # Call me at [PHONE] or [PHONE]

# You can also use a function for dynamic replacement
def redact(match):
    return '[REDACTED-' match.group()[0:3] ']'

redacted = re.sub(r'\d{3}-\d{3}-\d{4}', redact, text)
print(redacted) # Call me at [REDACTED-555] or [REDACTED-555]

Common Regex Patterns and Flags

Some frequently used patterns:

• \d — digit
• \w — word character (letters, digits, underscore)
• \s — whitespace
• . — any character except newline
• * — zero or more
• — one or more
• ? — zero or one
• ^ — start of string
• $ — end of string

Use flags to modify behavior:

 # Case-insensitive search
re.search(r'hello', 'Hello World', re.IGNORECASE)

# Match across multiple lines (^ and $ match line boundaries)
re.search(r'^start', 'start\nstart', re.MULTILINE)

# Dot matches newline
re.search(r'.*', 'line1\nline2', re.DOTALL)

# Verbose mode for readable patterns
pattern = re.compile(r'''
    \b[A-Za-z0-9._% -] @ # Username
    [A-Za-z0-9.-] \.[A-Za-z]{2,}\b # Domain
''', re.VERBOSE)

Compiling Patterns for Reuse

If you're using the same pattern multiple times, compile it for better performance.

 phone_pattern = re.compile(r'\d{3}-\d{3}-\d{4}')

text1 = "Call 123-456-7890"
text2 = "Or try 999-888-7777"

print(phone_pattern.findall(text1)) # ['123-456-7890']
print(phone_pattern.findall(text2)) # ['999-888-7777']

The compiled object has all the same methods: .search() , .match() , .findall() , .sub() , etc.

Basically, the re module gives you powerful tools for string pattern matching. Start with simple patterns, use raw strings, and leverage compiling and flags as your needs grow. It's not magic, but it's extremely useful once you get the basics down.

The above is the detailed content of How to use regular expressions with the re module in Python?. For more information, please follow other related articles on the PHP Chinese website!