正则表达式从入门到精通

可视化演示

展示正则表达式三模式：NFA有限状态机匹配过程、贪婪与非贪婪回溯机制对比、字符类与量词匹配规则，递进呈现从理论到实践的核心原理。

字符匹配基础

分拣机器人上班第一天，班长递给它一张“分拣指令卡”，第一条写着：“凡是圆形的包裹放到 1 号道。”在这条流水线上，每个快递包裹就是文本里的一个字符，而指令卡就是我们要学的正则表达式。要学会写指令卡，第一步是学会“认包裹”——用字符类描述一类字符。

正则里的字符类（Character Class）用方括号表示，[abc] 表示“a、b、c 三个字符中的任意一个”。这和指令卡上写“圆形、方形、三角形任一形状”是同一个逻辑：一个位置，多种可能。再配上范围连字符，[0-9] 表示任意数字，[a-zA-Z] 表示任意字母，写起来就像把一堆同类包裹归到一个筐里。

正则还内置了三个常用预定义类：\d 代表数字、\w 代表单词字符、\s 代表空白。若在方括号开头放一个 ^，含义立刻反转，[^0-9] 表示“非数字”。字面量则是最朴素的认包裹：指令卡上写着“苹果”，包裹就必须是“苹果”二字，多一个偏旁都不行。

\displaystyle \text{[0-9]} \equiv \{0,1,\ldots,9\},\quad \text{[^0-9]} \equiv \overline{\{0,\ldots,9\}}

1. 字符类 [0-9]：方括号内的范围写法，匹配 0 到 9 中的任意一个数字字符，等价于 \d。

$$\displaystyle \text{[0-9]} = \{0, 1, \ldots, 9\}$$

2. 取反 [^0-9]：^ 在方括号内表示“除了这些”，匹配非数字的任意字符。

\displaystyle \text{[^0-9]} = \overline{\{0,\ldots,9\}}

3. 预定义 \d：\d 是 [0-9] 的简写，让指令卡更短更清晰。

$$\displaystyle \backslash d \equiv \text{[0-9]}$$

就这样，机器人靠“圆形、方形、星形”的分类方法认出了大大小小的包裹。但传送带上的包裹往往是一串一串出现的，下一节我们看看怎么让机器人一次处理一小串。

量词与贪婪

一台只会“认一个”的机器人效率太低。班长在指令卡上加了新规则：“连续出现 3 个以上的圆形包裹，打包丢到 2 号道。”这里的“3 个以上”就是量词，它告诉机器人前面的规则要重复多少次。

正则的量词让一个字符类或分组可以重复匹配：* 表示 0 次或多次，+ 表示 1 次或多次，? 表示 0 次或 1 次，{n,m} 则是精确指定 n 到 m 次。比如 \d+ 表示“连续的数字串”，提取日期、价格时几乎是万能钥匙。

正则默认是贪婪的（Greedy），像贪心的机器人一样，总想在规则允许的范围内多吞几个字符。比如 a.*b 匹配 "a...b...b" 时，会吞到最后一个 b 才停。如果希望它“够用就好”，在量词后加一个 ?，写成 a.*?b，它会找到第一个 b 就收手，这叫非贪婪匹配（也叫懒惰匹配）。

$$\displaystyle a^{+}: \max\{k \geq 1\}, \quad a^{+?}: \min\{k \geq 1\}$$

1. 贪婪量词 +：默认情形，a+ 会尽可能多地吞下连续的 a，直到无法继续。

$$\displaystyle a^{+}: k \to \max$$

2. 非贪婪 +?：在量词后追加 ?，改为从最少次数开始试探，不行再加。

$$\displaystyle a^{+?}: k \to \min$$

原来机器人并不是越贪心越好，有时候“见好就收”反而更快完成任务。不过它又有了新疑问：怎么才能确定自己站在传送带的开头还是末尾呢？下一节就来安装定位标记。

锚点与边界

分拣车间的传送带两端贴着醒目的标签：一头写着“起点”，一头写着“终点”。机器人处理包裹前都会先看一眼标签，确认自己是不是在开头或结尾。正则里的锚点（Anchor）就扮演了这两个标签。

^ 匹配字符串的开头，$ 匹配结尾。比如 ^2025 能匹配以“2025“开头的行，常用于过滤日志时间戳。\b 则是一个更精细的位置标记——单词边界，它能在”cat“这个词出现的地方定位，却不误伤”concatenate”里的前缀 cat。

\B 是 \b 的反面，匹配非单词边界。在多行模式下，^ 和 $ 会分别匹配每一行的开头和结尾，而不再只盯着整个字符串的首尾。分析多行日志文件时，这几乎是必备能力。

$$\displaystyle \text{行首: pos} = 0, \quad \text{行尾: pos} = |\text{text}|$$

1. 行首锚点 ^：^ 断言当前位置位于文本起点，它自身不消耗任何字符。

$$\displaystyle \text{start}: \text{pos} = 0$$

