接触Python这些年，我几乎每天都会和正则表达式打交道。无论是清洗爬虫抓下来的脏数据、从日志里提取关键字段，还是做表单校验，正则表达式都是绕不开的文本处理利器。很多人嫌正则难记、难写，看到一长串符号就头皮发麻，但实际上掌握核心的匹配逻辑和几个关键函数，就能解决绝大多数日常需求。这篇博文不绕弯子，直接把我实际项目里沉淀下来的使用经验和排查思路整理出来，从基础函数、语法拆解到性能优化和实战踩坑，适合刚开始接触正则的新手，也适合想系统梳理一遍、提升效率的开发者。
1. 先搞清楚：正则到底在解决什么问题
1.1 文本处理的核心矛盾
实际开发中，数据从来不是规规矩矩躺在那里等我们取用的。日志里的时间戳可能是2024-05-12 14:30:22，也可能是2024/05/12 14:30:22；用户提交的手机号可能有空格、有横线，也可能直接少了一位；网页爬下来的价格可能是￥1,299.00这种带千分位的格式。如果每次都用字符串的split()、find()去硬切，代码会写得又臭又长，而且稍微换一种数据格式就崩。
正则表达式的核心价值，是用一种描述性的语言来定义"我要匹配什么样的文本模式"，而不是具体去匹配哪一段文本。就像你告诉别人"帮我找一个以字母A开头、后面跟着3位数字的字符串"，而不是拿着一个具体字符串挨个比对。这种模式匹配能力，让处理不规则文本变成了一件可维护、可复用的事情。
1.2 Python正则的整体工作方式
Python中正则的核心模块是re。它的工作流程是：先用模式字符串编译成一个内部的状态机（Pattern对象），然后用这个状态机去扫描目标文本，找出所有符合规则的子串。这里要特别注意：正则匹配是逐字符进行的状态机匹配，不是简单的字符串包含判断，所以它对字符顺序、重复次数、位置关系都有精确的控制能力。
import re # 最常用的几个函数 pattern = r"\d{3}-\d{4}-\d{4}" # 匹配座机号码格式 text = "联系方式：010-1234-5678 或 021-8765-4321" # findall: 找出所有匹配的子串 result = re.findall(pattern, text) print(result) # ['010-1234-5678', '021-8765-4321']这个例子里的\d表示数字，{3}表示恰好出现3次，-是普通字符按字面匹配。把它们组合起来，就构成了一个能识别固定电话号码格式的模式。后面我会逐步拆解这些符号的含义，先让大家对正则的"形状"有个整体印象。
2. 几个核心函数，搞懂它们的区别就够用一半
2.1 findall、search、match的分工
这三个函数是平时用得最多的，但很多新手容易搞混它们的匹配起点和返回值。我做个对比说明：
| 函数 | 匹配起点 | 返回值 | 典型使用场景 |
|---|---|---|---|
re.match() | 必须从字符串开头匹配 | 匹配对象或None | 校验字符串是否以指定模式开头 |
re.search() | 扫描整个字符串，找第一个匹配 | 匹配对象或None | 在长文本中查找某个模式是否存在 |
re.findall() | 扫描整个字符串，找所有匹配 | 匹配子串组成的列表 | 提取文本中所有符合条件的片段 |
import re text = "订单号：A20240512，金额：299.00元，状态：已发货" # match从开头匹配，前面是"订单号"，所以匹配"订单"能成功，匹配"金额"会失败 m1 = re.match(r"订单", text) # 成功 m2 = re.match(r"金额", text) # 失败，返回None # search会扫描全文本，"金额"在中间也能找到 s = re.search(r"金额[:：](\d+\.\d+)", text) if s: print(s.group(1)) # 299.00 # findall返回所有匹配的子串，如果模式里有分组则返回分组的元组列表 prices = re.findall(r"(\d+\.\d+)元", text) print(prices) # ['299.00']值得注意的一个细节：re.match()虽然名字叫"匹配"，但它在找不到匹配时不会报错，而是返回None。所以用之前最好先if 结果:判断一下，避免对None调用方法出现AttributeError。
2.2 finditer、sub、split的进阶用法
除了上面三个，还有三个函数在实战中出场率也很高。
finditer和findall的区别是它返回一个迭代器，每次产出的是一个匹配对象而非字符串。当匹配数量很大、或者我们需要拿到匹配位置时，用finditer更合适。比如从一份几万行的日志里找出所有IP地址，同时还想知道每个IP出现在第几行：
import re log = "192.168.1.1 访问了 /api/user\n10.0.0.2 访问了 /api/login\n..." ip_pattern = re.compile(r"\b(?:\d{1,3}\.){3}\d{1,3}\b") for m in ip_pattern.finditer(log): start_line = log.count("\n", 0, m.start()) + 1 print(f"第{start_line}行发现IP: {m.group()}")re.sub()是替换函数。它的强大之处在于可以在替换文本中反向引用分组捕获的内容。比如把日志里的日期格式从2024-05-12统一改成2024/05/12：
import re text = "日期: 2024-05-12，下一次更新: 2024-06-01" new_text = re.sub(r"(\d{4})-(\d{2})-(\d{2})", r"\1/\2/\3", text) print(new_text) # 日期: 2024/05/12，下一次更新: 2024/06/01split()是按模式分割字符串，和字符串自带的split()相比，它能按不规则的分隔符切分。比如处理用逗号、空格、竖线混合分隔的数据行：
import re line = "张三, 25 | 程序员 | 北京" fields = re.split(r"[,|，]\s*", line) print(fields) # ['张三', '25', '程序员', '北京']2.3 为什么要用re.compile
很多人写正则都是直接re.findall(pattern, text)一把梭，代码能跑就行。但在循环次数多、模式复用频繁的场景下，建议先re.compile()成Pattern对象再调用。原因很简单：每次直接调用re.findall()，模块内部都要重新编译一次模式字符串；而compile()只编译一次，后面复用同一个Pattern对象。
import re # 不推荐的写法：在循环里反复编译 patterns = [r"\d+", r"[a-z]+", r"\w+@\w+\.\w+"] for text in text_list: for p in patterns: re.findall(p, text) # 每次都会重新编译 # 推荐的写法：提前编译一次 compiled_patterns = [re.compile(p) for p in patterns] for text in text_list: for pat in compiled_patterns: pat.findall(text) # 直接复用编译后的状态机从工程效率角度看，compile的另一个好处是代码更整洁。同一个正则如果需要在一个函数里的多个地方使用，集中定义在顶部，维护时只需改一处，不用到处找散落的模式字符串。
3. 核心语法与匹配逻辑拆解
3.1 字符类与预定义字符集
正则最基础的单位是"匹配一个字符"。普通字符比如a、1、你，就是按字面去匹配。但更多时候我们想匹配的是"某一类字符"，这时就需要字符类和预定义字符集。
| 语法 | 含义 | 等价写法 | 示例匹配 |
|---|---|---|---|
\d | 任意数字 | [0-9] | 5、8、0 |
\D | 任意非数字 | [^0-9] | a、空格、好 |
\w | 字母、数字、下划线 | [a-zA-Z0-9_] | A、_、9 |
\W | 非字母数字下划线 | [^a-zA-Z0-9_] | @、#、空格 |
\s | 空白字符（空格、tab、换行等） | [ \t\n\r\f\v] | 空格、\t、\n |
\S | 非空白字符 | [^ \t\n\r\f\v] | a、3、你 |
. | 除换行符以外的任意字符（在DOTALL模式下包含换行） | 无 | a、1、你、空格 |
字符类用方括号[]表示，它匹配的是方括号内任意一个字符。比如[abc]匹配a、b或c；[a-z]匹配任意小写字母；[^0-9]匹配任意非数字。注意：^在字符类内部表示"否定"，但在正则整体开头表示"从字符串开头匹配"，含义完全不同，不要搞混。
import re # 匹配一个IPv4地址的各个部分（简版） parts = re.findall(r"\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}", "服务器IP: 192.168.10.5 备用: 10.0.0.1") print(parts) # ['192.168.10.5', '10.0.0.1']上面例子里的\.表示匹配一个普通点号。因为点号在正则里有特殊含义（匹配任意字符），要匹配字面意义上的点，需要加反斜杠转义。这个转义逻辑在正则里普遍适用：任何有特殊含义的符号，想要匹配它自身，都要在前面加\。
3.2 量词：控制字符重复的次数
光能匹配一类字符还不够，我们还要控制它出现几次。量词用{}、*、+、?来定义：
{n}：恰好出现n次，比如\d{4}匹配4位数字{n,}：至少出现n次，比如\d{2,}匹配2位及以上的数字{n,m}：出现n到m次，比如\d{1,3}匹配1到3位数字*：出现0次或多次，等价于{0,}+：出现1次或多次，等价于{1,}?：出现0次或1次，等价于{0,1}
import re # 匹配手机号（简单版，以1开头，第二位是3-9，后面9位数字） pattern = r"1[3-9]\d{9}" text = "用户手机：13812345678，座机：010-87654321" result = re.findall(pattern, text) print(result) # ['13812345678']这里量词默认是贪婪模式：在有多种匹配可能时，它会尽可能多地匹配字符。比如文本aaa，用a+去匹配，它会吃掉整个aaa；如果后面紧跟a{2}，贪婪匹配会引起回溯调整。理解贪婪模式很重要，因为很多看似"匹配结果不对"的问题，根源都在这里。
3.3 贪婪、非贪婪与回溯机制
用一个实际案例来说明。假设要提取HTML里的<b>标题</b>内容，新手很容易写成<b>.*</b>。这个模式在文本<b>小明</b> 和 <b>小红</b>上运行时，贪婪模式的.*会先尽可能多地匹配，直到最后一个</b>才停下来，结果一次就把整段文本都匹配了，得不到两个单独的标题。
import re text = "<b>小明</b> 和 <b>小红</b>" # 贪婪模式 greedy = re.findall(r"<b>.*</b>", text) print(greedy) # ['<b>小明</b> 和 <b>小红</b>'] # 非贪婪模式：在量词后面加? lazy = re.findall(r"<b>.*?</b>", text) print(lazy) # ['<b>小明</b>', '<b>小红</b>']非贪婪模式的写法就是在*、+、?、{n,m}后面加一个?（例如.*?），表示"尽可能少地匹配"。当它匹配到<b>小明</b>中的第一个</b>时就停下来，然后继续从后面的位置开始下一轮查找。
理解回溯机制：正则引擎在匹配过程中，如果当前分支走不通，会回退到之前的选择点换一条路重试。贪婪模式默认先选最长路径，不行再逐步缩短；非贪婪模式先选最短路径，不行再逐步延长。这种自动回溯通常没问题，但如果模式写得不好（大批量.*嵌套），可能产生灾难性回溯，导致性能急剧下降。后面性能优化部分我会专门讲这个问题。
3.4 分组捕获与反向引用
括号()在正则里有两个作用：把一部分模式组合成一个整体，同时捕获这部分匹配到的内容。捕获的内容可以在后续代码、替换操作中复用。
import re text = "张三的邮箱是 zhangsan@example.com，李四的是 lisi@test.org" pattern = r"(\w+)@(\w+)\.(\w+)" for m in re.finditer(pattern, text): print("完整邮箱:", m.group(0)) print("用户名:", m.group(1)) print("域名:", m.group(2)) print("后缀:", m.group(3))m.group(0)永远代表整个匹配；m.group(1)起才是各个括号捕获的内容。如果不想让括号"捕获"而只想分组，可以使用(?:...)，比如(?:ab)+表示把ab作为一个整体重复多次，但不单独留下捕获记录，这样在findall()时不会干扰返回值结构。
反向引用用于匹配"前面已经出现过的内容"是否再次出现。最经典的例子是判断HTML标签是否成对：
import re text = "<p>第一段</p> <div>容器</div>" # \1 引用第一个分组捕获的标签名 pattern = r"<(/?)(\w+)>[^<]*</\1\2>" matches = re.findall(pattern, text) print(matches) # [('', 'p'), ('', 'div')]注意这里的\1是引用了第一个括号捕获的内容（开头标签的斜杠部分），\2引用了标签名。看到</p>时，反斜杠/通过\1匹配，标签名校验通过。这个技巧在写HTML解析器、日志结构化处理时特别实用。
4. 实战案例：从真实场景中拆解正则的运用
4.1 日志分析：提取关键字段并统计
拿一段nginx访问日志来练手。日志格式大概是：
127.0.0.1 - - [12/May/2024:14:30:22 +0800] "GET /api/user HTTP/1.1" 200 1234 "Mozilla/5.0"我们要一次性提取出IP、时间、请求方法、路径、状态码和响应大小：
import re from collections import Counter log_line = '127.0.0.1 - - [12/May/2024:14:30:22 +0800] "GET /api/user HTTP/1.1" 200 1234 "Mozilla/5.0"' pattern = re.compile( r'(?P<ip>\d+\.\d+\.\d+\.\d+)' r'.*?\[(?P<time>[^\]]+)\]' r'.*?"(?P<method>\w+) (?P<path>\S+) HTTP/[\d.]+" ' r'(?P<status>\d{3}) (?P<size>\d+)' ) m = pattern.search(log_line) if m: print("IP:", m.group("ip")) print("时间:", m.group("time")) print("方法:", m.group("method")) print("路径:", m.group("path")) print("状态码:", m.group("status")) print("响应大小:", m.group("size"))这里用了命名分组(?P<name>...)，比用数字索引清晰很多，尤其是在分组多的时候。从日志里提取字段的核心思路是：先用.*?跳过不关心的内容，再用(?P<name>...)捕获目标字段，最后用search()定位第一行匹配。
统计所有IP的出现次数只需要另加一个Counter：
lines = [...] # 假设有多行日志 ip_counts = Counter() for line in lines: ip = pattern.search(line) if ip: ip_counts[ip.group("ip")] += 1 for ip, count in ip_counts.most_common(5): print(f"{ip}: {count}次")4.2 数据清洗：统一格式和脱敏
爬虫或外部系统拿到的数据往往鱼龙混杂。手机号可能写成138 1234 5678、138-1234-5678、+86 13812345678；日期各种分隔符都有。处理思路分两步：先把数据规整成统一格式，再对敏感信息脱敏。
import re raw_data = [ "联系电话: 138 1234 5678, 备用: +86 138-1234-5678", "联系电话: 13912345678", ] def normalize_phone(text): # 先提取所有数字和加号 digits = re.sub(r"[\s\-]", "", text) # 去掉国际区号前缀 digits = re.sub(r"^\+?86", "", digits) # 统一为 3-4-4 格式 return re.sub(r"(\d{3})(\d{4})(\d{4})", r"\1 \2 \3", digits) for item in raw_data: phones = re.findall(r"\+?\d[\d\s-]{8,}", item) for p in phones: print(normalize_phone(p.strip()))脱敏的核心思路是把中间几位替换成星号。比如姓名、身份证号、银行卡号，保留首尾部分：
def mask_name(name): if len(name) == 2: return name[0] + "*" return name[0] + "*" * (len(name) - 2) + name[-1] def mask_phone(phone): # 把中间四位替换为**** return re.sub(r"(\d{3})\d{4}(\d{4})", r"\1****\2", phone) print(mask_name("张大壮")) # 张*壮 print(mask_phone("13812345678")) # 138****5678这里用\1****\2在替换字符串中同时保留了第一个和第三个分组，中间用星号替代。这种脱敏方式在数据测试、日志脱敏场景下非常常用，既保留数据格式，又不会泄露隐私。
4.3 表单校验：写一个复合校验的正则
正则也是表单校验的基础工具。以邮箱校验为例，一个"够用"而非"完美"的校验模式是：
import re email_pattern = re.compile(r"^[\w.+-]+@[\w-]+\.[\w.-]+$") def validate_email(email): if email_pattern.match(email): return True return False注意几个设计细节：
- 开头和结尾用
^和$锚定，确保整个字符串都符合规则，而不是只匹配某个片段 [\w.+-]+表示用户名部分允许字母、数字、下划线、点、加号、减号@后面是域名部分，[\w-]+允许字母数字和减号- 最后
\.[\w.-]+匹配顶级域名，比如.com或.co.uk match()自带从头匹配的特性，但加上^和$后边界更明确
手机号校验同理：
phone_pattern = re.compile(r"^1[3-9]\d{9}$") if phone_pattern.match("13812345678"): print("合法手机号") else: print("非法手机号")这里1[3-9]\d{9}限定了第一位是1、第二位是3到9、后面9位数字，总共11位。写校验正则的关键是"锚定首尾"，否则search()模式可能只匹配到长串数字中间的一段，造成误判。
5. 性能优化与常见坑
5.1 灾难性回溯与自我保护
正则性能杀手主要来自嵌套的量词和回溯。比如模式(a+)+匹配一串aaaaaaaaaaaa时，如果字符串末尾多了一个不该出现的字符，引擎会尝试各种分组方式，反复回溯，时间复杂度可能指数级增长。
import re import time text = "a" * 30 + "!" # 危险模式：嵌套量词 + 回朔 bad_pattern = re.compile(r"(a+)+$") start = time.time() bad_pattern.search(text) print(f"耗时: {time.time() - start:.2f}秒") # 随便感受一下，可能秒级遇到这种问题的策略：
- 尽量用原子的、明确的字符类代替
.*，避免大范围模糊匹配 - 使用非贪婪量词
.*?，能减少回溯次数 - 在调试阶段通过
re.DEBUG查看编译过程，发现可疑的嵌套结构 - 如果正则过于复杂，考虑拆分成多步简单正则，而不是写一个"万能大正则"
re.DEBUG是个很有用的内置调试参数，能打印出编译后的状态机指令。虽然读起来不太友好，但能直观看到模式的展开结构，定位"是不是嵌套层数太多"。
5.2 flags的作用与选择
正则模块提供了一些编译标志，控制匹配行为。我用得比较多的是这几个：
| 标志 | 作用 | 适用场景 |
|---|---|---|
re.I | 忽略大小写 | 匹配邮件、URL等不区分大小写的场景 |
re.M | 多行模式，让^和$匹配每行的开头/结尾 | 逐行分析配置文件、日志 |
re.S | DOTALL，让.匹配包括换行符在内的任意字符 | 匹配跨行的HTML块、描述文本 |
re.X | 忽略模式中的空白字符和注释 | 写复杂正则时提高可读性 |
import re text = """第一条: abc 第二条: ABC 第三条: AbC""" # 忽略大小写，同时多行模式下 ^ 匹配每一行 for m in re.finditer(r"^第.条:\s*\w+", text, flags=re.I | re.M): print(m.group())尤其是re.X，强烈建议在写长正则时使用。它允许在模式中加注释和换行，让正则代码像普通代码一样容易读：
pattern = re.compile(r""" ^ # 从行首开始 (?P<ip>\d+\.\d+\.\d+\.\d+) # IP地址 [ ] (?P<user>\S+) # 用户名，非空白字符 [ ] \[(?P<time>[^\]]+)\] # 方括号包裹的时间戳 """, re.X)5.3 中文与编码陷阱
Python正则默认对Unicode支持得不错，\w能匹配中文字符（取决于字符串类型和正则标志）。但有两个常见的坑：
第一个坑是\w在Python3中默认匹配Unicode字母数字，包括中文、日文、韩文。如果你只想匹配英文和下划线，必须显式写[a-zA-Z0-9_]或加上re.ASCII标志。
import re # 默认 \w 匹配中文 print(re.findall(r"\w+", "你好world")) # ['你好world'] # 限制为ASCII后，中文不匹配 print(re.findall(r"\w+", "你好world", flags=re.ASCII)) # ['world']第二个坑是正则匹配中文时不要在模式里直接写中文标点全角半角混用。常见做法是字符类里同时包含全角和半角形式，比如[:：]表示匹配半角冒号或全角冒号，[，,]表示匹配全角或半角逗号。这在处理用户输入时特别贴心，因为用户往往不会注意输入法状态。
6. 工具选型与调试思路
6.1 在线调试工具的使用
写复杂正则时，我不建议直接在代码里一遍遍试错。在线正则调试工具（比如常见的regex101等）可以实时显示匹配结果、分组层级和回溯步骤，对于理解模式行为非常有帮助。
调试的核心思路：
- 先把文本准备好，确认要匹配的目标是什么样子的
- 输入正则，查看哪些文本被高亮匹配
- 看右边的分组面板，确认每个括号捕获的内容是不是你想要的
- 如果匹配结果不对，先移除开头末尾的锚定符，逐步缩小问题范围
比如调试时发现模式匹配到了意外的长串，第一反应检查贪婪与非贪婪；发现某一部分确实没捕获到，检查那部分的括号是不是写成了(?:...)；发现中文没匹配上，检查是否受re.ASCII影响。
6.2 从需求到正则的拆解方法
很多新手拿到需求直接上手写正则，结果越写越乱。我的习惯是分三步走：
第一步，把"人话需求"翻译成"结构需求"。比如"提取URL中的域名"，先明确URL的常见样式：可能有https://头、可能没有协议头、可能有端口号、可能带路径。把这些可能性列成清单。
第二步，用语言描述每种可能性的匹配模式，不要急着写代码。比如"域名部分是一串字母数字和点号组成，结尾不能是点号"。
第三步，写正则。遵循从"粗"到"细"的原则：先用最宽泛的模式把整体抓出来，再逐一添加限定条件，最后测试边界情况。
下面是我实际处理URL域名提取的过程：
import re urls = [ "https://www.example.com/path?a=1", "http://sub.domain.co.uk:8080/index", "example.org", "ftp://files.example.net/pub", ] domain_pattern = re.compile(r"(?:https?://)?([a-zA-Z0-9][a-zA-Z0-9.-]+\.[a-zA-Z]{2,})") for url in urls: m = domain_pattern.search(url) if m: print(m.group(1))这个模式的构建逻辑是：先把可能的协议头(?:https?://)?放在前面做可选匹配，然后用[a-zA-Z0-9][a-zA-Z0-9.-]+匹配域名主体，最后\.[a-zA-Z]{2,}要求域名必须以点号结尾且顶级域名至少2个字母。分步拆解的好处是每一步都有明确的验证标准，不会一上来就被复杂的正则搞晕。
7. 常见问题排查速查与日常维护建议
7.1 常见问题速查表
我整理了平时最容易踩到的几个问题，做成速查表方便直接定位：
| 问题现象 | 可能原因 | 解决方案 |
|---|---|---|
re.match()一直返回None | 文本开头不符合模式 | 改用re.search()，或者检查^锚定 |
| 匹配结果比预期长 | 贪婪量词.*导致 | 改用.*?非贪婪模式 |
| 点号匹配不到换行 | .默认不匹配\n | 加re.S标志，或用[\s\S]替代. |
| 捕获分组取不到值 | 写了(?:...)非捕获组 | 改成(...)捕获组 |
\d匹配不到全角数字 | 全角数字不在\d范围 | 字符类显式加上全角数字，如[0-9０-９] |
| 正则匹配特别慢 | 嵌套量词导致灾难性回溯 | 拆分成多个正则，减少.*嵌套 |
| 替换时反斜杠数量不对 | 替换字符串中\需要转义 | 用r"..."原始字符串，或使用函数作为替换 |
7.2 维护正则的思路
正则代码的特点是"写的时候费劲，看的时候更费劲"。为了保证半年后还能看懂自己写的东西，建议从三个角度做好维护：
第一，命名分组。用(?P<user>\w+)而不是(\w+)，在group()调用时按名字取值，减少数字索引的混乱。
第二，拆分复杂模式。如果一次要提取十几个字段，考虑拆成多个正则分别匹配：先提取小块，再在块里做二次正则。宁可多写几行代码，也别堆一个阅读性极差的巨型模式。
第三，搭配注释。用re.X模式写注释，或至少在模式字符串上方加一段说明，标明"这段正则用来干什么、输入样本和期望输出是什么"。我自己的习惯是把每个模式对应的正反测试样本放在正则旁边，方便回归。
# 模式说明： # 匹配格式 YYYY-MM-DD 或 YYYY/MM/DD，忽略时间部分 date_pattern = re.compile( r""" (?P<year>\d{4}) # 4位年份 [/-] # 分隔符，支持横线或斜杠 (?P<month>\d{1,2}) # 1-2位月份 [/-] # 分隔符 (?P<day>\d{1,2}) # 1-2位日期 """, re.X )平时维护老项目时，遇到看不明白的正则，我的经验是拿几组测试数据跑一遍，把findall结果打印出来观察，比直接盯着字符串硬读高效得多。正则这东西，跑起来看结果，比在脑子里模拟状态机要直观得多。
8. 一个完整的综合案例：日志统计工具
最后分享一个我在实际工作中写过的日志字段提取脚本。它的功能是读取应用日志，提取出每行日志的时间戳、日志级别、错误码和描述信息，然后按错误码统计出现次数。
需求拆解：
- 日志格式类似：
2024-05-12 14:30:22 ERROR [4002] 数据库连接超时，重试3次后放弃 - 级别有
INFO、WARN、ERROR几种 - 错误码是方括号里的4位数字，个别行的错误码是5位
- 描述信息可能包含中文、空格、冒号等
我最终写出的正则是：
import re from collections import Counter log_pattern = re.compile( r""" ^(?P<time>\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2}) # 时间戳 \s+ (?P<level>INFO|WARN|ERROR) # 日志级别 \s+ \[(?P<code>\d{4,5})\] # 错误码 \s+ (?P<message>.+)$ # 描述信息 """, re.VERBOSE ) def analyze_log(filename): code_counter = Counter() error_lines = [] with open(filename, "r", encoding="utf-8") as f: for line in f: line = line.strip() m = log_pattern.match(line) if not m: continue code = m.group("code") code_counter[code] += 1 if m.group("level") == "ERROR": error_lines.append((m.group("time"), code, m.group("message"))) return code_counter, error_lines # 使用示例 code_counter, error_lines = analyze_log("app.log") print("错误码统计:", code_counter.most_common(10)) for time, code, msg in error_lines[:5]: print(f"[{time}] 错误码{code}: {msg}")这里有几个细节值得总结：
re.VERBOSE让整个模式的逻辑一目了然，每条分支都有注释- 用
match()配合^锚定，保证每行从头开始解析，不会漏掉前面内容 .+在re.VERBOSE下默认不匹配换行，所以能安全地从每行提取出完整描述信息- 用
Counter做统计，一行代码搞定频次排序
需要说明的是，这个脚本在处理几万行级别的日志时表现很好，但正则的匹配仍会消耗一定CPU。如果日志量上百万行，可以考虑先按行号切块、使用多进程并行处理，或者改用更轻量的文本解析方式。正则适合的是"模式复杂但单条匹配成本可控"的场景。
我自己用了这么多年正则，最大的体会是：不要试图记住所有语法，真正重要的其实是那十几个核心概念。抓住匹配起点、贪婪与非贪婪、分组捕获、转义这几个关键点，再配合在线工具不断调试，就能覆盖绝大多数开发场景。正则这门技术，练得越多越顺手，写得不顺的时候，不妨把模式先拆开，一段一段验证，逐步组合，比闷头硬写要靠谱得多。
