要说Python里哪个工具最实用，正则表达式绝对排得上号。它就像文本世界里的瑞士军刀——匹配、查找、替换字符串中的特定模式，干起活来效率极高。而Python通过内置的re模块，把这把刀递到了每位开发者手里。

import re

常用元字符

元字符是什么？就是正则表达式里那些拥有“特异功能”的符号。掌握它们，就等于拿到了入门钥匙。下面这张表是基本功，值得收藏：

• .：匹配任意单个字符（换行符除外）。
• ^：锚定字符串的开头。
• $：锚定字符串的结尾。
• *：匹配前面的字符零次或多次。
• +：匹配前面的字符一次或多次。
• ?：匹配前面的字符零次或一次。
• {n}：匹配前面的字符恰好 n 次。
• {n,}：匹配前面的字符至少 n 次。
• {n,m}：匹配前面的字符至少 n 次，至多 m 次。
• []：匹配括号内的任意一个字符。
• |：表示“或”关系。

举个例子，用a.b这个模式去匹配字符串"aab abb acb"，看看会发生什么？

import re
pattern = r"a.b"
text = "aab abb acb"
matches = re.findall(pattern, text)
print(matches)  # 输出: ['aab', 'abb', 'acb']

字符类

字符类是一个字符集合，专门用来匹配“这一类”中的任意一个。无论是数字、字母还是空白，全都能搞定：

• \d：匹配任意数字，等价于[0-9]。
• \D：匹配任意非数字。
• \w：匹配任意字母、数字或下划线。
• \W：匹配任意非字母、数字或下划线。
• \s：匹配任意空白字符（空格、制表符、换行符等）。
• \S：匹配任意非空白字符。

比如，你想从一大段文本里找出美国社保号（格式是123-45-6789），一句正则就能搞定：

pattern = r"\d{3}-\d{2}-\d{4}"
text = "My SSN is 123-45-6789."
match = re.search(pattern, text)
if match:
    print("Found SSN:", match.group())  # 输出: Found SSN: 123-45-6789

分组与捕获

圆括号()不光能分组，还能“捕获”匹配到的内容。捕获到的内容通过group()方法按编号提取，非常灵活：

pattern = r"(\d{3})-(\d{2})-(\d{4})"
text = "My SSN is 123-45-6789."
match = re.search(pattern, text)
if match:
    print("Full match:", match.group(0))  # 输出: Full match: 123-45-6789
    print("Group 1:", match.group(1))  # 输出: Group 1: 123
    print("Group 2:", match.group(2))  # 输出: Group 2: 45
    print("Group 3:", match.group(3))  # 输出: Group 3: 6789

非捕获分组

有些场景下，我们只是想分组，并不需要捕获内容。这时候就用(?:...)语法，既保持了逻辑分组，又省去了不必要的内存开销：

pattern = r"(?:\d{3})-(\d{2})-(\d{4})"
text = "My SSN is 123-45-6789."
match = re.search(pattern, text)
if match:
    print("Full match:", match.group(0))  # 输出: Full match: 123-45-6789
    print("Group 1:", match.group(1))  # 输出: Group 1: 45
    print("Group 2:", match.group(2))  # 输出: Group 2: 6789

贪婪与非贪婪匹配

默认情况下，正则表达式是“贪婪”的——它会尽可能多地匹配字符。但你只要在量词后面加个?，它立刻变得“非贪婪”，点到为止：

pattern_greedy = r"<.*>"
pattern_non_greedy = r"<.*?>"
text = ""
match_greedy = re.search(pattern_greedy, text)
match_non_greedy = re.search(pattern_non_greedy, text)
print("Greedy match:", match_greedy.group())  # 全吃掉了
print("Non-greedy match:", match_non_greedy.group())  # 只吃第一个标签

查找与替换

re.sub()是处理文本替换的得力干将。比如想把字符串里所有数字都换成"X"：

pattern = r"\d+"
text = "There are 3 apples and 5 oranges."
result = re.sub(pattern, "X", text)
print(result)  # 输出: There are X apples and X oranges.

编译正则表达式

