如何优化Python中多正则表达式模式的搜索性能？

嘿，我之前处理大文件多正则匹配的时候也踩过慢到离谱的坑，给你几个亲测有效的优化思路，从简单到复杂都有：

1. 合并多个正则成一个，只扫一遍文本 #

你现在的代码是每个正则单独遍历一次整个文件，大文件的话三次遍历的开销其实很大。把三个正则合并成一个用|分隔的表达式，只需要遍历一次文本就能匹配所有类型，这是最立竿见影的优化。

不过要注意区分匹配到的是哪种类型，我们可以用命名捕获组来标记每个模式：

import re

# 合并后的正则，每个模式用命名组标记
COMBINED_PATTERN = re.compile(
    r"(?P<email>\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b)"
    r"|(?P<phone>\b\d{3}-\d{3}-\d{4}\b)"
    r"|(?P<date>\b\d{4}-\d{2}-\d{2}\b)"
)

def readfilecontent(filepath):
    with open(filepath,'r', encoding='utf-8', errors='ignore') as file:
        return file.read()

filecontent = readfilecontent("path/ToFile")
# 用finditer遍历所有匹配，判断每个匹配属于哪种类型
for match in COMBINED_PATTERN.finditer(filecontent):
    if match.group("email"):
        print(f"Email: {match.group('email')}")
    elif match.group("phone"):
        print(f"Phone: {match.group('phone')}")
    elif match.group("date"):
        print(f"Date: {match.group('date')}")

这样一来，文本只需要被扫描一次，直接减少2/3的遍历开销，大文件下速度提升非常明显。

2. 改用更高效的正则引擎：regex库 #

Python标准库的re虽然够用，但第三方的regex库（注意不是标准库的re）在性能上有很大优势，尤其是处理复杂正则和大文本时，它支持JIT编译、更高效的匹配算法。

先安装它：

pip install regex

然后只需要把代码里的import re改成import regex，其他用法几乎完全一致：

import regex

COMBINED_PATTERN = regex.compile(
    r"(?P<email>\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b)"
    r"|(?P<phone>\b\d{3}-\d{3}-\d{4}\b)"
    r"|(?P<date>\b\d{4}-\d{2}-\d{2}\b)"
)

亲测在大文件场景下，regex的匹配速度比re快2-5倍，完全不需要改业务逻辑，性价比极高。

3. 避免一次性加载整个大文件到内存 #

如果你的文件大到几GB级别，一次性读取整个文件会占用大量内存，导致系统缓存效率下降，反而变慢。可以分块读取文件，同时注意处理跨块的匹配（比如一个邮箱刚好在两个块的交界处），我们可以保留上一块的末尾部分（比如20个字符，足够覆盖你最长的匹配模式）：

import regex

COMBINED_PATTERN = regex.compile(
    r"(?P<email>\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b)"
    r"|(?P<phone>\b\d{3}-\d{3}-\d{4}\b)"
    r"|(?P<date>\b\d{4}-\d{2}-\d{2}\b)"
)

def process_large_file(filepath, chunk_size=1024*1024, overlap=20):
    """分块处理大文件，避免跨块匹配丢失"""
    last_chunk = ""
    with open(filepath, 'r', encoding='utf-8', errors='ignore') as file:
        while True:
            chunk = file.read(chunk_size)
            if not chunk:
                # 处理最后剩余的片段
                for match in COMBINED_PATTERN.finditer(last_chunk):
                    yield match
                break
            # 合并上一块的末尾和当前块，解决跨块匹配问题
            combined_chunk = last_chunk + chunk
            for match in COMBINED_PATTERN.finditer(combined_chunk):
                yield match
            # 保留当前块的最后overlap个字符，用于下一次合并
            last_chunk = chunk[-overlap:] if len(chunk) >= overlap else chunk

# 调用分块处理函数
for match in process_large_file("path/ToFile"):
    if match.group("email"):
        print(f"Email: {match.group('email')}")
    elif match.group("phone"):
        print(f"Phone: {match.group('phone')}")
    elif match.group("date"):
        print(f"Date: {match.group('date')}")

这种方式内存占用会低很多，系统能更高效地处理数据，同时不会丢失任何匹配结果。

4. 并行处理（适合多文件场景） #

如果是要处理多个大文件，可以用多进程来并行处理不同的文件（因为Python的GIL限制，多线程在CPU密集型任务上没用，多进程更合适）。比如用concurrent.futures的ProcessPoolExecutor：

import regex
from concurrent.futures import ProcessPoolExecutor

PATTERNS = {  
    "email": regex.compile(r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b"),  
    "phone": regex.compile(r"\b\d{3}-\d{3}-\d{4}\b"),  
    "date": regex.compile(r"\b\d{4}-\d{2}-\d{2}\b")  
}

def readfilecontent(filepath):
    with open(filepath,'r', encoding='utf-8', errors='ignore') as file:
        return file.read()

def process_single_file(filepath):
    """处理单个文件的函数，供进程池调用"""
    content = readfilecontent(filepath)
    results = {}
    for key, pattern in PATTERNS.items():
        results[key] = pattern.findall(content)
    return filepath, results

# 要处理的文件列表
file_paths = ["file1.txt", "file2.txt", "file3.txt"]

# 用进程池并行处理
with ProcessPoolExecutor() as executor:
    for filepath, results in executor.map(process_single_file, file_paths):
        print(f"处理完成文件: {filepath}")
        for key, matches in results.items():
            if matches:
                print(f"{key}匹配结果: {matches}")

注意：如果是单文件的话，不建议用并行，因为分块处理的复杂度高，而且进程间通信的开销可能抵消性能收益。

总结一下优先级：先合并正则+换regex库，这两个改动最小、收益最大；如果文件超大，再加分块读取；多文件场景再加并行处理。

备注：内容来源于stack exchange，提问作者Metin Bulak