Python 正则表达式：re 模块的高级用法

正则表达式是处理文本的利器，而 Python 的 re 模块提供了丰富的功能来应对各种复杂的匹配需求。本文将深入探讨 re 模块的高级用法，帮助你从「能用」进阶到「精通」。

一、编译标志：让匹配更灵活

默认情况下，正则表达式区分大小写且只匹配单行。编译标志可以改变这些行为，让表达式更符合实际需求。

常用标志速查

return bool(re.match(pattern, password))

print(validate_password("abc123")) # False（长度不足）
print(validate_password("abcdefgh")) # False（没有数字）
print(validate_password("abc12345")) # True

**场景 4：特定分隔符提取**

```python
text = "用户ID:123|姓名:张三|年龄:30"

# 使用后视断言提取冒号后的值
pattern = r'(?<=:\s*)\d+|\w+'
result = re.findall(pattern, text)
print(result)  # 输出: ['123', '张三', '30']

四、非捕获组与独立组：优化性能与逻辑

非捕获组 (?:...)

当你只需要分组但不需要捕获时，使用非捕获组可以节省内存并提高性能。

text = "2024-05-15 2025-06-20 2026-07-25"

# 捕获组会占用额外内存
pattern1 = r'(\d{4})-(\d{2})-(\d{2})'
for m in re.finditer(pattern1, text):
    print(m.groups())  # 输出元组

# 非捕获组 - 只分组不捕获
pattern2 = r'(?:\d{4})-(?:\d{2})-(?:\d{2})'
for m in re.finditer(pattern2, text):
    print(m.group())  # 只输出完整匹配

独立组 (?:...) 的区别

注意：Python 的 re 模块不支持原子组（atomic groups），但可以使用 (?>...) 语法（需要 regex 第三方库）。标准库中主要使用非捕获组来优化。

嵌套分组的性能优化

# 复杂日志解析示例
log = "2024-05-15 10:30:45 [INFO] 用户登录成功 [ID:1001]"

# 低效写法 - 过多捕获组
pattern_bad = r'(\d{4})-(\d{2})-(\d{2})\s+(\d{2}):(\d{2}):(\d{2})\s+\[(\w+)\]\s+(.+)\s+\[ID:(\d+)\]'

# 优化写法 - 只捕获需要的部分
pattern_good = r'(?:\d{4})-(?:\d{2})-(?:\d{2})\s+(?:\d{2}):(?:\d{2}):(?:\d{2})\s+\[(?P<level>\w+)\]\s+(?P<message>.+)\s+\[ID:(?P<id>\d+)\]'

match = re.match(pattern_good, log)
print(match.group('level'))   # INFO
print(match.group('message')) # 用户登录成功
print(match.group('id'))      # 1001

五、条件匹配：更复杂的逻辑

if 条件组

使用 (?(id)yes|no) 语法可以根据某个组是否匹配来选择不同的模式。

text1 = "IP地址: 192.168.1.1"
text2 = "域名: example.com"

# 如果存在引号，匹配引号内容；否则匹配非空白字符
pattern = r'(:\s*)(?(?=")(".*?"|.*?))'

for text in [text1, text2]:
    match = re.search(pattern, text)
    if match:
        print(f"值: {match.group(2)}")

使用 | 实现条件分支

text = ["$100", "€50", "£75", "INVALID"]

# 匹配美元、欧元或英镑金额
pattern = r'^(?P<currency>\$|€|£)(?P<amount>\d+)$'

for t in text:
    m = re.match(pattern, t)
    if m:
        print(f"{m.group('currency')} -> {m.group('amount')}")
    else:
        print(f"无法解析: {t}")
```

---

## 六、实用技巧与性能优化

### 1. 预编译正则表达式

如果你需要多次使用同一个表达式，**预编译**可以显著提升性能。