2. 行尾锚点 $：$ 断言当前位置是文本终点，匹配会一直延伸到末尾。

$$\displaystyle \text{end}: \text{pos} = n$$

3. 单词边界 \b：\b 断言当前位置一侧是单词字符而另一侧不是。

$$\displaystyle \backslash b: \text{单词字符与非单词字符的接缝处}$$

有了起点、终点和单词边界的标签，机器人在传送带上再也不会跑错位置了。不过，面对一整组包裹时，它还需要学会把它们捆在一起——下一节的分组。

分组与捕获

班长要求在传送带上认出“三个连在一起的包裹”，并作为一票货记录下来。机器人把三件包裹用胶带缠成一捆，在运单上记作“第 1 组”——这就是正则里的分组（Group）：把多个字符打包成一个整体，还能给这个包编上号。

用圆括号 ( ) 就能创建捕获分组。分组后可以用量词作用于整个包，例如 (ab)+ 匹配连续的 ab。捕获的内容会被引擎记住，你可以用回溯引用 \1 在模式里引用第 1 组的内容，(ab)\1 匹配的就是"abab"。

如果只想分组却不想捕获，可以改用非捕获分组 (?:...)，它不消耗内存记录内容。命名分组 (?P<name>...)（Python 写法）让提取结果更可读，配合 (?P=name) 按名引用。回溯引用让正则有了记忆，比如匹配重复单词：\b(\w+)\s+\1\b 就能找出"the the"这样的笔误。

$$\displaystyle (\text{ab})\text{+}\backslash 1$$

1. 捕获分组 (ab)：圆括号把 ab 聚合为一个整体，引擎自动给它编号 1。

$$\displaystyle \text{group}(1) = (\text{ab})$$

2. 回溯引用 \1：\1 表示“再匹配一遍第 1 组捕获到的内容”，实现重复约束。

$$\displaystyle \backslash 1 = \text{第 1 组捕获值}$$

胶带既能打包也能拆包，机器人现在既能捆包裹，又能指着运单说“第 1 组和第 2 组长得一样”。但有些时候，它不想碰包裹，只想远远地看一眼后面来的是什么——零宽断言登场。

零宽断言

传送带上方装了一只扫描眼，它能提前看到包裹后面跟着什么，但永远不会动手拿包裹。这只“只看不动”的扫描眼，在正则里叫零宽断言（Zero-Width Assertion）。

零宽断言本身不消费任何字符，它只“查看”当前位置前后是否满足某个模式。最常见的两类是前瞻（Lookahead）和后顾（Lookbehind）。正向前瞻 (?=pattern) 断言“后面必须跟着 pattern”；负向前瞻 (?!pattern) 断言“后面不能是 pattern”。

后顾断言 (?<=pattern) 检查前面是不是 pattern，负后顾 (?<!pattern) 则相反。比如提取价格时用 (?<=\$)\d+，只匹配美元符号后面的数字，而 $ 本身不会被吃掉。密码强度校验也常用断言：一个正则同时要求“必须含数字”和“必须含字母”。

$$\displaystyle \text{pa}(?=\text{tn}): \text{宽 } 0 \text{ 的观察}$$

1. 前瞻 (?=tn)：在当前位置向后验证，断言后面必须紧跟 tn，但不算“拿到”。

$$\displaystyle \text{(?=tn)}: \text{lookahead}(\text{tn})$$

2. 零宽度：整个断言消费的字符长度为 0，匹配结果中不会包含 tn。

$$\displaystyle \text{width} = 0$$

扫描眼让机器人的视野远超手臂长度，能在下手前就预判后面会发生什么。但机器人身上还有好几个开关——大小写敏感吗？只找第一处还是全部？下一节认识这些调节旋钮。

修饰符标志

班长发现机器人看标签时“大小写不通吃”，于是在机身侧面加了一排开关。这些开关就是正则的修饰符（Flag），它们改变整个匹配引擎的默认行为。

最常用的三个开关是：i 忽略大小写，g 全局匹配（找出所有匹配而不是停在第一处），m 多行模式（让 ^ 和 $ 匹配每一行的行首行尾）。在 Python 的 re 模块中它们写作 re.I、re.M、re.S，JavaScript 则把标志写在结束斜杠后面，如 /abc/gi。

还有一个易被忽略的开关 s（DOTALL），它让点号 . 也能匹配换行符 \n。默认情况下点号不匹配换行符，这常常让跨行匹配的初学者抓狂。Python 中 re.findall 配合 re.M 和命名分组，是处理日志数据的黄金组合。

$$\displaystyle / \text{pattern} / \text{gim}$$

1. 全局 g：引擎把匹配全部找出来，而不是拿到第一个结果就收工。

$$\displaystyle g: \{\text{全部匹配项}\}$$

2. 忽略大小写 i：字母匹配时把大写和小写视为等价。

$$\displaystyle i: c \sim \text{tolower}(c)$$

3. 多行 m：^ 与 $ 从“全文首尾”扩展为“每一行的首尾”。

