Python's re module supports advanced regular expression functions, including: 1. Grouping and capturing, extracting specific content such as parts of the date through brackets (), or using (?:...) to logically group; 2. Zero width assertion, matching positions rather than characters, such as (?

When processing text, basic regular expressions are enough, but some complex tasks are far from enough to rely on basic functions. Python's re module supports advanced features, which can help you deal with more complex matching, replacement and extraction scenarios. Mastering these skills can help you achieve twice the result with half the effort in data cleaning, log analysis and other work.

Grouping and Capture: Not only matching, but also extracting

Many times we not only need to judge whether it matches, but also extract specific parts from it. Grouping is used at this time.

For example, you want to extract content with the date format YYYY-MM-DD from a piece of text and obtain the year, month and day respectively:

 import re

text = "Today's date is 2024-03-15"
match = re.search(r"(\d{4})-(\d{2})-(\d{2})", text)

If match:
    year, month, day = match.groups()

In the above example, brackets () define three groups. You can get the content of all groups through .groups() , or you can get only the year by numbering such as match.group(1) .

If you just want to group and don't want to be captured (for example for logical grouping), you can use (?:...) :

 re.findall(r"(?:http|https): http://example.com", text)

This will not return to the protocol part separately.

Zero width assertion: Match position instead of character

Sometimes you don't want to really "eat" characters, just want to confirm what's in front and behind a certain position. This can be used to assert with zero width .

For example: You want to find a situation where the word "error" is not preceded by "no":

 text = "There is no error here, but this is a real error"
matches = re.findall(r"\b(?<!no )error\b", text)

Here we use negative assertion (?<!...) , which means that the current position cannot be followed by no and error .

Common usages include:

• Go forward first: (?=...)
• Negative direction first: (?<!...)
• Go backwards: (?<=...)
• Negative backwards: (?<!...)

This type of technique is very suitable for conditional matching, such as extracting content that begins or ends in a certain format.

Function application in replacement: not just static strings

re.sub() is very common, but many people only use it for simple replacements. In fact, it can also accept a function as a parameter to implement dynamic replacement.

For example, add all numbers 1:

 def add_one(match):
    return str(int(match.group()) 1)

text = "a=100, b=200"
new_text = re.sub(r"\d ", add_one, text)
# Output: a=101, b=201

This method is particularly suitable for context-based intelligent replacement, such as using different replacement rules for different modes.

Multi-line pattern matches dot number

By default, . will not match newlines. If you want to match content across lines, there are two options:

• Use the re.DOTALL flag to make . line break
• Use re.MULTILINE to make ^ and $ work on each line

For example, you want to match multiple lines of comments:

 code = """
/*
This code will be ignored*/
int main() {}
"""

comment = re.search(r"/\*.*?\*/", code, re.DOTALL)

If re.DOTALL is not added, .*? will stop when the line breaks, and the closed */ cannot be matched.

For example, you want to match the beginning words of each line:

 text = "apple\nbanana\ncherry"
words = re.findall(r"^\w ", text, re.MULTILINE)

If re.MULTILINE is not added, it will only match apple on the first row.

Basically that's it. These tips don't seem difficult, but are very practical when actually working with complex text. The key is to understand the scenarios that each function applies to, such as when to use grouping and when to use assertions. After you are proficient in it, you will find that many problems that originally needed to be dealt with multiple times can be solved in one regular way.

The above is the detailed content of Advanced Regular Expressions in Python for Text Processing. For more information, please follow other related articles on the PHP Chinese website!