```python
import re

# 多次使用时 - 预编译
email_pattern = re.compile(r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}')

emails = [
    "test@example.com",
    "user.name@domain.org",
    "invalid-email"
]

for email in emails:
    if email_pattern.match(email):
        print(f"有效: {email}")
    else:
        print(f"无效: {email}")
```

### 2. 使用 `finditer` 处理大文本

```python
# 对于大文件，使用 finditer 迭代而不是 findall
with open('large_file.log', 'r') as f:
    content = f.read()

pattern = re.compile(r'\bERROR\b.*$', re.MULTILINE)

# 逐行处理，节省内存
for match in pattern.finditer(content):
    line_start = match.start()
    line_end = content.find('\n', line_start)
    print(match.group().strip())

3. 贪婪 vs 非贪婪匹配

text = "<div>第一层<div>第二层</div>剩余</div>"

# 贪婪匹配 - 匹配尽可能多
pattern_greedy = r'<div>.*</div>'
print(re.search(pattern_greedy, text).group())
# 输出: <div>第一层<div>第二层</div>剩余</div>

# 非贪婪匹配 - 匹配尽可能少
pattern_lazy = r'<div>.*?</div>'
print(re.search(pattern_lazy, text).group())
# 输出: <div>第一层<div>第二层</div>

4. 边界匹配技巧

# \b 的精确应用
words = ["cat", "catalog", "category", "bat", "batch"]

# 匹配完整的 "cat" 单词
pattern = r'\bcat\b'
for word in words:
    if re.match(pattern, word):
        print(f"匹配: {word}")
# 输出: cat

七、综合示例：构建一个简单的日志解析器

以下是一个整合多个高级用法的完整示例：

import re
from dataclasses import dataclass
from datetime import datetime
from typing import Optional

@dataclass
class LogEntry:
    timestamp: datetime
    level: str
    message: str
    request_id: Optional[str]

# 日志格式: "2024-05-15 10:30:45 [INFO] Process started [Request-ID: abc123]"
LOG_PATTERN = re.compile(r'''
    (?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})\s+
    (?P<hour>\d{2}):(?P<minute>\d{2}):(?P<second>\d{2})\s+
    \[(?P<level>INFO|WARNING|ERROR|DEBUG)\]\s+
    (?P<message>.+?)\s*
    (?:\[Request-ID:\s*(?P<request_id>\w+)\])?
    $
''', re.VERBOSE)

def parse_log_line(line: str) -> Optional[LogEntry]:
    match = LOG_PATTERN.match(line.strip())
    if not match:
        return None

    try:
        timestamp = datetime(
            int(match.group('year')),
            int(match.group('month')),
            int(match.group('day')),
            int(match.group('hour')),
            int(match.group('minute')),
            int(match.group('second'))
        )
        return LogEntry(
            timestamp=timestamp,
            level=match.group('level'),
            message=match.group('message'),
            request_id=match.group('request_id')
        )
    except ValueError:
        return None

# 测试
log_lines = [
    "2024-05-15 10:30:45 [INFO] Process started [Request-ID: abc123]",
    "2024-05-15 10:30:46 [WARNING] High memory usage detected",
    "2024-05-15 10:30:47 [ERROR] Connection failed [Request-ID: def456]"
]

for line in log_lines:
    entry = parse_log_line(line)
    if entry:
        print(f"[{entry.level}] {entry.timestamp} - {entry.message}")
        if entry.request_id:
            print(f"  Request ID: {entry.request_id}")

总结要点

掌握这些高级用法后，你将能够：

• 用 IGNORORECASE、MULTILINE 等标志灵活控制匹配行为
• 用命名组替代数字，提高代码可读性和维护性
• 用零宽断言实现精准定位，无需消耗字符
• 用非捕获组优化性能
• 预编译常用表达式，应对高频率匹配场景

正则表达式的强大在于组合。遇到复杂文本处理任务时，先分析需求，再选择合适的高级特性组合使用，往往能写出简洁而高效的解决方案。