$$\displaystyle m: \text{行首集合} = \{0, l_1+1, l_2+1, \ldots\}$$

这一排开关让机器人适应了不同班次的货物标签。到这里基础知识已经齐了——现在跟着班长去仓库的实战岗位上看一圈。

实战应用

新机器人正式上岗，班长带它巡了三个岗位：入库检查（验证表单）、巡线记录（提取日志）、整理货架（清洗数据）。每个岗位都有一张经典的指令卡。

表单验证是最常见的正则场景。校验手机号 1[3-9]\d{9} 确保是 11 位数字；校验邮箱 ^[\w.-]+@[\w-]+\.\w+$ 保证基本格式。后端收到任何用户输入，先用一条正则挡住明显不合法数据，能省下大量数据库查询。

日志提取常用命名分组加多行模式。从一行日志里同时抓出时间、级别和消息，一次性得到结构化字典。数据清洗则利用 re.sub 把乱码中的无用字符替换掉：re.sub(r'\s+', ' ', text) 能把多个空白折叠成一个空格，让脏文本变干净。

$$\displaystyle 1[3-9]\backslash d\{9\}: \text{11 位手机号}$$

1. 首位 1：第一位锁定数字 1，这是手机号的固定开头。

$$\displaystyle \text{首位} = 1$$

2. 号段 [3-9]：第二位只取 3 到 9，覆盖主流运营商的号段。

$$\displaystyle \text{第二位} \in [3,9] \cap \mathbb{Z}$$

3. 尾 9 位 \d{9}：后面 9 位任意数字，合计 11 位。

$$\displaystyle 1 + 1 + 9 = 11$$

三张指令卡熟练下来，机器人已经能独当一面。但班长提醒它：指令卡写得不好，机器人会在岔路口反复犹豫——那是下一节要解决的性能问题。

性能优化

有一个奇怪的现象：同样的指令卡，在一排长得像的包裹前，机器人突然原地打转，好半天才回过神。这不是机器人坏了，而是遇到了正则世界著名的“灾难性回溯”。

正则引擎在遇到多分支匹配时，会先尝试贪婪路径，失败后再回头尝试其他路径，这个过程叫回溯（Backtracking）。绝大多数回溯很轻快，但模式里出现嵌套量词如 (a+)+$，目标又是一长串 a 加一个 b 时，回溯次数会爆炸式增长，复杂度从线性退化为指数级。

优化常用手段包括：尽量用非贪婪量词、用非捕获分组 (?:...) 减少记忆开销、把固定前缀提取出来（如 ^id=\d+ 优于 \d+$）、用 re.compile 预编译复用。在关键正则上，可以用原子组 (?>) 防止回溯，不过部分语言不支持。

$$\displaystyle (a\text{+})\text{+}\$: O(2^{n}) \text{ 回溯}$$

1. 嵌套量词：外层 + 每扩展一次，内层 + 都要重新分割剩余字符。

$$\displaystyle \text{分割方式数} = 2^{n-1}$$

2. 灾难性回溯：n 个 a 时尝试次数指数增长，足以拖垮程序。

$$\displaystyle O(2^{n}) \gg O(n^{2})$$

班长在指令卡上加了两条批注：别让量词嵌套嵌套再嵌套，尽量用最短路径试探。优化后的机器人跑得又快又稳，从此被评为最佳员工。你也该去自己的代码里，为文本处理写一张漂亮的“指令卡”了。

AI 应用场景

Python 演示

import re LOG_LINES = [    "2025-01-15 08:32:11 ERROR Failed to connect to db",    "2025-01-15 08:33:02 INFO User admin logged in",    "2025-01-15 08:33:45 WARN Disk usage 92%",    "2025-01-15 08:34:10 ERROR Timeout after 30s",    "2025-01-15 08:35:00 INFO Backup completed",] # 编译正则: 命名分组分别提取时间、级别与消息PATTERN = re.compile(    r"(?P<time>\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}) "    r"(?P<level>ERROR|WARN|INFO) (?P<message>.+)") def parse_logs(lines):    records = []    for line in lines:        match = PATTERN.match(line)  # 从行首开始匹配        if match:            records.append(match.groupdict())    return records if __name__ == "__main__":    records = parse_logs(LOG_LINES)    errors = [r for r in records if r["level"] == "ERROR"]    print("parsed {} logs, {} errors".format(len(records), len(errors)))    for r in errors:        print("  [{}] {}".format(r["time"], r["message"]))

1. PATTERN = re.compile(...)预编译正则为一次编译、多次复用，避免循环中反复编译的开销。
2. r"(?P<time>\d{4}-...原始字符串前缀 r 让反斜杠不被转义，正则里 \d 才有效。
3. (?P<time>...)命名分组，让提取结果可以直接按字段名读取，可读性远胜编号分组。
4. PATTERN.match(line)从字符串开头尝试匹配，等价于在模式前加了 ^ 锚点。
5. match.groupdict()把所有命名分组转成字典返回，一行代码完成结构化。

常见误区

面试题