如果一个正则表达式要反复使用，别每次都重新解析。用re.compile()把它编译成re.Pattern对象，性能会有明显提升：

pattern = re.compile(r"\d{3}-\d{2}-\d{4}")
text = "My SSN is 123-45-6789."
match = pattern.search(text)
if match:
    print("Found SSN:", match.group())  # 输出: Found SSN: 123-45-6789

多行匹配

默认情况下，^和$只匹配整个字符串的开头和结尾。但如果加上re.MULTILINE标志，它们就能分别匹配每一行的开头和结尾了：

pattern = r"^\d+"
text = "1 apple\n2 oranges\n3 bananas"
matches = re.findall(pattern, text, re.MULTILINE)
print(matches)  # 输出: ['1', '2', '3']

忽略大小写

配合re.IGNORECASE标志，正则匹配时不再区分大小写——这在处理用户输入时尤其有用：

pattern = r"apple"
text = "Apple is a fruit."
match = re.search(pattern, text, re.IGNORECASE)
if match:
    print("Found:", match.group())  # 输出: Found: Apple

正则表达式的高级技巧

正向预查

(?=...)——匹配一个后面跟着特定模式的位置，但不消耗那个模式本身。例如，要匹配“后面跟着‘dollars’的数字”：

pattern = r"\d+(?= dollars)"
text = "I ha ve 100 dollars."
match = re.search(pattern, text)
if match:
    print("Found:", match.group())  # 输出: Found: 100

负向预查

(?!...)——与正向预查相反，它匹配后面不跟着特定模式的位置：

pattern = r"\d+(?! dollars)"
text = "I ha ve 100 euros."
match = re.search(pattern, text)
if match:
    print("Found:", match.group())  # 输出: Found: 100

命名分组

用(?P...)可以给捕获的分组起个名字。后续用名字引用，代码的可读性瞬间拉满：

pattern = r"(?P\d{3})-(?P\d{2})-(?P\d{4})"
text = "My SSN is 123-45-6789."
match = re.search(pattern, text)
if match:
    print("Area:", match.group("area"))  # 输出: Area: 123
    print("Group:", match.group("group"))  # 输出: Group: 45
    print("Serial:", match.group("serial"))  # 输出: Serial: 6789

调试与性能优化

正则表达式写起来爽，但调起来也可能让人头疼。不妨试试re.DEBUG标志，它能把正则表达式引擎的解析过程打印出来，帮你理清思路：

pattern = re.compile(r"\d{3}-\d{2}-\d{4}", re.DEBUG)

至于性能，有几个小诀窍：尽量用非贪婪匹配；避免嵌套量词；预编译正则表达式；需要遍历大量匹配时，用re.finditer()代替re.findall()，前者是惰性求值，能省不少内存：

pattern = re.compile(r"\d{3}-\d{2}-\d{4}")
text = "My SSN is 123-45-6789."
for match in pattern.finditer(text):
    print("Found SSN:", match.group())

正则表达式的常见应用场景

验证电子邮件地址

虽然电子邮件的完整验证很复杂，但一个简单的正则就能过滤掉大部分无效输入：

pattern = r"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$"
email = "example@example.com"
if re.match(pattern, email):
    print("Valid email address")
else:
    print("Invalid email address")

提取 URL

从文本中抓取网址？一行代码的事儿：

pattern = r"https?://(?:www\.)?\S+"
text = "Visit https://example.com for more info."
matches = re.findall(pattern, text)
print(matches)  # 输出: ['https://example.com']

提取 HTML 标签

处理简单的HTML时，正则也能发挥余热——比如抓取所有标签名和其中的内容：

pattern = r"<(\w+)[^>]*>(.*?)"
html = "
Title
Paragraph
"
matches = re.findall(pattern, html)
print(matches)  # 输出: [('h1', 'Title'), ('p', 'Paragraph')]

总结

正则表达式是文本处理领域的核心技能，基础语法加上高级技巧，足以应对绝大多数模式匹配和替换任务。从简单的数据清洗到复杂的文本解析，只要用得巧妙，它总能给你带来惊喜。说到底，它是任何一位Python开发者工具箱里不可或缺的利器。