> ## Content Index > Fetch the complete content index at: https://blog.vercanti.com/llms.txt > Use this file to discover other available public pages before exploring further. # Python 正则表达式完全指南 - URL: https://blog.vercanti.com/python-zheng-ze-biao-da-shi-wan-quan-zhi-nan/ - Published: 2026-08-28T14:34:36.000Z - Updated: 2026-08-28T14:56:56.000Z - Description: 相关文档：内置函数完全参考(/python-nei-zhi-han-shu-wan-quan-can-kao/) | 数据类型(/python-nei-zhi-shu-ju-lei-xing-wan-quan-can-kao/) | 装饰器与函数高级(/python-zhuang-shi-qi-yu-han-shu-gao-ji-yong-fa/) 1. 正则表达式基础语法(#%E4%B8%80%E3%80%81%E6%AD%A3%E5%88%99%E8%A1%A8%E8%BE%BE%E5%BC%8F%E5%9F%BA%E7%A1%80%E8%AF%AD - Author: yellowdog - Tags: Python, 基础 > 官方文档： > 适用版本：Python 3.12（2026-05-07 核实） 相关文档：[内置函数完全参考](https://blog.vercanti.com/python-nei-zhi-han-shu-wan-quan-can-kao/) | [数据类型](https://blog.vercanti.com/python-nei-zhi-shu-ju-lei-xing-wan-quan-can-kao/) | [装饰器与函数高级](https://blog.vercanti.com/python-zhuang-shi-qi-yu-han-shu-gao-ji-yong-fa/) --- ## 目录 1. [正则表达式基础语法](#%E4%B8%80%E3%80%81%E6%AD%A3%E5%88%99%E8%A1%A8%E8%BE%BE%E5%BC%8F%E5%9F%BA%E7%A1%80%E8%AF%AD%E6%B3%95) 2. [修饰符（Flags）](#%E4%BA%8C%E3%80%81%E4%BF%AE%E9%A5%B0%E7%AC%A6%EF%BC%88flags%EF%BC%89) 3. [re 模块所有函数](#%E4%B8%89%E3%80%81re-%E6%A8%A1%E5%9D%97%E6%89%80%E6%9C%89%E5%87%BD%E6%95%B0) 4. [Pattern 编译对象](#%E5%9B%9B%E3%80%81pattern-%E7%BC%96%E8%AF%91%E5%AF%B9%E8%B1%A1) 5. [Match 对象](#%E4%BA%94%E3%80%81match-%E5%AF%B9%E8%B1%A1) 6. [贪婪与非贪婪](#%E5%85%AD%E3%80%81%E8%B4%AA%E5%A9%AA%E4%B8%8E%E9%9D%9E%E8%B4%AA%E5%A9%AA) 7. [零宽断言](#%E4%B8%83%E3%80%81%E9%9B%B6%E5%AE%BD%E6%96%AD%E8%A8%80) 8. [分组高级用法](#%E5%85%AB%E3%80%81%E5%88%86%E7%BB%84%E9%AB%98%E7%BA%A7%E7%94%A8%E6%B3%95) 9. [实战案例](#%E4%B9%9D%E3%80%81%E5%AE%9E%E6%88%98%E6%A1%88%E4%BE%8B) 10. [性能优化](#%E5%8D%81%E3%80%81%E6%80%A7%E8%83%BD%E4%BC%98%E5%8C%96) 11. [最佳实践](#%E5%8D%81%E4%B8%80%E3%80%81%E6%9C%80%E4%BD%B3%E5%AE%9E%E8%B7%B5) 12. [常见陷阱与注意事项](#%E5%8D%81%E4%BA%8C%E3%80%81%E5%B8%B8%E8%A7%81%E9%99%B7%E9%98%B1%E4%B8%8E%E6%B3%A8%E6%84%8F%E4%BA%8B%E9%A1%B9) --- ## 一、正则表达式基础语法 ### 1.1 普通字符 普通字符匹配其自身。字母、数字、下划线等非特殊字符直接匹配对应字符。 ### 1.2 元字符总览 以下字符在正则中具有特殊含义，匹配字面量时需用反斜杠转义： ``` . ^ $ * + ? { } [ ] \ | ( ) ``` ### 1.3 字符类 | 语法 | 说明 | 示例 | | ------------- | -------------------------------------------- | ------------------ | | . | 匹配除换行符 \\n 以外的任意字符（re.DOTALL 时包括换行） | a.c 匹配 abc、a1c | | \[abc\] | 字符集，匹配括号内任意一个字符 | \[abc\] 匹配 a、b 或 c | | \[^abc\] | 取反字符集，匹配括号内字符以外的任意字符 | \[^abc\] 不匹配 a、b、c | | \[a-z\] | 字符范围，匹配 a 到 z 任意字符 | \[0-9\] 匹配任意数字 | | \[a-zA-Z0-9\] | 多范围组合 | 匹配字母和数字 | | \\d | 等价于 \[0-9\]，匹配数字（Unicode 模式下匹配所有 Unicode 数字） | \\d+ 匹配一串数字 | | \\D | 等价于 \[^\\d\]，匹配非数字 | | | \\w | 等价于 \[a-zA-Z0-9\_\]，匹配单词字符 | | | \\W | 等价于 \[^\\w\]，匹配非单词字符 | | | \\s | 匹配空白字符：空格、制表符、换行符等 | | | \\S | 匹配非空白字符 | | | \\b | 单词边界（零宽断言） | \\bword\\b 精确匹配单词 | | \\B | 非单词边界 | | ### 1.4 量词 | 语法 | 说明 | 等价写法 | | ----- | ---------------- | ----- | | \* | 匹配前一个元素 0 次或多次 | {0,} | | + | 匹配前一个元素 1 次或多次 | {1,} | | ? | 匹配前一个元素 0 次或 1 次 | {0,1} | | {n} | 精确匹配 n 次 | | | {n,} | 匹配至少 n 次 | | | {,m} | 匹配最多 m 次 | | | {n,m} | 匹配 n 到 m 次 | | 所有量词默认贪婪，在量词后加 `?` 变为非贪婪（懒惰）模式： | 语法 | 说明 | | ------ | ---------- | | \*? | 非贪婪，尽可能少匹配 | | +? | 非贪婪 | | ?? | 非贪婪 | | {n,m}? | 非贪婪 | ### 1.5 锚点（位置断言） | 语法 | 说明 | | --- | --------------------------------------- | | ^ | 匹配字符串开头（re.MULTILINE 时匹配每行开头） | | $ | 匹配字符串结尾（re.MULTILINE 时匹配每行结尾，允许结尾有 \\n） | | \\A | 仅匹配整个字符串的开头，不受 re.MULTILINE 影响 | | \\Z | 仅匹配整个字符串的结尾，不受 re.MULTILINE 影响 | | \\b | 单词边界，\\w 与 \\W 之间的位置（包括字符串开头/结尾） | | \\B | 非单词边界 | ### 1.6 分组与反向引用 | 语法 | 说明 | | ----------------- | --------------------------- | | (pattern) | 捕获分组，捕获匹配内容，可用 \\1、\\2 反向引用 | | (?:pattern) | 非捕获分组，仅分组不捕获 | | (?Ppattern) | 命名捕获分组 | | (?P=name) | 命名反向引用，引用已命名的分组 | | \\1、\\2... | 数字反向引用，引用第 n 个捕获分组 | | (?#comment) | 注释，不参与匹配 | ### 1.7 零宽断言 | 语法 | 说明 | | ------------ | ------------------------- | | (?=pattern) | 正向先行断言：当前位置右侧能匹配 pattern | | (?!pattern) | 负向先行断言：当前位置右侧不能匹配 pattern | | (?<=pattern) | 正向后行断言：当前位置左侧能匹配 pattern | | (?\n content\n" # 不加 DOTALL，. 不匹配换行 print(re.findall(r'
.*
', html)) # [] # 加 DOTALL，. 匹配所有字符包括换行 print(re.findall(r'
.*
', html, re.S)) # ['
\n content\n
'] ``` #### re.VERBOSE（re.X） ```python import re # 可读性更高的正则，空格和 # 注释被忽略 email_pattern = re.compile(r""" [\w.+-]+ # 用户名部分（字母、数字、.、+、-） @ # @ 符号 [\w-]+ # 域名主体 (?:\.[\w-]+)* # 子域名（可选，可多个） \. # 点号 [a-zA-Z]{2,} # 顶级域名 """, re.VERBOSE) print(email_pattern.findall('user@example.com test@sub.domain.org')) # ['user@example.com', 'test@sub.domain.org'] ``` #### re.ASCII（re.A） ```python import re text = "hello 你好 123 ١٢٣" # ١٢٣ 是阿拉伯数字 # 默认 Unicode 模式，\d 匹配所有 Unicode 数字 print(re.findall(r'\d+', text)) # ['123', '١٢٣'] # ASCII 模式，\d 只匹配 0-9 print(re.findall(r'\d+', text, re.A)) # ['123'] # \w 同理 print(re.findall(r'\w+', text)) # ['hello', '你好', '123', '١٢٣'] print(re.findall(r'\w+', text, re.A)) # ['hello', '123'] ``` --- ## 三、re 模块所有函数 ### 3.1 re.compile() 将正则表达式字符串编译为 Pattern 对象，供反复使用。 **函数签名：** ```python re.compile(pattern, flags=0) ``` **参数表：** | 参数名 | 类型 | 默认值 | 说明 | | ------- | ----------- | --- | ------------- | | pattern | str 或 bytes | 必填 | 正则表达式字符串 | | flags | int | 0 | 修饰符，多个用 \| 组合 | **返回值：** `re.Pattern` 对象 ```python import re # 基本编译 pattern = re.compile(r'\d+') print(pattern.findall('abc123def456')) # ['123', '456'] # 带修饰符 pattern = re.compile(r'hello', re.I | re.M) # 编译后的 pattern 可重复使用，性能更好 email_re = re.compile(r'[\w.+-]+@[\w-]+\.[\w.]+') urls = ['user@example.com', 'bad-email', 'admin@test.org'] for url in urls: if email_re.match(url): print(f"{url} 是有效邮箱") ``` ### 3.2 re.match() 从字符串的**起始位置**尝试匹配，若起始位置不匹配则返回 `None`。 **函数签名：** ```python re.match(pattern, string, flags=0) ``` **参数表：** | 参数名 | 类型 | 默认值 | 说明 | | ------- | ----------- | --- | -------- | | pattern | str | 必填 | 正则表达式字符串 | | string | str 或 bytes | 必填 | 待匹配的字符串 | | flags | int | 0 | 修饰符 | **返回值：** 匹配成功返回 `Match` 对象，失败返回 `None` ```python import re # match 只从起始位置匹配 m = re.match(r'\d+', '123abc') print(m.group()) # '123' m = re.match(r'\d+', 'abc123') print(m) # None，因为起始位置不是数字 # 注意：match 不需要匹配整个字符串 m = re.match(r'\d+', '123abc456') print(m.group()) # '123'，只匹配到第一段数字 # 若要匹配整个字符串，使用 re.fullmatch 或在模式末尾加 $ m = re.match(r'\d+$', '123abc') print(m) # None ``` ### 3.3 re.fullmatch() 要求正则表达式匹配**整个字符串**。 **函数签名：** ```python re.fullmatch(pattern, string, flags=0) ``` **参数表：** | 参数名 | 类型 | 默认值 | 说明 | | ------- | ----------- | --- | -------- | | pattern | str | 必填 | 正则表达式字符串 | | string | str 或 bytes | 必填 | 待匹配的字符串 | | flags | int | 0 | 修饰符 | **返回值：** 整个字符串匹配返回 `Match` 对象，否则返回 `None` ```python import re # fullmatch 要求整个字符串匹配 m = re.fullmatch(r'\d+', '12345') print(m.group()) # '12345' m = re.fullmatch(r'\d+', '123abc') print(m) # None，因为 'abc' 部分不匹配 # 常用于输入验证 def is_valid_phone(phone): return re.fullmatch(r'1[3-9]\d{9}', phone) is not None print(is_valid_phone('13812345678')) # True print(is_valid_phone('138123456789')) # False（太长） print(is_valid_phone('23812345678')) # False（不以1开头） ``` ### 3.4 re.search() 扫描整个字符串，找到**第一个**匹配的位置。 **函数签名：** ```python re.search(pattern, string, flags=0) ``` **参数表：** | 参数名 | 类型 | 默认值 | 说明 | | ------- | ----------- | --- | -------- | | pattern | str | 必填 | 正则表达式字符串 | | string | str 或 bytes | 必填 | 待匹配的字符串 | | flags | int | 0 | 修饰符 | **返回值：** 找到返回 `Match` 对象，未找到返回 `None` ```python import re # search 扫描整个字符串 m = re.search(r'\d+', 'abc123def456') print(m.group()) # '123'，返回第一个匹配 m = re.search(r'\d+', 'no digits here') print(m) # None # match vs search 对比 text = 'abc123' print(re.match(r'\d+', text)) # None（起始位置不是数字） print(re.search(r'\d+', text)) # （找到 '123'） # 使用 search 查找首个匹配 m = re.search(r'(?P\d{4})-(?P\d{2})-(?P\d{2})', 'Today is 2026-03-05') if m: print(m.group('year')) # '2026' print(m.group('month')) # '03' print(m.group('day')) # '05' ``` ### 3.5 re.findall() 找到字符串中**所有**非重叠匹配，返回列表。 **函数签名：** ```python re.findall(pattern, string, flags=0) ``` **参数表：** | 参数名 | 类型 | 默认值 | 说明 | | ------- | ----------- | --- | -------- | | pattern | str | 必填 | 正则表达式字符串 | | string | str 或 bytes | 必填 | 待匹配的字符串 | | flags | int | 0 | 修饰符 | **返回值：** - 无捕获分组：返回匹配字符串列表 - 一个捕获分组：返回捕获内容字符串列表 - 多个捕获分组：返回元组列表，每个元组对应一次匹配的各分组内容 ```python import re # 无分组：返回完整匹配列表 result = re.findall(r'\d+', 'abc123def456ghi789') print(result) # ['123', '456', '789'] # 一个分组：返回分组内容列表 result = re.findall(r'(\d+)', 'abc123def456') print(result) # ['123', '456'] # 多个分组：返回元组列表 result = re.findall(r'(\w+)=(\w+)', 'a=1 b=2 c=3') print(result) # [('a', '1'), ('b', '2'), ('c', '3')] # 非捕获分组 (?:) 不影响返回结构 result = re.findall(r'(?:\d{3})-(\d{4})', '010-1234 021-5678') print(result) # ['1234', '5678'] # 空匹配 result = re.findall(r'\d*', 'a1b2') print(result) # ['', '1', '', '2', '']（\d* 可匹配空字符串） ``` ### 3.6 re.finditer() 找到所有非重叠匹配，返回迭代器（每个元素为 `Match` 对象）。 **函数签名：** ```python re.finditer(pattern, string, flags=0) ``` **参数表：** | 参数名 | 类型 | 默认值 | 说明 | | ------- | ----------- | --- | -------- | | pattern | str | 必填 | 正则表达式字符串 | | string | str 或 bytes | 必填 | 待匹配的字符串 | | flags | int | 0 | 修饰符 | **返回值：** 迭代器，每次产出一个 `Match` 对象 ```python import re # finditer 返回迭代器，内存效率更高 text = 'abc123def456ghi789' for m in re.finditer(r'\d+', text): print(f"匹配: {m.group()}, 位置: {m.start()}-{m.end()}") # 匹配: 123, 位置: 3-6 # 匹配: 456, 位置: 9-12 # 匹配: 789, 位置: 15-18 # 比 findall 更灵活，可获取位置信息 pattern = re.compile(r'(\w+)@(\w+)\.(\w+)') for m in pattern.finditer('user@example.com admin@test.org'): print(f"完整: {m.group()}, 用户: {m.group(1)}, 域名: {m.group(2)}") ``` ### 3.7 re.sub() 将字符串中匹配的部分替换为指定内容。 **函数签名：** ```python re.sub(pattern, repl, string, count=0, flags=0) ``` **参数表：** | 参数名 | 类型 | 默认值 | 说明 | | ------- | -------------- | --- | -------------------------------------------------------------- | | pattern | str | 必填 | 正则表达式字符串 | | repl | str 或 callable | 必填 | 替换内容。字符串时可用 \\1、\\g<1>、\\g 引用分组；可调用对象接收 Match 对象，返回替换字符串 | | string | str 或 bytes | 必填 | 原始字符串 | | count | int | 0 | 最多替换次数，0 表示替换全部 | | flags | int | 0 | 修饰符 | **返回值：** 替换后的字符串 ```python import re # 基本替换 result = re.sub(r'\d+', 'NUM', 'abc123def456') print(result) # 'abcNUMdefNUM' # count 限制替换次数 result = re.sub(r'\d+', 'NUM', 'abc123def456ghi789', count=2) print(result) # 'abcNUMdefNUMghi789' # 使用分组引用（\1 或 \g<1>） result = re.sub(r'(\w+)\s(\w+)', r'\2 \1', 'hello world') print(result) # 'world hello' # 使用命名分组引用（\g） result = re.sub( r'(?P\d{4})-(?P\d{2})-(?P\d{2})', r'\g/\g/\g', '2026-03-05' ) print(result) # '05/03/2026' # repl 为可调用对象 def uppercase_match(m): return m.group().upper() result = re.sub(r'[a-z]+', uppercase_match, 'abc123def456') print(result) # 'ABC123DEF456' # 更复杂的替换逻辑 def add_thousands_sep(m): num = int(m.group()) return f"{num:,}" result = re.sub(r'\d+', add_thousands_sep, 'price: 1234567 count: 89012') print(result) # 'price: 1,234,567 count: 89,012' ``` ### 3.8 re.subn() 与 `re.sub()` 相同，但同时返回替换次数。 **函数签名：** ```python re.subn(pattern, repl, string, count=0, flags=0) ``` **参数表：** | 参数名 | 类型 | 默认值 | 说明 | | ------- | -------------- | --- | --------------------- | | pattern | str | 必填 | 正则表达式字符串 | | repl | str 或 callable | 必填 | 替换内容（同 re.sub 的 repl） | | string | str 或 bytes | 必填 | 原始字符串 | | count | int | 0 | 最多替换次数 | | flags | int | 0 | 修饰符 | **返回值：** `(new_string, number_of_subs_made)` 元组 ```python import re result, count = re.subn(r'\d+', 'NUM', 'abc123def456ghi789') print(result) # 'abcNUMdefNUMghiNUM' print(count) # 3 # 判断是否发生了替换 new_text, n = re.subn(r'foo', 'bar', 'hello world') if n == 0: print("没有发生替换") ``` ### 3.9 re.split() 用匹配的子字符串分割字符串。 **函数签名：** ```python re.split(pattern, string, maxsplit=0, flags=0) ``` **参数表：** | 参数名 | 类型 | 默认值 | 说明 | | -------- | ----------- | --- | -------------- | | pattern | str | 必填 | 分隔符的正则表达式 | | string | str 或 bytes | 必填 | 待分割的字符串 | | maxsplit | int | 0 | 最大分割次数，0 表示不限制 | | flags | int | 0 | 修饰符 | **返回值：** 分割后的字符串列表 ```python import re # 基本分割 result = re.split(r'\s+', 'one two\tthree\nfour') print(result) # ['one', 'two', 'three', 'four'] # maxsplit 限制分割次数 result = re.split(r'\s+', 'one two three four', maxsplit=2) print(result) # ['one', 'two', 'three four'] # 分隔符含捕获分组时，分隔符也会出现在结果中 result = re.split(r'(\s+)', 'one two three') print(result) # ['one', ' ', 'two', ' ', 'three'] # 使用非捕获分组则不保留分隔符 result = re.split(r'(?:\s+)', 'one two three') print(result) # ['one', 'two', 'three'] # 按多种分隔符分割 result = re.split(r'[,;|]+', 'a,b;;c|d') print(result) # ['a', 'b', 'c', 'd'] # 字符串开头或结尾匹配时，结果中会有空字符串 result = re.split(r',', ',a,b,') print(result) # ['', 'a', 'b', ''] ``` ### 3.10 re.escape() 对字符串中的所有非字母数字字符进行转义，使其可作为字面量正则模式使用。 **函数签名：** ```python re.escape(pattern) ``` **参数表：** | 参数名 | 类型 | 默认值 | 说明 | | ------- | ----------- | --- | -------- | | pattern | str 或 bytes | 必填 | 需要转义的字符串 | **返回值：** 转义后的字符串 ```python import re # 转义特殊字符 user_input = 'price: $1.99 (special offer)' escaped = re.escape(user_input) print(escaped) # 'price\:\ \$1\.99\ \(special\ offer\)' # 安全地将用户输入用于正则 def search_literal(text, query): """安全地搜索字面量字符串""" pattern = re.escape(query) return re.findall(pattern, text, re.I) text = 'The price is $1.99, not $2.99' print(search_literal(text, '$1.99')) # ['$1.99'] # 构建动态正则 keywords = ['c++', 'c#', '.net', 'node.js'] pattern = '|'.join(re.escape(kw) for kw in keywords) print(re.findall(pattern, 'I like c++ and c# but not .net', re.I)) # ['c++', 'c#', '.net'] ``` ### 3.11 re.purge() 清除正则表达式的内部缓存。 **函数签名：** ```python re.purge() ``` **参数表：** 无参数 **说明：** Python 会缓存最近编译的正则表达式（默认缓存 512 个）。`re.purge()` 用于清除该缓存，释放内存。通常不需要手动调用。 ```python import re # 使用大量不同的临时正则后，手动清除缓存 for i in range(1000): re.findall(f'pattern_{i}', 'test string') re.purge() # 清除缓存，释放内存 ``` --- ## 四、Pattern 编译对象 `re.compile()` 返回的 `Pattern` 对象拥有与 `re` 模块顶层函数相同的方法，但不需要再传入 `pattern` 参数，且性能更好。 ### Pattern 对象的属性 | 属性 | 类型 | 说明 | | ------------------ | ---- | ---------------- | | pattern.pattern | str | 编译时使用的正则表达式字符串 | | pattern.flags | int | 编译时使用的修饰符（包含默认值） | | pattern.groups | int | 模式中捕获分组的数量 | | pattern.groupindex | dict | 命名分组名称到分组编号的映射字典 | ### Pattern 对象的方法 所有方法与顶层函数签名相同，但省略第一个 `pattern` 参数。 | 方法 | 说明 | | ---------------------------------------------- | ---------------- | | pattern.match(string\[, pos\[, endpos\]\]) | 从 pos 开始匹配（默认 0） | | pattern.fullmatch(string\[, pos\[, endpos\]\]) | 全串匹配 | | pattern.search(string\[, pos\[, endpos\]\]) | 搜索第一个匹配 | | pattern.findall(string\[, pos\[, endpos\]\]) | 找所有匹配 | | pattern.finditer(string\[, pos\[, endpos\]\]) | 找所有匹配（迭代器） | | pattern.sub(repl, string, count=0) | 替换 | | pattern.subn(repl, string, count=0) | 替换并返回次数 | | pattern.split(string, maxsplit=0) | 分割 | **pos 和 endpos 参数说明：** | 参数名 | 类型 | 默认值 | 说明 | | ------ | --- | ----------- | ------------------------------- | | pos | int | 0 | 从字符串的哪个索引位置开始匹配，相当于对字符串切片但不影响 ^ | | endpos | int | len(string) | 匹配到字符串的哪个索引位置结束 | ```python import re pattern = re.compile(r'\d+') # 查看 Pattern 属性 print(pattern.pattern) # '\d+' print(pattern.flags) # 32（默认 re.UNICODE） print(pattern.groups) # 0 # 带命名分组的 Pattern p = re.compile(r'(?P\d{4})-(?P\d{2})') print(p.groups) # 2 print(p.groupindex) # {'year': 1, 'month': 2} # 使用 pos 和 endpos text = 'abc123def456' print(pattern.findall(text, 3, 9)) # ['123']（只在索引 3-9 范围内查找） print(pattern.search(text, 6)) # 在 'def456' 中找，找到 '456' # pos 不影响 ^ 的行为 p = re.compile(r'^\d+') text = 'abc123' print(p.match(text, 3)) # None（pos=3 处是 '1'，但 ^ 仍锚定字符串开头） ``` --- ## 五、Match 对象 匹配成功后，`re.match()`、`re.search()`、`re.finditer()` 返回 `Match` 对象。 ### Match 对象的属性 | 属性 | 类型 | 说明 | | ----------- | ---------- | ----------------- | | m.re | Pattern | 产生此匹配的 Pattern 对象 | | m.string | str | 传入的原始字符串 | | m.pos | int | 搜索开始位置 | | m.endpos | int | 搜索结束位置 | | m.lastindex | int 或 None | 最后一个参与匹配的捕获分组编号 | | m.lastgroup | str 或 None | 最后一个参与匹配的命名分组名称 | ### 5.1 m.group() **函数签名：** ```python m.group([group1, ...]) ``` **参数表：** | 参数名 | 类型 | 默认值 | 说明 | | ----------- | --------- | --- | --------------------------------- | | group1, ... | int 或 str | 0 | 分组编号或命名分组名称。0 或缺省表示整个匹配；多个参数时返回元组 | **返回值：** 单个参数时返回字符串（分组未参与匹配时返回 `None`）；多个参数时返回元组 ```python import re m = re.match(r'(\d{4})-(\d{2})-(\d{2})', '2026-03-05') print(m.group()) # '2026-03-05'（整个匹配） print(m.group(0)) # '2026-03-05'（同上） print(m.group(1)) # '2026'（第一个分组） print(m.group(2)) # '03' print(m.group(3)) # '05' print(m.group(1, 3)) # ('2026', '05')（多个参数返回元组） # 命名分组 m = re.match(r'(?P\d{4})-(?P\d{2})', '2026-03') print(m.group('year')) # '2026' print(m.group('month')) # '03' # 未参与匹配的分组返回 None m = re.match(r'(\d+)|([a-z]+)', '123') print(m.group(1)) # '123' print(m.group(2)) # None（第二个分组未参与匹配） ``` ### 5.2 m.groups() **函数签名：** ```python m.groups(default=None) ``` **参数表：** | 参数名 | 类型 | 默认值 | 说明 | | ------- | --- | ---- | ------------ | | default | any | None | 未参与匹配的分组的默认值 | **返回值：** 包含所有捕获分组内容的元组 ```python import re m = re.match(r'(\d{4})-(\d{2})-(\d{2})', '2026-03-05') print(m.groups()) # ('2026', '03', '05') # default 参数处理未匹配分组 m = re.match(r'(\d+)\.?(\d*)', '123') print(m.groups()) # ('123', '') print(m.groups('N/A')) # ('123', '')（空字符串不是 None，不替换） m = re.match(r'(\d+)|([a-z]+)', '123') print(m.groups()) # ('123', None) print(m.groups('N/A')) # ('123', 'N/A') ``` ### 5.3 m.groupdict() **函数签名：** ```python m.groupdict(default=None) ``` **参数表：** | 参数名 | 类型 | 默认值 | 说明 | | ------- | --- | ---- | -------------- | | default | any | None | 未参与匹配的命名分组的默认值 | **返回值：** 包含所有命名分组的字典，键为分组名 ```python import re m = re.match( r'(?P\d{4})-(?P\d{2})-(?P\d{2})', '2026-03-05' ) print(m.groupdict()) # {'year': '2026', 'month': '03', 'day': '05'} # 含未匹配命名分组时使用 default m = re.match(r'(?P\d+)|(?P[a-z]+)', '123') print(m.groupdict()) # {'num': '123', 'word': None} print(m.groupdict('N/A')) # {'num': '123', 'word': 'N/A'} ``` ### 5.4 m.start() / m.end() / m.span() **函数签名：** ```python m.start([group]) m.end([group]) m.span([group]) ``` **参数表（三者相同）：** | 参数名 | 类型 | 默认值 | 说明 | | ----- | --------- | --- | -------------------- | | group | int 或 str | 0 | 分组编号或命名分组名称，0 表示整个匹配 | **返回值：** - `start()`：匹配开始的索引 - `end()`：匹配结束的索引（不含） - `span()`：`(start, end)` 元组 ```python import re text = 'hello 2026-03-05 world' m = re.search(r'(\d{4})-(\d{2})-(\d{2})', text) print(m.start()) # 6（整个匹配开始位置） print(m.end()) # 16（整个匹配结束位置） print(m.span()) # (6, 16) print(m.start(1)) # 6（第一个分组开始位置） print(m.end(1)) # 10 print(m.span(1)) # (6, 10) # 验证：原始字符串切片 print(text[m.start():m.end()]) # '2026-03-05' print(text[m.start(2):m.end(2)]) # '03' # 未参与匹配的分组返回 -1 m = re.match(r'(\d+)|([a-z]+)', '123') print(m.start(2)) # -1 print(m.end(2)) # -1 print(m.span(2)) # (-1, -1) ``` ### 5.5 m.expand() **函数签名：** ```python m.expand(template) ``` **参数表：** | 参数名 | 类型 | 默认值 | 说明 | | -------- | --- | --- | ----------------------------------- | | template | str | 必填 | 模板字符串，可使用 \\1、\\g<1>、\\g 引用分组 | **返回值：** 替换分组引用后的字符串 ```python import re m = re.match(r'(?P\d{4})-(?P\d{2})-(?P\d{2})', '2026-03-05') print(m.expand(r'\g/\g/\g')) # '05/03/2026' print(m.expand(r'\1年\2月\3日')) # '2026年03月05日' ``` --- ## 六、贪婪与非贪婪 ### 6.1 贪婪模式（默认） 量词默认是贪婪的，尽可能多地匹配字符。 ```python import re html = 'bold and italic' # 贪婪：匹配从第一个 < 到最后一个 > print(re.findall(r'<.+>', html)) # ['bold and italic']（全部匹配） # 解释：.+ 尽可能多匹配，直到整个字符串都能满足模式 ``` ### 6.2 非贪婪模式 在量词后加 `?`，尽可能少地匹配字符。 ```python import re html = 'bold and italic' # 非贪婪：每次找最短的匹配 print(re.findall(r'<.+?>', html)) # ['', '', '', ''] # 数量对比 print(re.findall(r'".*"', '"a" and "b"')) # ['"a" and "b"']（贪婪） print(re.findall(r'".*?"', '"a" and "b"')) # ['"a"', '"b"']（非贪婪） ``` ### 6.3 回溯机制 理解贪婪模式的工作原理有助于优化正则： ```python import re # 贪婪匹配的工作过程： # 模式：a.*b，字符串：aXXbXXb # 1. .* 先吃掉整个字符串 aXXbXXb # 2. 尝试匹配末尾 b，失败 # 3. 回吐一个字符，尝试匹配...直到成功 # 最终匹配到 aXXbXXb（贪婪，找最长匹配） text = 'aXXbXXb' print(re.search(r'a.*b', text).group()) # 'aXXbXXb' print(re.search(r'a.*?b', text).group()) # 'aXXb'（非贪婪，找最短） # 固化量词（possessive quantifier）：Python 3.11+ 支持原子组 (?>...) # 可避免不必要的回溯（见"原子组"章节） ``` --- ## 七、零宽断言 零宽断言（Zero-Width Assertion）匹配的是位置而非字符，不消耗字符。 ### 7.1 正向先行断言 `(?=pattern)` 当前位置右侧能匹配 pattern 时成立。 ```python import re # 匹配后面跟着 "元" 的数字 text = '苹果5元，香蕉3元，橙子12元' prices = re.findall(r'\d+(?=元)', text) print(prices) # ['5', '3', '12'] # 密码验证：必须包含数字（先行断言同时满足多个条件） def is_strong_password(pwd): has_digit = bool(re.search(r'(?=.*\d)', pwd)) has_upper = bool(re.search(r'(?=.*[A-Z])', pwd)) has_lower = bool(re.search(r'(?=.*[a-z])', pwd)) has_special = bool(re.search(r'(?=.*[!@#$%^&*])', pwd)) return all([has_digit, has_upper, has_lower, has_special, len(pwd) >= 8]) # 或者用单个正则 password_pattern = re.compile( r'^(?=.*\d)(?=.*[A-Z])(?=.*[a-z])(?=.*[!@#$%^&*]).{8,}$' ) print(bool(password_pattern.match('MyPass@1'))) # True print(bool(password_pattern.match('mypassword'))) # False ``` ### 7.2 负向先行断言 `(?!pattern)` 当前位置右侧不能匹配 pattern 时成立。 ```python import re # 匹配不以 .min.js 结尾的 .js 文件 files = ['main.js', 'main.min.js', 'app.js', 'vendor.min.js'] for f in files: if re.search(r'\.js(?!\.min)', f): # 注意这里逻辑需调整 pass # 正确写法：文件名不包含 .min 的 .js 文件 for f in files: if re.match(r'(?!.*\.min).*\.js$', f): print(f) # main.js, app.js # 匹配不跟在 "un" 后面的 "happy" text = 'I am happy and unhappy' result = re.findall(r'(?pattern)` ```python import re # 基本命名分组 m = re.match( r'(?P\w+),\s*(?P\w+)', 'Smith, John' ) print(m.group('last')) # 'Smith' print(m.group('first')) # 'John' print(m.groupdict()) # {'last': 'Smith', 'first': 'John'} # 命名分组反向引用（在模式内部） # 匹配 HTML 开闭标签一致的结构 html_tag = re.compile(r'<(?P[a-z]+)>.*?', re.S) print(html_tag.findall('
content
')) # ['div']，注意只返回分组内容 # 改用 search 获取完整匹配 m = html_tag.search('
hello world
') print(m.group()) # '
hello world
' print(m.group('tag')) # 'div' # 在 re.sub 中引用命名分组 result = re.sub( r'(?P\w+)\s+(?P\w+)', r'\g, \g', 'John Smith' ) print(result) # 'Smith, John' ``` ### 8.2 非捕获分组 `(?:pattern)` ```python import re # 捕获分组 vs 非捕获分组 text = 'color: red, colour: blue' # 使用捕获分组 result = re.findall(r'colou?r:\s*(\w+)', text) print(result) # ['red', 'blue'] # 如果需要对 colou?r 分组但不捕获 result = re.findall(r'(?:colou?r):\s*(\w+)', text) print(result) # ['red', 'blue']（只捕获颜色值） # 非捕获分组常用于量词应用于多字符 text = 'abcabcabc' print(re.findall(r'(?:abc)+', text)) # ['abcabcabc'] print(re.findall(r'(abc)+', text)) # ['abc']（返回最后一次捕获的分组值） # 性能：非捕获分组略快于捕获分组 ``` ### 8.3 条件分组 `(?(id)yes|no)` 根据某个分组是否参与了匹配，选择不同的匹配模式。 ```python import re # 基本语法：(?(id)yes_pattern|no_pattern) # 如果第 id 个分组已匹配，则使用 yes_pattern，否则使用 no_pattern # 匹配带括号或不带括号的数字 # 有左括号时，要求有右括号 pattern = re.compile(r'(\()?\d+(?(1)\)|)') tests = ['(123)', '456', '(789'] for t in tests: m = pattern.fullmatch(t) print(f"{t}: {'匹配' if m else '不匹配'}") # (123): 匹配 # 456: 匹配 # (789: 不匹配（有左括号但没有右括号） # 匹配可选的 http/https 前缀 pattern = re.compile(r'(https?://)?www\.(?(1)[\w.]+|[\w.]+\.com)') print(bool(pattern.fullmatch('http://www.example.org'))) # True print(bool(pattern.fullmatch('www.example.com'))) # True ``` ### 8.4 原子组 `(?>pattern)`（Python 3.11+） 原子组匹配后不允许回溯，可以提升性能并避免灾难性回溯。 ```python import re import sys # Python 3.11+ if sys.version_info >= (3, 11): # 不使用原子组（可能发生灾难性回溯） # pattern = re.compile(r'(a+)+b') # 使用原子组（禁止回溯） pattern = re.compile(r'(?>a+)+b') print(bool(pattern.search('aaab'))) # True print(bool(pattern.search('aaac'))) # False（快速失败，无回溯） # Python 3.10 及以前的替代方案：使用非贪婪或重写模式 # 避免嵌套量词如 (a+)+ 的写法 ``` ### 8.5 数字反向引用 ```python import re # 匹配重复的单词 pattern = re.compile(r'\b(\w+)\s+\1\b', re.I) text = 'the the quick brown fox over the the lazy dog' result = pattern.findall(text) print(result) # ['the', 'the'] # 匹配 HTML 配对标签 pattern = re.compile(r'<([a-z]+)>(.*?)', re.S) html = '
hello
world' for m in pattern.finditer(html): print(f"标签: {m.group(1)}, 内容: {m.group(2)}") # 标签: div, 内容: hello # 标签: span, 内容: world # 匹配引号（单引号或双引号配对） pattern = re.compile(r'([\'"])(.*?)\1') text = '"hello" and \'world\' and "mixed\'' for m in pattern.finditer(text): print(f"引号: {m.group(1)}, 内容: {m.group(2)}") # 引号: ", 内容: hello # 引号: ', 内容: world ``` --- ## 九、实战案例 ### 案例 1：邮箱提取 ```python import re EMAIL_PATTERN = re.compile( r""" (?P [\w.!#$%&'*+/=?^_`{|}~-]+ # 本地部分：允许的字符 ) @ (?P (?:[a-zA-Z0-9] # 域名：以字母或数字开头 (?:[a-zA-Z0-9-]{0,61} # 中间部分 [a-zA-Z0-9])? # 以字母或数字结尾 \.)+ # 点号分隔 [a-zA-Z]{2,} # 顶级域名至少2字符 ) """, re.VERBOSE ) def extract_emails(text): return EMAIL_PATTERN.findall(text) # 注意：findall 返回分组内容，需要调整 EMAIL_SIMPLE = re.compile(r'[\w.!#$%&\'*+/=?^_`{|}~-]+@[\w.-]+\.[a-zA-Z]{2,}') def extract_emails(text): return EMAIL_SIMPLE.findall(text) test_text = """ 联系邮箱：user@example.com 或 admin.test+tag@sub.domain.org 无效邮箱：@invalid.com，user@，plain-text 另一个：info@company.co.uk """ emails = extract_emails(test_text) for email in emails: print(email) # user@example.com # admin.test+tag@sub.domain.org # info@company.co.uk ``` ### 案例 2：手机号匹配 ```python import re # 中国大陆手机号：1 开头，第二位 3-9，共 11 位 PHONE_PATTERN = re.compile(r'(? {cleaned}, valid: {is_valid_phone(cleaned)}") ``` ### 案例 3：IP 地址验证 ```python import re # IPv4 地址验证 # 每段 0-255 def _build_ipv4(): # 250-255 p1 = r'25[0-5]' # 200-249 p2 = r'2[0-4]\d' # 100-199 p3 = r'1\d{2}' # 10-99 p4 = r'[1-9]\d' # 0-9 p5 = r'\d' octet = f'(?:{p1}|{p2}|{p3}|{p4}|{p5})' return re.compile(rf'^{octet}\.{octet}\.{octet}\.{octet}$') IPV4_PATTERN = _build_ipv4() def is_valid_ipv4(ip): return bool(IPV4_PATTERN.match(ip)) test_ips = ['192.168.1.1', '255.255.255.255', '0.0.0.0', '256.1.1.1', '1.2.3', '192.168.01.1'] for ip in test_ips: print(f"{ip}: {is_valid_ipv4(ip)}") # 192.168.1.1: True # 255.255.255.255: True # 0.0.0.0: True # 256.1.1.1: False # 1.2.3: False # 192.168.01.1: True（注意：01 被接受，如需拒绝需额外处理） # 从文本中提取 IP（不验证合法性） IP_EXTRACT = re.compile(r'\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b') text = "服务器 192.168.1.100 和网关 10.0.0.1 以及无效的 999.999.999.999" print(IP_EXTRACT.findall(text)) # ['192.168.1.100', '10.0.0.1', '999.999.999.999'] ``` ### 案例 4：URL 提取 ```python import re URL_PATTERN = re.compile( r'https?://' # 协议 r'(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+' # 域名 r'(?:[A-Z]{2,6}\.?|[A-Z0-9-]{2,}\.?))' # TLD r'(?::\d+)?' # 可选端口 r'(?:/?|[/?]\S+)', # 路径 re.IGNORECASE ) test_text = """ 访问 https://www.example.com/path?q=1&p=2 或 http://api.test.org:8080/v1/users 获取更多信息。 无效的 ftp://not-http.com 不会被匹配。 """ urls = URL_PATTERN.findall(test_text) for url in urls: print(url) # https://www.example.com/path?q=1&p=2 # http://api.test.org:8080/v1/users # 解析 URL 组成部分 URL_PARTS = re.compile( r'(?Phttps?)://' r'(?P[^/:?#]+)' r'(?::(?P\d+))?' r'(?P/[^?#]*)?' r'(?:\?(?P[^#]*))?' r'(?:#(?P.*))?' ) m = URL_PARTS.match('https://api.example.com:8080/v1/users?role=admin#section1') if m: print(m.groupdict()) # {'scheme': 'https', 'host': 'api.example.com', 'port': '8080', # 'path': '/v1/users', 'query': 'role=admin', 'fragment': 'section1'} ``` ### 案例 5：HTML 标签提取 ```python import re # 提取 HTML 标签及其属性（警告：复杂 HTML 请使用 BeautifulSoup） HTML_TAG = re.compile(r'<([a-zA-Z][a-zA-Z0-9]*)\b([^>]*)>', re.S) def parse_attributes(attr_string): """解析 HTML 属性字符串""" attr_pattern = re.compile(r'(\w[\w-]*)(?:\s*=\s*(?:"([^"]*)"|\'([^\']*)\'|(\S+)))?') attrs = {} for m in attr_pattern.finditer(attr_string): name = m.group(1) value = m.group(2) or m.group(3) or m.group(4) or True attrs[name] = value return attrs html = '' for m in HTML_TAG.finditer(html): tag = m.group(1) attrs = parse_attributes(m.group(2)) print(f"标签: {tag}, 属性: {attrs}") # 标签: div, 属性: {'class': 'container', 'id': 'main'} # 标签: a, 属性: {'href': 'http://example.com', 'target': '_blank'} # 提取特定属性 hrefs = re.findall(r']*href=["\']([^"\']+)["\']', html, re.I) print(hrefs) # ['http://example.com'] ``` ### 案例 6：中文提取 ```python import re # 中文 Unicode 范围：\u4e00-\u9fff（基本汉字） # 扩展：\u3400-\u4dbf（扩展A）、\u20000-\u2a6df（扩展B）等 CHINESE_PATTERN = re.compile(r'[\u4e00-\u9fff\u3400-\u4dbf]+') def extract_chinese(text): return CHINESE_PATTERN.findall(text) text = "Hello 你好 World 中文提取 Test 测试123" print(extract_chinese(text)) # ['你好', '中文提取', '测试'] # 包含中文标点符号 CHINESE_WITH_PUNCT = re.compile( r'[\u4e00-\u9fff\u3400-\u4dbf' # 汉字 r'\u3000-\u303f' # CJK 标点 r'\uff00-\uffef]+' # 全角字符 ) # 统计中文字符数 def count_chinese_chars(text): return sum(len(m) for m in CHINESE_PATTERN.findall(text)) text = "这是一段中文，contains English and 数字123" print(count_chinese_chars(text)) # 10（'这是一段中文' + '数字'） # 移除非中文字符（只保留中文） def keep_chinese_only(text): return ''.join(CHINESE_PATTERN.findall(text)) print(keep_chinese_only("Hello世界！abc中文123")) # '世界中文' ``` ### 案例 7：日期格式匹配 ```python import re from datetime import datetime # 匹配多种日期格式 DATE_PATTERNS = { 'ISO': re.compile(r'\b(\d{4})-(\d{2})-(\d{2})\b'), 'CN': re.compile(r'\b(\d{4})年(\d{1,2})月(\d{1,2})日\b'), 'US': re.compile(r'\b(\d{1,2})/(\d{1,2})/(\d{2,4})\b'), 'EU': re.compile(r'\b(\d{1,2})\.(\d{1,2})\.(\d{2,4})\b'), } def extract_dates(text): results = [] for fmt, pattern in DATE_PATTERNS.items(): for m in pattern.finditer(text): results.append({'format': fmt, 'raw': m.group(), 'groups': m.groups()}) return results text = "日期：2026-03-05，或者2026年3月5日，也可以是03/05/2026" for date in extract_dates(text): print(f"格式: {date['format']}, 原始: {date['raw']}") # 验证并解析日期 def parse_date(text): pattern = re.compile( r'(?P\d{4})[年/-](?P\d{1,2})[月/-](?P\d{1,2})日?' ) m = pattern.search(text) if m: try: return datetime(int(m.group('year')), int(m.group('month')), int(m.group('day'))) except ValueError: return None return None print(parse_date("今天是2026-03-05")) # datetime(2026, 3, 5, 0, 0) print(parse_date("2026年13月5日")) # None（月份无效） ``` ### 案例 8：密码强度验证 ```python import re def check_password_strength(password): """ 检查密码强度 强密码条件： - 长度至少 8 位 - 包含大写字母 - 包含小写字母 - 包含数字 - 包含特殊字符 """ checks = { 'length': len(password) >= 8, 'uppercase': bool(re.search(r'[A-Z]', password)), 'lowercase': bool(re.search(r'[a-z]', password)), 'digit': bool(re.search(r'\d', password)), 'special': bool(re.search(r'[!@#$%^&*(),.?":{}|<>]', password)), } score = sum(checks.values()) strength_map = {5: '强', 4: '中等', 3: '弱', 2: '很弱', 1: '极弱', 0: '不合格'} strength = strength_map.get(score, '不合格') return {'score': score, 'strength': strength, 'checks': checks} # 单一强密码正则（使用前行断言） STRONG_PASSWORD = re.compile( r'^' r'(?=.*[a-z])' # 至少一个小写字母 r'(?=.*[A-Z])' # 至少一个大写字母 r'(?=.*\d)' # 至少一个数字 r'(?=.*[!@#$%^&*])' # 至少一个特殊字符 r'.{8,}$' # 至少 8 位 ) passwords = ['MyPass@1', 'weakpass', 'NoSpecial1', 'MyPassword@123'] for pwd in passwords: result = check_password_strength(pwd) valid = bool(STRONG_PASSWORD.match(pwd)) print(f"{pwd}: {result['strength']} (强密码: {valid})") ``` ### 案例 9：JSON 字段提取 ```python import re # 注意：复杂 JSON 请使用 json 模块。以下适用于日志中嵌入的 JSON 片段。 def extract_json_string_field(json_str, field_name): """提取 JSON 字符串字段值""" pattern = re.compile( rf'"{re.escape(field_name)}"\s*:\s*"([^"\\]*(?:\\.[^"\\]*)*)"' ) m = pattern.search(json_str) return m.group(1) if m else None def extract_json_number_field(json_str, field_name): """提取 JSON 数字字段值""" pattern = re.compile( rf'"{re.escape(field_name)}"\s*:\s*(-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)' ) m = pattern.search(json_str) return m.group(1) if m else None json_str = '{"name": "Alice", "age": 30, "email": "alice@example.com", "score": 98.5}' print(extract_json_string_field(json_str, 'name')) # 'Alice' print(extract_json_string_field(json_str, 'email')) # 'alice@example.com' print(extract_json_number_field(json_str, 'age')) # '30' print(extract_json_number_field(json_str, 'score')) # '98.5' # 提取所有键值对（仅字符串值） ALL_STRING_FIELDS = re.compile(r'"(\w+)"\s*:\s*"([^"\\]*(?:\\.[^"\\]*)*)"') fields = dict(ALL_STRING_FIELDS.findall(json_str)) print(fields) # {'name': 'Alice', 'email': 'alice@example.com'} ``` ### 案例 10：去除 HTML 标签 ```python import re def strip_html_tags(html): """移除所有 HTML 标签，保留文本内容""" # 移除 script 和 style 标签及其内容 clean = re.sub(r'<(script|style)[^>]*>.*?', '', html, flags=re.S | re.I) # 移除所有 HTML 标签 clean = re.sub(r'<[^>]+>', '', clean) # 替换 HTML 实体 entities = { '&': '&', '<': '<', '>': '>', '"': '"', ''': "'", ' ': ' ', } for entity, char in entities.items(): clean = clean.replace(entity, char) # 去除多余空白 clean = re.sub(r'\s+', ' ', clean).strip() return clean html = """ 测试页面

标题

这是一段文字，包含链接。

HTML实体：& < >  空格

""" print(strip_html_tags(html)) # '测试页面 标题 这是一段文字，包含链接。 HTML实体：& < > 空格' ``` ### 案例 11：爬虫中的常见提取场景 ```python import re # 提取页面标题 def extract_title(html): m = re.search(r']*>(.*?)', html, re.S | re.I) return m.group(1).strip() if m else None # 提取 meta 描述 def extract_meta_description(html): m = re.search( r']*name=["\']description["\'][^>]*content=["\']([^"\']+)["\']', html, re.I ) if not m: m = re.search( r']*content=["\']([^"\']+)["\'][^>]*name=["\']description["\']', html, re.I ) return m.group(1).strip() if m else None # 提取所有图片 src def extract_images(html): return re.findall(r']*src=["\']([^"\']+)["\']', html, re.I) # 提取所有链接 def extract_links(html): return re.findall(r']*href=["\']([^"\']+)["\']', html, re.I) # 提取 JSON-LD 结构化数据 def extract_jsonld(html): pattern = re.compile( r']*type=["\']application/ld\+json["\'][^>]*>(.*?)', re.S | re.I ) return pattern.findall(html) # 示例 html = """ 商品详情 - 示例网站 商品图片 分类一 外部链接 """ print(extract_title(html)) # '商品详情 - 示例网站' print(extract_meta_description(html)) # '这是商品描述信息' print(extract_images(html)) # ['/images/product.jpg', '/images/thumb.png'] print(extract_links(html)) # ['/category/1', 'https://external.com'] ``` ### 案例 12：日志解析 ```python import re from datetime import datetime # Nginx 访问日志格式： # 127.0.0.1 - frank [10/Oct/2000:13:55:36 -0700] "GET /apache_pb.gif HTTP/1.0" 200 2326 NGINX_LOG = re.compile( r'(?P\d{1,3}(?:\.\d{1,3}){3})\s+' # IP 地址 r'(?P\S+)\s+' # 标识（通常为 -） r'(?P\S+)\s+' # 用户名 r'\[(?P