引言

在现代软件开发和数据科学领域，对文本数据的处理能力是衡量效率和灵活性的关键指标之一。无论是验证用户输入的合法性、从海量日志中筛选关键信息、还是从非结构化文本中精准提取数据，我们都常常需要一种强大而精确的工具。此时，正则表达式 (Regular Expressions, Regex) 便应运而生。

正则表达式是一种描述字符串模式的语言，它通过一套精巧的字符序列和语法规则，使得我们能够以声明式的方式定义复杂的文本搜索逻辑。掌握正则表达式，不仅是提升文本处理效率的利器，更是赋能您驾驭各种数据挑战的“超能力”。

本教程将以 Python 语言的 re 模块为核心，带领您系统地学习正则表达式的模式构建艺术。我们将从最基础的字面量匹配开始，逐步深入到元字符、字符集、量词、特殊序列等核心语法，并详细探讨贪婪/非贪婪模式、捕获组、反向引用等高级技巧。针对每个概念，我们都将遵循“是什么”、“为什么”、“怎么做”的原则进行阐述，并辅以清晰、可运行的 Python 代码示例及输出解释。此外，教程还将涵盖综合实践案例、性能优化建议以及对“灾难性回溯”这一常见陷阱的深入剖析。

通过本教程的系统学习，您将能够：

• 理解正则表达式的核心概念、工作原理及其在 Python 中的应用。
• 掌握所有基本与高级的正则表达式语法元素，并能灵活组合。
• 学会如何编写精准、高效、可维护的正则表达式模式。
• 运用 Python re 模块进行文本的匹配、搜索、替换和分割操作。
• 识别并避免常见的正则表达式陷阱，如贪婪模式的误用和灾难性回溯。
• 提升解决实际文本处理问题的能力，成为文本数据领域的“模式构建专家”。

无论您是初涉编程的学生，寻求数据处理效率提升的开发者，还是希望在数据科学旅程中武装自己的分析师，本教程都将为您提供一份全面、系统且极具实践价值的学习路径。

目录

1. 什么是正则表达式？
   • 1.1. 正则表达式的用途与重要性
2. Python 中的正则表达式：re 模块概述
   • 2.1. 原始字符串 r"..." 的重要性
   • 2.2. 快速实践：re.search() 和 re.findall()
   • 2.3. 其他常用 re 模块函数概览
3. 正则表达式核心语法：构建模式的基石
   • 3.1. 字面量字符 (Literal Characters)
   • 3.2. 元字符 (Metacharacters)
     • 3.2.1. . (点号)：匹配任意单个字符
     • 3.2.2. ^ (脱字符)：匹配字符串或行开头
     • 3.2.3. $ (美元符号)：匹配字符串或行结尾
     • 3.2.4. | (竖线)：或操作 (Alternation)
     • 3.2.5. \ (反斜杠)：转义字符 (Escaping)
     • 3.2.6. () (圆括号)：分组与捕获 (Grouping & Capturing)
   • 3.3. 字符集 (Character Sets)
     • 3.3.1. [] (方括号)：匹配指定范围内的任意一个字符
     • 3.3.2. [^...] (反向字符集)：匹配不在指定范围内的任意一个字符
   • 3.4. 量词 (Quantifiers)：指定重复次数
     • 3.4.1. * (星号)：零次或多次
     • 3.4.2. + (加号)：一次或多次
     • 3.4.3. ? (问号)：零次或一次
     • 3.4.4. {n}：精确匹配 n 次
     • 3.4.5. {n,}：至少匹配 n 次
     • 3.4.6. {n,m}：匹配 n 到 m 次
   • 3.5. 特殊序列 (Special Sequences)：常用字符集简写
     • 3.5.1. \d, \D：数字与非数字
     • 3.5.2. \s, \S：空白字符与非空白字符
     • 3.5.3. \w, \W：单词字符与非单词字符
     • 3.5.4. \b, \B：单词边界与非单词边界
4. 进阶模式构建技巧
   • 4.1. 贪婪与非贪婪模式 (*?, +?, ??, {m,n}?)
   • 4.2. 非捕获组 (?:...)
   • 4.3. 反向引用 \n 或 \g<n> (Backreferences)
   • 4.4. 正则表达式标志 (Flags)
     • 4.4.1. re.IGNORECASE (或 re.I)：忽略大小写
     • 4.4.2. re.MULTILINE (或 re.M)：多行模式
     • 4.4.3. re.DOTALL (或 re.S)：点号匹配换行符
     • 4.4.4. 组合使用标志
5. 综合实践：模式写作案例
   • 5.1. 提取 IP 地址
   • 5.2. 验证电话号码
   • 5.3. 清理重复的单词
   • 5.4. 提取邮件地址与用户名
   • 5.5. 从 HTML/XML 中提取标签内容
6. 正则表达式写作最佳实践与调试
   • 6.1. 逐步构建与测试
   • 6.2. 利用在线工具进行可视化与测试
   • 6.3. 保持可读性：使用命名捕获组与详细模式 re.VERBOSE (或 re.X)
   • 6.4. 性能考量：re.compile() 的使用
   • 6.5. 避免“灾难性回溯” (Catastrophic Backtracking)
     • 6.5.1. 什么是灾难性回溯
     • 6.5.2. 灾难性回溯的原因
     • 6.5.3. 如何避免灾难性回溯
       • 6.5.3.1. 使用精确量词
       • 6.5.3.2. 减少模糊匹配
       • 6.5.3.3. 使用原子组 (?>...) (仅部分引擎支持，Python不支持) 或占有量词 *+ (仅部分引擎支持)
7. 结语与进一步学习

---

1. 什么是正则表达式？

正则表达式，通常简称为 regex、regexp 或 RE，是一种用于描述文本模式的强大语言。它通过特定的字符序列（模式），让计算机能够高效地执行以下任务：搜索、匹配、提取、替换和分割文本。可以将正则表达式理解为一种微型编程语言，专门用于字符串处理。它提供了一套简洁而富有表达力的语法，能够以极高的灵活性描述各种复杂的字符串模式。

1.1. 正则表达式的用途与重要性

正则表达式在现代软件开发和数据处理中扮演着不可或缺的角色，其应用场景广泛且影响深远：

• 数据清洗与预处理：从原始文本中移除噪音，例如 HTML 标签、URL、不必要的空格或特殊符号，为后续的数据分析和机器学习任务提供高质量的输入。
• 数据验证：在用户输入、配置文件或数据导入时，验证数据是否符合特定的格式要求，如电子邮件地址、电话号码、日期、密码强度等，确保数据的一致性和有效性。
• 信息提取：从非结构化或半结构化数据源（如日志文件、网页内容、API 响应）中精准地抽取所需的信息，例如提取股票代码、日期时间、错误代码或用户ID。
• 文本编辑器与IDE：几乎所有现代文本编辑器和集成开发环境（IDE）都支持正则表达式作为其高级搜索和替换功能的核心，极大地提升了开发者的工作效率。
• 日志分析：快速定位并分析日志文件中的特定事件或错误模式，帮助系统管理员和开发者进行故障排查和性能监控。
• 编程语言与脚本：作为一项通用的文本处理技能，正则表达式内置于几乎所有主流编程语言（Python, Java, JavaScript, C#, Ruby, PHP, Go等）中，是编写脚本和自动化任务的利器。

掌握正则表达式，意味着您获得了驾驭文本数据的超能力，能够以简洁而高效的方式解决各种复杂的文本处理问题，从而在数据处理和软件开发领域更具竞争力。

2. Python 中的正则表达式：re 模块概述

Python 通过其内置的 re 模块提供全面的正则表达式功能。在任何 Python 脚本中，您只需通过 import re 即可开始使用它。re 模块提供了一系列函数，用于执行匹配、搜索、替换、分割等多种操作。

2.1. 原始字符串 r"..." 的重要性

在 Python 中定义正则表达式模式时，强烈推荐使用原始字符串 (raw string)，即在字符串字面量前加上 r 或 R（例如：r"your\pattern" 而不是 "\your\pattern"）。这是因为 Python 字符串和正则表达式都使用反斜杠 \ 作为特殊字符的转义符，这可能导致混淆和错误。

• “是什么”：原始字符串会指示 Python 解释器不对字符串中的反斜杠进行任何转义处理，而是将它们视为字面量字符。
• “为什么”：
  • Python 字符串转义：在 Python 普通字符串中，\n 表示换行符，\t 表示制表符，\\ 表示一个字面量的反斜杠。
  • 正则表达式转义：在正则表达式中，\d 表示数字，\s 表示空白字符，\. 表示字面量的点号（因为 . 也是元字符）。如果模式中需要匹配一个字面量的反斜杠，正则表达式本身需要 \\。
  • 冲突与冗余：当您在普通 Python 字符串中定义包含反斜杠的正则表达式时，Python 解释器会首先处理字符串本身的转义。例如，如果您想匹配正则表达式中的 \d（数字），在普通字符串中您可能需要写成 \\d，因为 \d 本身不是一个标准的 Python 转义序列。这使得正则表达式模式变得冗长、难以阅读且极易出错。
• “怎么做”：在字符串前加上 r。

import re

# 示例：原始字符串与普通字符串的区别

# 1. Python 字符串转义示例
print("普通字符串中的换行符: \nPython")
print(r"原始字符串中的字面量 \nPython")

# 2. 匹配字面量反斜杠的正则表达式模式
# 普通字符串模式（需要双重转义，非常不直观且容易出错）
pattern_normal_string = "\\\\" 
print(f"\n普通字符串模式表示: '{pattern_normal_string}' (实际存储的字符串是单反斜杠 '\\')")
print(f"匹配结果 (普通字符串模式): {re.findall(pattern_normal_string, r"C:\Users\Doc")}")

# 原始字符串模式（更清晰、简洁，推荐写法）
pattern_raw_string = r"\\" 
print(f"原始字符串模式表示: '{pattern_raw_string}' (实际存储的字符串也是单反斜杠 '\\')")
print(f"匹配结果 (原始字符串模式): {re.findall(pattern_raw_string, r"C:\Users\Doc")}")

# 3. 匹配特殊序列 \d 的例子
# 普通字符串模式 (Python会先处理\d，发现不是有效的Python转义，可能会报错或原样保留，但意图不明确)
# re.search("\d+", "123")  # 警告或错误：Invalid escape sequence '\d' (Python 3.6+)
# 正确写法应该是: re.search("\\d+", "123")

# 使用原始字符串则清晰明了，推荐写法:
match_digit = re.search(r"\d+", "Found 123 numbers.")
print(f"\n使用原始字符串匹配数字: {match_digit.group() if match_digit else '无匹配'}")

输出示例：

普通字符串中的换行符: 
Python
原始字符串中的字面量 \nPython

普通字符串模式表示: '\\' (实际存储的字符串是单反斜杠 '\')
匹配结果 (普通字符串模式): ['\\', '\\']
原始字符串模式表示: '\\' (实际存储的字符串也是单反斜杠 '\')
匹配结果 (原始字符串模式): ['\\', '\\']

使用原始字符串匹配数字: 123

通过上述示例，我们可以清晰地看到使用原始字符串的巨大优势，它消除了 Python 字符串转义和正则表达式转义之间的歧义。从现在开始，本教程中的所有正则表达式模式都将统一使用原始字符串。

2.2. 快速实践：re.search() 和 re.findall()

在深入探讨正则表达式的具体语法之前，让我们通过 re 模块的两个基本函数快速了解如何应用正则表达式模式来查找文本：

• re.search(pattern, string, flags=0)：

  • “是什么”：在给定的 string 中扫描，查找第一个匹配 pattern 的位置。
  • “为什么”：当您需要判断字符串中是否存在某个模式，或者仅对第一个匹配项感兴趣时，re.search() 是理想选择。它返回一个 Match 对象，其中包含有关匹配的详细信息。如果未找到匹配，则返回 None。
  • “怎么做”：调用 re.search() 并传入您的模式和目标字符串。

• re.findall(pattern, string, flags=0)：

  • “是什么”：在给定的 string 中查找所有非重叠的匹配 pattern。
  • “为什么”：当您需要从文本中提取所有符合特定模式的子字符串时，re.findall() 非常方便。
  • “怎么做”：它以列表形式返回所有匹配到的字符串。如果模式包含捕获组（稍后介绍），则返回一个元组列表，每个元组包含对应捕获组的匹配内容。

import re

text_example = "The quick brown fox jumps over the lazy dog. Another Fox is hiding."

# 1. 使用 re.search 查找第一个 "fox" (忽略大小写)
# re.IGNORECASE 是一个标志，表示忽略大小写，会在后续章节详细介绍
match_obj = re.search(r"fox", text_example, re.IGNORECASE) 
if match_obj:
    print(f"re.search 找到第一个匹配:")
    print(f"  完整匹配文本: '{match_obj.group(0)}'") # .group(0) 或 .group() 返回整个匹配到的字符串
    print(f"  匹配的起始和结束位置: {match_obj.span()}") # .span() 返回 (start, end) 元组
    print(f"  匹配的起始索引: {match_obj.start()}") # .start() 返回起始索引
    print(f"  匹配的结束索引 (不包含): {match_obj.end()}") # .end() 返回结束索引
else:
    print("re.search 未找到匹配。")

# 2. 使用 re.findall 查找所有 "fox" (忽略大小写)
all_foxes = re.findall(r"fox", text_example, re.IGNORECASE)
print(f"\nre.findall 找到所有匹配: {all_foxes}")

# 3. re.findall 结合捕获组的例子
text_dates = "Today is 2023-10-27 and tomorrow is 2023-10-28."
date_pattern = r"(\d{4})-(\d{2})-(\d{2})" # 年、月、日分别是一个捕获组
all_dates = re.findall(date_pattern, text_dates)
print(f"\nre.findall 结合捕获组匹配日期: {all_dates}")

输出示例：

re.search 找到第一个匹配:
  完整匹配文本: 'fox'
  匹配的起始和结束位置: (16, 19)
  匹配的起始索引: 16
  匹配的结束索引 (不包含): 19

re.findall 找到所有匹配: ['fox', 'Fox']

re.findall 结合捕获组匹配日期: [('2023', '10', '27'), ('2023', '10', '28')]

2.3. 其他常用 re 模块函数概览

除了 re.search() 和 re.findall()，re 模块还提供了其他一些非常实用的函数，用于执行不同的正则表达式操作：

• re.match(pattern, string, flags=0)：

  • “是什么”：尝试从 string 的开头匹配 pattern。
  • “为什么”：与 re.search() 不同，re.match() 仅检查字符串的起始位置。如果模式不在字符串开头，即使字符串后面有匹配，re.match() 也不会找到。它通常用于验证整个字符串是否符合某个模式。
  • “怎么做”：用法与 re.search() 类似，返回 Match 对象或 None。

• re.fullmatch(pattern, string, flags=0)：

  • “是什么”：尝试匹配整个 string，要求 string 完全与 pattern 匹配。
  • “为什么”：这是最严格的匹配方式，确保整个字符串都符合模式，没有多余的字符。非常适用于数据格式的完整校验。
  • “怎么做”：用法与 re.search() 类似，返回 Match 对象或 None。

• re.sub(pattern, repl, string, count=0, flags=0)：

  • “是什么”：在 string 中找到所有匹配 pattern 的子字符串，并用 repl 进行替换。
  • “为什么”：用于执行文本的查找和替换操作，可以非常灵活地清理、格式化或修改文本。repl 可以是字符串，也可以是一个函数。
  • “怎么做”：返回替换后的字符串。count 参数限制替换次数。

• re.split(pattern, string, maxsplit=0, flags=0)：

  • “是什么”：使用 pattern 作为分隔符，将 string 分割成一个列表。
  • “为什么”：当您需要根据复杂的模式而不是固定的字符来分割字符串时，re.split() 非常有用。
  • “怎么做”：返回分割后的字符串列表。maxsplit 参数限制分割次数。

• re.finditer(pattern, string, flags=0)：

  • “是什么”：在 string 中查找所有非重叠匹配，并返回一个迭代器，每次迭代产生一个 Match 对象。
  • “为什么”：当您需要处理大量匹配结果，并且希望避免一次性将所有结果加载到内存中时，re.finditer() 比 re.findall() 更高效。它也提供了 Match 对象的完整信息。
  • “怎么做”：通过 for 循环遍历迭代器，访问每个 Match 对象。

import re

text_long = "Hello World! This is a test. Python is awesome. Hello again!"

# re.match: 仅从字符串开头匹配
match_hello = re.match(r"Hello", text_long)
print(f"re.match('Hello', text_long): {match_hello.group() if match_hello else '无匹配'}") # 输出: Hello

match_world = re.match(r"World", text_long) # 不匹配，因为 'World' 不在开头
print(f"re.match('World', text_long): {match_world.group() if match_world else '无匹配'}") # 输出: 无匹配

# re.fullmatch: 匹配整个字符串
full_match_example = re.fullmatch(r"Hello World! This is a test. Python is awesome. Hello again!", text_long)
print(f"re.fullmatch (完整匹配): {full_match_example.group() if full_match_example else '无匹配'}") # 输出: 整个字符串

full_match_fail = re.fullmatch(r"Hello World!", text_long) # 不完整匹配
print(f"re.fullmatch (不完整匹配): {full_match_fail.group() if full_match_fail else '无匹配'}") # 输出: 无匹配

# re.sub: 查找并替换
replaced_text = re.sub(r"Hello", "Hi", text_long, count=1) # 只替换第一个
print(f"re.sub 替换 'Hello' 为 'Hi' (一次): {replaced_text}") # 输出: Hi World! This is a test. Python is awesome. Hello again!

replaced_all = re.sub(r"Hello", "Hi", text_long) # 替换所有
print(f"re.sub 替换 'Hello' 为 'Hi' (所有): {replaced_all}") # 输出: Hi World! This is a test. Python is awesome. Hi again!

# re.split: 分割字符串
split_parts = re.split(r"\s+", "Apple  Banana\tCherry\nDate") # 多个空白字符作为分隔符
print(f"re.split 分割字符串: {split_parts}") # 输出: ['Apple', 'Banana', 'Cherry', 'Date']

# re.finditer: 返回迭代器
print("\n使用 re.finditer 遍历所有匹配:")
for match in re.finditer(r"\b\w{6}\b", text_long): # 匹配6个字母的单词
    print(f"  找到单词: '{match.group()}' 在位置 {match.span()}")

输出示例：

re.match('Hello', text_long): Hello
re.match('World', text_long): 无匹配
re.fullmatch (完整匹配): Hello World! This is a test. Python is awesome. Hello again!
re.fullmatch (不完整匹配): 无匹配
re.sub 替换 'Hello' 为 'Hi' (一次): Hi World! This is a test. Python is awesome. Hello again!
re.sub 替换 'Hello' 为 'Hi' (所有): Hi World! This is a test. Python is awesome. Hi again!
re.split 分割字符串: ['Apple', 'Banana', 'Cherry', 'Date']

使用 re.finditer 遍历所有匹配:
  找到单词: 'Python' 在位置 (23, 29)
  找到单词: 'awesome' 在位置 (33, 40)

通过对 re 模块主要函数的概览，您应该对如何在 Python 中应用正则表达式有了全面的认识。接下来，我们将深入学习正则表达式的核心语法，它们是构建任何复杂模式的基石。

3. 正则表达式核心语法：构建模式的基石

正则表达式的强大之处在于其精巧的语法。理解这些基本构建块是编写任何复杂模式的关键。本节将详细介绍正则表达式的字面量字符、元字符、字符集、量词和特殊序列。

3.1. 字面量字符 (Literal Characters)

• “是什么”：正则表达式中最简单的匹配方式。大多数字符（如字母、数字、大部分符号）都直接匹配它们本身，而无需特殊处理。
• “为什么”：这是构建任何模式的基础，它允许我们匹配字符串中固定的、不变的部分。当模式中包含不变的文本片段时，字面量字符是首选。
• “怎么做”：直接在模式中写入需要匹配的字符。

import re

text = "Hello World! The year is 2023."

# 匹配 "Hello"
match1 = re.search(r"Hello", text)
print(f"匹配 'Hello': {match1.group() if match1 else '无匹配'}")

# 匹配 "year"
match2 = re.search(r"year", text)
print(f"匹配 'year': {match2.group() if match2 else '无匹配'}")

# 匹配字面量的 "!" (需要注意，某些特殊符号如 "." "*" "?" 等是元字符，需要转义才能作为字面量匹配)
match3 = re.search(r"!", text) 
print(f"匹配字面量 '!': {match3.group() if match3 else '无匹配'}")

输出示例：

匹配 'Hello': Hello
匹配 'year': year
匹配字面量 '!': !

3.2. 元字符 (Metacharacters)

元字符是具有特殊含义的字符，它们不匹配自身，而是匹配某种模式、字符类别或字符串中的特定位置。它们是正则表达式灵活性的核心。

3.2.1. . (点号)：匹配任意单个字符

• “是什么”：匹配除换行符 \n 之外的任意单个字符。
• “为什么”：当您需要在某个位置上匹配可以是任意字符但又不想指定具体字符时，点号 非常有用。例如，匹配一个未知字符但前后字符固定的模式。
• “怎么做”：直接在模式中使用 .。如果需要匹配字面量的点号，则必须进行转义 \.。

import re

text = "cat, hat, bat, mat, fat, chat, car, cot"

# 匹配任意字符 + 'at'
matches = re.findall(r".at", text)
print(f"匹配 '.at': {matches}")
# 说明: 'cat', 'hat', 'bat', 'mat', 'fat' 都匹配。'chat' 中的 'hat' 由于 findall 的非重叠特性未单独列出。
# 'car' 和 'cot' 不匹配，因为最后两个字符不是 'at'。

text_newline = "line1\nline2"
match_dot_default = re.search(r"line.line", text_newline)
print(f"匹配 'line.line' (默认情况下不匹配换行符): {match_dot_default.group() if match_dot_default else '无匹配'}") 
# 输出: 无匹配 (因为 '.' 默认不匹配 '\n')

# 匹配字面量的点号，需要转义
match_literal_dot = re.search(r"1\.2", "Version 1.2.3")
print(f"匹配字面量 '1.2': {match_literal_dot.group() if match_literal_dot else '无匹配'}")

输出示例：

匹配 '.at': ['cat', 'hat', 'bat', 'mat', 'fat']
匹配 'line.line' (默认情况下不匹配换行符): 无匹配
匹配字面量 '1.2': 1.2

注意：要让 . 也匹配换行符，需要使用 re.DOTALL 标志，我们将在 4.4.3. re.DOTALL (或 re.S) 中详细介绍。

3.2.2. ^ (脱字符)：匹配字符串或行开头

• “是什么”：^ 元字符匹配字符串的起始位置。
• “为什么”：当您需要确保模式从文本的某个特定起点开始匹配时（例如验证一个文件路径必须以特定字符开始，或者一段文本必须以某个关键词开头），^ 是关键。它能有效限制匹配范围，提高匹配的精确性。
• “怎么做”：将 ^ 放在模式的最前面。

import re

text = "Python is a popular language.\nPython development is growing."

# 匹配字符串开头的 "Python"
match_start_str = re.search(r"^Python", text)
print(f"字符串开头匹配 '^Python': {match_start_str.group() if match_start_str else '无匹配'}")

# 匹配字符串开头的 "language"
match_start_fail = re.search(r"^language", text)
print(f"字符串开头匹配 '^language': {match_start_fail.group() if match_start_fail else '无匹配'}")

输出示例：

字符串开头匹配 '^Python': Python
字符串开头匹配 '^language': 无匹配

注意：在 re.MULTILINE 模式下，^ 会匹配每一行的开头，而不仅仅是整个字符串的开头。详见 4.4.2. re.MULTILINE (或 re.M)。

3.2.3. $ (美元符号)：匹配字符串或行结尾

• “是什么”：$ 元字符匹配字符串的结束位置。
• “为什么”：当您需要确保模式在文本的某个特定终点结束时（例如验证一个文件名必须以特定扩展名结尾，或一段文本必须以某个标点符号结束），$ 是关键。它与 ^ 结合，可以实现对整个字符串的精确匹配。
• “怎么做”：将 $ 放在模式的最后面。

import re

text = "Python is a popular language.\nPython development is growing."

# 匹配字符串结尾的 "growing." (注意 '.' 需要转义)
match_end_str = re.search(r"growing\.$", text) 
print(f"字符串结尾匹配 'growing\\.$': {match_end_str.group() if match_end_str else '无匹配'}")

# 匹配字符串结尾的 "language." (不匹配，因为后面有换行符和更多内容)
match_end_fail = re.search(r"language\.$", text)
print(f"字符串结尾匹配 'language\\.$': {match_end_fail.group() if match_end_fail else '无匹配'}")

输出示例：

字符串结尾匹配 'growing\.$': growing.
字符串结尾匹配 'language\.$': 无匹配

注意：在 re.MULTILINE 模式下，$ 会匹配每一行的结尾，而不仅仅是整个字符串的结尾。详见 4.4.2. re.MULTILINE (或 re.M)。

3.2.4. | (竖线)：或操作 (Alternation)

• “是什么”：| 元字符表示“或”关系，它匹配竖线左边或右边的任意一个模式。
• “为什么”：当您需要匹配多种可能的字符串模式中的任意一种时，| 提供了极大的灵活性。例如，在同一个搜索中查找多个关键词。
• “怎么做”：将两个或多个模式用 | 分隔。

import re

text = "apple, banana, cherry, grape, kiwi"

# 匹配 "apple" 或 "grape"
matches = re.findall(r"apple|grape", text)
print(f"匹配 'apple|grape': {matches}")

# 结合其他模式，匹配 "red apple" 或 "green banana"
text_colors = "I like red apple and green banana, but not blue cherry."
matches_colors = re.findall(r"red apple|green banana", text_colors)
print(f"匹配 'red apple|green banana': {matches_colors}")

# 配合分组 () 进行更复杂的“或”逻辑
matches_fruit_types = re.findall(r"(apple|banana|cherry)", text_colors)
print(f"匹配水果类型 '(apple|banana|cherry)': {matches_fruit_types}")

输出示例：

匹配 'apple|grape': ['apple', 'grape']
匹配 'red apple|green banana': ['red apple', 'green banana']
匹配水果类型 '(apple|banana|cherry)': ['apple', 'banana', 'cherry']

3.2.5. \ (反斜杠)：转义字符 (Escaping)

• “是什么”：\ 反斜杠在正则表达式中是一个多功能字符。它的主要作用是转义，即将紧随其后的元字符（如 . * ? 等）转变为字面量字符，使其失去特殊含义；或者将紧随其后的字面量字符转变为具有特殊含义的特殊序列（如 \d \s \b 等）。
• “为什么”：
  • 匹配字面量元字符：当您需要匹配一个正则表达式中具有特殊含义的字符本身时，例如匹配一个字面量的问号 ? 而不是问号量词，就需要 \?。
  • 引入特殊序列：\ 也用于引入一系列预定义的特殊字符序列，这些序列代表了常用的字符集或位置断言，极大地简化了模式的编写。
• “怎么做”：在需要转义的元字符前加上 \。对于特殊序列，直接使用 \ 后面跟对应字符即可。由于我们强制使用原始字符串 r"..."，您无需担心 Python 字符串的额外转义问题。

import re

text = "What's the price? Is it $10.99 or $15.50? And 2*3=6."

# 匹配字面量问号 '?'
matches_q_mark = re.findall(r"\?", text)
print(f"匹配字面量 '?': {matches_q_mark}")

# 匹配字面量 '$' 和 '.'
matches_price = re.findall(r"\$\d+\.\d+", text)
print(f"匹配价格 '\\$\\d+\\.\\d+': {matches_price}")

# 匹配字面量 '*'
matches_star = re.findall(r"2\*3", text)
print(f"匹配字面量 '2*3': {matches_star}")

输出示例：

匹配字面量 '?': ['?', '?']
匹配价格 '\$\d+\.\d+': ['$10.99', '$15.50']
匹配字面量 '2*3': ['2*3']

3.2.6. () (圆括号)：分组与捕获 (Grouping & Capturing)

• “是什么”：圆括号 () 在正则表达式中具有两个核心功能：分组和捕获。
  • 分组 (Grouping)：将多个字符或模式组合成一个逻辑单元，使其作为一个整体。
  • 捕获 (Capturing)：将分组匹配到的子字符串提取出来，供后续使用。每个捕获组都会按照从左到右的顺序自动获得一个数字索引（从 1 开始），可以通过 Match 对象的 group(index) 方法访问。group(0) 或 group() 返回整个匹配的字符串。
• “为什么”：
  • 对组应用量词：例如，要匹配重复的单词对，如 “go go”，您可以写 (go\s)+ 而不是 go\s+（后者只会重复空格）。
  • 对组应用“或”操作：例如 (cat|dog)food 可以匹配 “catfood” 或 “dogfood”，而不是 cat|dogfood（它会匹配 “cat” 或 “dogfood”）。
  • 提取特定部分：当您需要从复杂字符串中提取结构化的信息时，捕获组是不可或缺的。例如，从日期字符串中分别提取年、月、日。
• “怎么做”：将需要分组或捕获的模式放在 () 中。

import re

text = "The date is 2023-10-26. Another date is 2024-01-15. We say hahahaha!"

# 示例 1: 分组（对组应用量词）
# 匹配重复的 "ha"
matches_repeat = re.findall(r"(ha){2,}", text) # 匹配至少两个 "ha"
print(f"匹配 '(ha){{2,}}': {matches_repeat}") # 输出: ['ha']
# 说明：`findall` 对于含有捕获组的模式，默认返回捕获组中的内容。这里因为 (ha) 是捕获组，所以返回的是 'ha'。
# 如果想获取整个匹配，需要使用 re.finditer

# 使用 re.finditer 获取完整的匹配
print("\n使用 re.finditer 匹配 '(ha){2,}':")
for match_obj in re.finditer(r"(ha){2,}", text):
    print(f"  完整匹配: '{match_obj.group(0)}', 捕获组内容: '{match_obj.group(1)}'")
# 输出: 完整匹配: 'hahahaha', 捕获组内容: 'ha'

# 示例 2: 分组（对组应用 | 操作）
text_foods = "I like catfood and dogfood."
matches_foods = re.findall(r"(cat|dog)food", text_foods)
print(f"\n匹配 '(cat|dog)food': {matches_foods}") # 返回捕获组内容：['cat', 'dog']

# 示例 3: 捕获组（提取日期中的年、月、日）
pattern_date = r"(\d{4})-(\d{2})-(\d{2})" # 包含三个捕获组
matches_dates = re.findall(pattern_date, text)
print(f"\n捕获所有日期: {matches_dates}")

# 使用 re.search 获取 Match 对象，并通过索引访问捕获组
match_obj_date = re.search(pattern_date, text)
if match_obj_date:
    print(f"\n对第一个日期匹配的详细信息:")
    print(f"  完整匹配 (group(0)): {match_obj_date.group(0)}") # 整个匹配
    print(f"  年份 (group(1)): {match_obj_date.group(1)}") # 第一个捕获组
    print(f"  月份 (group(2)): {match_obj_date.group(2)}") # 第二个捕获组
    print(f"  日期 (group(3)): {match_obj_date.group(3)}") # 第三个捕获组
    print(f"  所有捕获组内容 (groups()): {match_obj_date.groups()}") # 返回所有捕获组的元组

输出示例：

匹配 '(ha){2,}': ['ha']

使用 re.finditer 匹配 '(ha){2,}':
  完整匹配: 'hahahaha', 捕获组内容: 'ha'

匹配 '(cat|dog)food': ['cat', 'dog']

捕获所有日期: [('2023', '10', '26'), ('2024', '01', '15')]

对第一个日期匹配的详细信息:
  完整匹配 (group(0)): 2023-10-26
  年份 (group(1)): 2023
  月份 (group(2)): 10
  日期 (group(3)): 26
  所有捕获组内容 (groups()): ('2023', '10', '26')

3.3. 字符集 (Character Sets)

字符集允许您匹配一组字符中的任意一个。它们用方括号 [] 表示。

3.3.1. [] (方括号)：匹配指定范围内的任意一个字符

• “是什么”：[] 匹配方括号内定义的任意一个字符。
• “为什么”：当您需要在某个位置匹配多种字符中的一个，而不是固定字符时，字符集非常灵活。例如，匹配所有元音字母、数字范围或自定义的一组字符。
• “怎么做”：将需要匹配的字符或字符范围放在 [] 中。
  • [abc]：匹配 a、b 或 c 中的任意一个。
  • [a-z]：匹配任意小写字母。
  • [A-Z]：匹配任意大写字母。
  • [0-9]：匹配任意数字。
  • [a-zA-Z0-9]：匹配任意字母或数字。
  • 在字符集中，大部分元字符（如 ., *, ?, +, (, )）会失去其特殊含义，被视为字面量字符，但 \ (转义)、- (表示范围，除非在开头或结尾)、^ (反向，如果放在开头) 仍然具有特殊含义。

import re

text = "The quick brown fox jumps over the lazy dog. 123 eggs, 456."

# 匹配任意元音字母 (忽略大小写)
matches_vowels = re.findall(r"[aeiouAEIOU]", text) # 或者使用 re.IGNORECASE 标志
print(f"匹配元音字母 '[aeiouAEIOU]': {matches_vowels}")

# 匹配任意数字或字母
matches_alnum = re.findall(r"[a-zA-Z0-9]", text)
print(f"匹配数字或字母 '[a-zA-Z0-9]': {matches_alnum[:20]}...") # 打印前20个

# 匹配特殊字符，如逗号或句号
matches_punct = re.findall(r"[,.]", text)
print(f"匹配逗号或句号 '[,.]': {matches_punct}")

输出示例：

匹配元音字母 '[aeiouAEIOU]': ['e', 'u', 'i', 'o', 'o', 'u', 'o', 'e', 'e', 'a', 'o', 'e', 'e']
匹配数字或字母 '[a-zA-Z0-9]': ['T', 'h', 'e', 'q', 'u', 'i', 'c', 'k', 'b', 'r', 'o', 'w', 'n', 'f', 'o', 'x', 'j', 'u', 'm', 'p']...
匹配逗号或句号 '[,.]': [',', '.', ',']

3.3.2. [^...] (反向字符集)：匹配不在指定范围内的任意一个字符

• “是什么”：当 ^ 字符出现在字符集 [] 的开头时，它表示“非”或“不匹配”。它匹配除了方括号内定义的字符之外的任意一个字符（包括换行符）。
• “为什么”：当您需要匹配所有不属于某个特定集合的字符时，反向字符集非常有用。例如，匹配所有非数字字符、所有非字母字符等。
• “怎么做”：将 ^ 放在 [] 内的开头。

import re

text = "Hello, World! This is a test. 123."

# 匹配所有非数字字符
matches_non_digit = re.findall(r"[^0-9]", text)
print(f"匹配非数字字符 '[^0-9]': {matches_non_digit[:20]}...") # 打印前20个

# 匹配所有非字母、非空格、非句号的字符
matches_non_alpha_space_dot = re.findall(r"[^a-zA-Z\s.]", text)
print(f"匹配非字母、非空格、非句号 '[^a-zA-Z\s.]': {matches_non_alpha_space_dot}")

输出示例：

匹配非数字字符 '[^0-9]': ['H', 'e', 'l', 'l', 'o', ',', ' ', 'W', 'o', 'r', 'l', 'd', '!', ' ', 'T', 'h', 'i', 's', ' ', 'i']...
匹配非字母、非空格、非句号 '[^a-zA-Z\s.]': [',', '!', '1', '2', '3']

3.4. 量词 (Quantifiers)：指定重复次数

量词允许您指定前一个字符、字符集或组应该出现多少次。默认情况下，量词是贪婪的 (greedy)，它们会尽可能多地匹配字符。

3.4.1. * (星号)：零次或多次

• “是什么”：匹配前一个元素（可以是单个字符、字符集或分组）零次或多次。
• “为什么”：当某个字符或模式可能存在，也可能不存在，或者可能重复多次，且不关心具体次数时使用。它是最宽松的量词。
• “怎么做”：放在需要重复的元素后面。

import re

text = "ab, abb, abbb, ac, a, aabbb"

# 匹配 'a' 后跟零个或多个 'b'
matches = re.findall(r"ab*", text)
print(f"匹配 'ab*': {matches}")
# 说明: 'ab', 'abb', 'abbb' 匹配。 'ac' 中的 'a' 和单独的 'a' 也匹配，因为 'b' 出现了零次。
# 'aabbb' 匹配 'a' 和后面的 'bbb' (因为 'a' 也可以是 'b' 前面的字符)

输出示例：

匹配 'ab*': ['ab', 'abb', 'abbb', 'a', 'a', 'abbb']

3.4.2. + (加号)：一次或多次

• “是什么”：匹配前一个元素一次或多次。
• “为什么”：当某个字符或模式必须至少出现一次，并且可能重复多次时使用。它比 * 更严格，确保匹配的元素至少存在。
• “怎么做”：放在需要重复的元素后面。

import re

text = "ab, abb, abbb, ac, a"

# 匹配 'a' 后跟一个或多个 'b'
matches = re.findall(r"ab+", text)
print(f"匹配 'ab+': {matches}")
# 说明: 'ac' 中的 'a' 和单独的 'a' 不匹配，因为它们后面没有 'b' 或 'b' 出现的次数少于一次。

输出示例：

匹配 'ab+': ['ab', 'abb', 'abbb']

3.4.3. ? (问号)：零次或一次

• “是什么”：匹配前一个元素零次或一次。
• “为什么”：当某个字符或模式是可选的（可有可无），且最多只出现一次时使用。例如，匹配单词的变体，如 “color” 和 “colour”。
• “怎么做”：放在需要重复的元素后面。

import re

text = "color, colour, colr, coloor"

# 匹配 'colo' 后跟零个或一个 'u'，再跟 'r'
matches = re.findall(r"colou?r", text)
print(f"匹配 'colou?r': {matches}")
# 说明: 'colr' 不匹配，因为 'u' 后需要 'r'。'coloor' 中的 'oo' 不符合 'u?' 的规则。

输出示例：

匹配 'colou?r': ['color', 'colour']

3.4.4. {n}：精确匹配 n 次

• “是什么”：精确匹配前一个元素**n 次**。
• “为什么”：当您需要精确控制某个字符或模式的重复次数时，例如匹配固定位数的电话号码或邮政编码。
• “怎么做”：放在需要重复的元素后面，n 是一个正整数。

import re

text = "123, 1234, 12345, 12, 987"

# 精确匹配 3 个数字
matches = re.findall(r"\d{3}", text)
print(f"匹配 '\\d{{3}}': {matches}")
# 说明: 从 '1234' 中匹配 '123'，从 '12345' 中匹配 '123' (因为 findall 是非重叠的，它会找到第一个3位数字)。

输出示例：

匹配 '\d{3}': ['123', '123', '123', '987']

3.4.5. {n,}：至少匹配 n 次

• “是什么”：匹配前一个元素至少 n 次。
• “为什么”：当您需要设置重复次数的下限时，例如匹配至少 5 个字符的密码。
• “怎么做”：放在需要重复的元素后面，n 是一个正整数。

import re

text = "123, 1234, 12345, 12, 1"

# 匹配至少 3 个数字
matches = re.findall(r"\d{3,}", text)
print(f"匹配 '\\d{{3,}}': {matches}")
# 说明: '12' 和 '1' 不匹配，因为它们少于3个数字。

输出示例：

匹配 '\d{3,}': ['123', '1234', '12345']

3.4.6. {n,m}：匹配 n 到 m 次

• “是什么”：匹配前一个元素至少 n 次，最多 m 次。
• “为什么”：当您需要控制重复次数的上下限时，提供更精确的匹配范围。例如，匹配一个 7 到 11 位的电话号码。
• “怎么做”：放在需要重复的元素后面，n 和 m 都是正整数，且 n <= m。

import re

text = "123, 1234, 12345, 12, 123456"

# 匹配 2 到 4 个数字
matches = re.findall(r"\d{2,4}", text)
print(f"匹配 '\\d{{2,4}}': {matches}")
# 说明: '12345' 会匹配到 '1234' (贪婪模式下尽可能多，但不超过上限)。'123456' 匹配到 '1234'。
# '12' 匹配，因为它在 2 到 4 次之间。

输出示例：

匹配 '\d{2,4}': ['123', '1234', '1234', '12', '1234']

3.5. 特殊序列 (Special Sequences)：常用字符集简写

特殊序列是反斜杠 \ 后跟一个特殊字符，它们是常用字符集或位置断言的简写，极大地提高了正则表达式的简洁性和可读性。

3.5.1. \d, \D：数字与非数字

• \d：
  • “是什么”：匹配任意数字 (0-9)。等同于字符集 [0-9]。
  • “为什么”：这是匹配数字最简洁直观的方式，比写 [0-9] 更省事。
  • “怎么做”：直接在模式中使用 \d。
• \D：
  • “是什么”：匹配任意非数字字符。等同于反向字符集 [^0-9]。
  • “为什么”：方便地匹配所有非数字内容，例如提取文本中的非数值部分。
  • “怎么做”：直接在模式中使用 \D。

import re

text = "Item A: 123, Item B: 45.6, Item C"

# 匹配一个或多个数字
digits = re.findall(r"\d+", text)
print(f"匹配数字 '\\d+': {digits}")

# 匹配一个或多个非数字字符
non_digits = re.findall(r"\D+", text)
print(f"匹配非数字 '\\D+': {non_digits}")

输出示例：

匹配数字 '\d+': ['123', '45', '6']
匹配非数字 '\D+': ['Item A: ', ', Item B: ', '.', ', Item C']

3.5.2. \s, \S：空白字符与非空白字符

• \s：
  • “是什么”：匹配任意空白字符，包括空格 、制表符 \t、换行符 \n、回车符 \r、换页符 \f 等。
  • “为什么”：方便地匹配各种形式的空白区域，而无需列出所有可能的空白字符。
  • “怎么做”：直接在模式中使用 \s。
• \S：
  • “是什么”：匹配任意非空白字符。
  • “为什么”：常用于匹配单词或连续的非空白内容，例如提取文本中的词汇或标点符号。
  • “怎么做”：直接在模式中使用 \S。

import re

text = "Hello\tWorld\nPython is fun. "

# 匹配一个或多个空白字符
spaces = re.findall(r"\s+", text)
print(f"匹配空白字符 '\\s+': {spaces}")

# 匹配一个或多个非空白字符 (通常用于提取单词)
words = re.findall(r"\S+", text)
print(f"匹配非空白字符 '\\S+': {words}")

输出示例：

匹配空白字符 '\s+': ['\t', '\n', ' ', ' ']
匹配非空白字符 '\S+': ['Hello', 'World', 'Python', 'is', 'fun.']

3.5.3. \w, \W：单词字符与非单词字符

• \w：
  • “是什么”：匹配任意单词字符，包括字母（a-z, A-Z）、数字（0-9）和下划线 _。等同于字符集 [a-zA-Z0-9_]。
  • “为什么”：这是匹配构成“词”的基本字符的最常用方式，非常适合提取标识符、变量名或普通文本中的单词。
  • “怎么做”：直接在模式中使用 \w。
• \W：
  • “是什么”：匹配任意非单词字符。等同于反向字符集 [^a-zA-Z0-9_]。
  • “为什么”：方便地匹配标点符号或特殊符号，用于从文本中去除这些非单词字符或作为分隔符。
  • “怎么做”：直接在模式中使用 \W。

import re

text = "User_Name123! Pass@word-test."

# 匹配一个或多个单词字符
word_chars = re.findall(r"\w+", text)
print(f"匹配单词字符 '\\w+': {word_chars}")

# 匹配一个或多个非单词字符
non_word_chars = re.findall(r"\W+", text)
print(f"匹配非单词字符 '\\W+': {non_word_chars}")

输出示例：

匹配单词字符 '\w+': ['User_Name123', 'Pass', 'word', 'test']
匹配非单词字符 '\W+': ['! ', '@', '-.']

3.5.4. \b, \B：单词边界与非单词边界

• \b：

  • “是什么”：匹配单词边界。单词边界是一个不消耗字符的零宽断言（zero-width assertion），它表示一个位置，该位置的一侧是单词字符 \w，另一侧是非单词字符 \W（或字符串的开头/结尾）。简而言之，它标记了一个“独立单词”的开始或结束位置。
  • “为什么”：当您需要匹配一个完整的单词，而不是作为另一个词的一部分时，\b 至关重要。例如，搜索“cat”时，希望匹配独立的“cat”，而不是“category”或“scatter”中的“cat”。
  • “怎么做”：将 \b 放在模式中需要边界的位置。

• \B：

  • “是什么”：匹配非单词边界。同样是一个零宽断言，它表示一个位置，该位置两侧都是单词字符 \w，或者两侧都是非单词字符 \W。
  • “为什么”：当您需要匹配单词内部的某个模式，或者非单词字符内部的模式时。
  • “怎么做”：将 \B 放在模式中需要非边界的位置。

import re

text = "cat, category, scatter, Cats and dogs. The concatenation."

# 匹配独立的单词 'cat' (忽略大小写)
matches_boundary = re.findall(r"\bcat\b", text, re.IGNORECASE)
print(f"匹配单词边界 '\\bcat\\b': {matches_boundary}")

# 匹配以 'cat' 开头但不是独立单词的词 (例如 'category')
matches_start_cat = re.findall(r"\bcat\B", text, re.IGNORECASE)
print(f"匹配以 'cat' 开头但不是独立单词的词 '\\bcat\\B': {matches_start_cat}")
# 说明: 从 'category' 中匹配 'cat'，从 'concatenation' 中匹配 'cat'

# 匹配以 'cat' 结尾但不是独立单词的词 (例如 'scatter')
matches_end_cat = re.findall(r"\Bcat\b", text, re.IGNORECASE)
print(f"匹配以 'cat' 结尾但不是独立单词的词 '\\Bcat\\b': {matches_end_cat}")
# 说明: 从 'scatter' 中匹配 'cat'

# 匹配单词内部的 'at'
matches_inner_at = re.findall(r"\Bat\B", "batman, water, cat")
print(f"匹配单词内部的 'at' ('\\Bat\\B'): {matches_inner_at}")
# 说明: 'batman' 中的 'at' 两侧都是单词字符，所以匹配。 'water' 和 'cat' 中的 'at' 有单词边界，所以不匹配。

输出示例：

匹配单词边界 '\bcat\b': ['cat', 'Cats']
匹配以 'cat' 开头但不是独立单词的词 '\bcat\B': ['cat', 'cat']
匹配以 'cat' 结尾但不是独立单词的词 '\Bcat\b': ['cat']
匹配单词内部的 'at' ('\Bat\B'): ['at']

---

4. 进阶模式构建技巧

在掌握了核心语法之后，我们将探讨一些更高级的模式构建技巧，它们能够让您的正则表达式更加精确、灵活和高效。

4.1. 贪婪与非贪婪模式 (*?, +?, ??, {m,n}?)

默认情况下，正则表达式中的量词（*, +, ?, {m,n}）是贪婪的 (greedy)。这意味着它们会尽可能多地匹配字符，直到不再可能匹配为止。然而，在某些情况下，我们可能需要它们尽可能少地匹配，这就是非贪婪模式 (non-greedy)，也称为懒惰模式 (lazy)。

• “是什么”：
  • 贪婪模式：量词在匹配时会尽可能地扩展，尝试匹配最长的可能字符串。
  • 非贪婪模式：通过在贪婪量词（*, +, ?, {m,n}）后面紧跟一个问号 ? 来启用。它会尽可能少地匹配字符，尝试找到最短的可能字符串来满足整个模式。
  • 对应的非贪婪量词为：*? (零次或多次，非贪婪)、+? (一次或多次，非贪婪)、?? (零次或一次，非贪婪)、{m,n}? (m到n次，非贪婪)。
• “为什么”：
  • 贪婪模式的问题：假设您想从 HTML 字符串 <b>Title 1</b> <p>Paragraph</p> <b>Title 2</b> 中提取所有 <b>...</b> 标签的内容。如果使用贪婪模式 <b>.*</b>，它会从第一个 <b> 匹配到最后一个 </b>，吞噬中间的所有内容（包括 <p>Paragraph</p> 和第二个 <b> ），这通常不是我们期望的结果。
  • 非贪婪模式的解决：非贪婪模式正是为了解决这种“过度匹配”的问题，它会尽可能少地匹配字符，直到找到满足模式的最短匹配。
• “怎么做”：在任何贪婪量词（*, +, ?, {m,n}）后面直接添加一个 ?。

import re

text_html = "<b>Title 1</b> <p>Paragraph</p> <b>Title 2</b>"

# 1. 贪婪模式示例
# 匹配从第一个 <b> 到最后一个 </b>，中间所有字符都被 .* 吞噬
greedy_pattern = r"<b>.*</b>"
greedy_match = re.findall(greedy_pattern, text_html)
print(f"贪婪模式 (r'<b>.*</b>'): {greedy_match}")
# 输出: ['<b>Title 1</b> <p>Paragraph</p> <b>Title 2</b>']
# 说明：.* 会尽可能多地匹配，直到遇到字符串末尾或最后一个能使整个模式匹配成功的 </b>。

# 2. 非贪婪模式示例
# 匹配最短的 <b>...</b> 对
non_greedy_pattern = r"<b>.*?</b>"
non_greedy_match = re.findall(non_greedy_pattern, text_html)
print(f"非贪婪模式 (r'<b>.*?</b>'): {non_greedy_match}")
# 输出: ['<b>Title 1</b>', '<b>Title 2</b>']
# 说明：.*? 会尽可能少地匹配，一旦遇到第一个 </b> 就能使模式匹配成功，它就停止。

# 3. 结合其他非贪婪量词
text_quantifiers = "aaaaa bbb ccc"
match_a_greedy = re.search(r"a+", text_quantifiers)
print(f"\n贪婪模式 'a+': {match_a_greedy.group()}") # 输出: aaaaa

match_a_nongreedy = re.search(r"a+?", text_quantifiers)
print(f"非贪婪模式 'a+?': {match_a_nongreedy.group()}") # 输出: a
# 说明: a+? 尽可能少地匹配，但至少一次。所以只匹配一个 'a'。

match_b_greedy = re.search(r"b{1,3}", text_quantifiers)
print(f"贪婪模式 'b{{1,3}}': {match_b_greedy.group()}") # 输出: bbb

match_b_nongreedy = re.search(r"b{1,3}?", text_quantifiers)
print(f"非贪婪模式 'b{{1,3}}?': {match_b_nongreedy.group()}") # 输出: b
# 说明: b{1,3}? 尽可能少地匹配，但至少一次。所以只匹配一个 'b'。

输出示例：

贪婪模式 (r'<b>.*</b>'): ['<b>Title 1</b> <p>Paragraph</p> <b>Title 2</b>']
非贪婪模式 (r'<b>.*?</b>'): ['<b>Title 1</b>', '<b>Title 2</b>']

贪婪模式 'a+': aaaaa
非贪婪模式 'a+?': a
贪婪模式 'b{1,3}': bbb
非贪婪模式 'b{1,3}?': b

重要提示：在处理像 HTML/XML 这样的结构化文本时，尽管正则表达式在很多简单场景下能够奏效，但对于复杂或嵌套结构，使用专门的解析器（如 Python 的 Beautiful Soup 或 lxml 库）通常是更健壮和推荐的做法。正则表达式的非贪婪模式可以处理一些简单的标签匹配，但无法完全处理所有可能的情况。

4.2. 非捕获组 (?:...)

• “是什么”：非捕获组 (?:...) 允许您将多个模式组合成一个逻辑单元（分组），但不捕获其匹配的内容。这意味着它不会为该组分配一个数字索引，也不会在 Match 对象的 groups() 或 findall() 返回结果中包含其内容。
• “为什么”：
  • 应用量词或“或”操作：当您需要将一组模式作为一个整体应用量词（如 (?:ab)+）或“或”操作（如 (?:cat|dog)food），但又不需要提取这部分内容时，使用非捕获组可以避免创建不必要的捕获组，从而稍微提高性能并简化 groups() 或 findall() 的返回结果。
  • 减少 Match 对象的复杂性：如果您的模式中有很多分组只是为了结构化正则表达式逻辑，而不是为了提取数据，非捕获组可以使 Match 对象更简洁，只包含您真正关心的数据。
• “怎么做”：将要分组但不需要捕获的模式放在 (?:...) 中。

import re

text = "apple pie, banana bread, cherry tart"

# 1. 捕获组示例 (默认行为)
# 匹配水果，并捕获水果名和烘焙食品名
pattern_capturing = r"(\w+)\s(pie|bread|tart)"
matches_capturing = re.findall(pattern_capturing, text)
print(f"捕获组模式 (r'(\\w+)\\s(pie|bread|tart)'): {matches_capturing}")
# 输出: [('apple', 'pie'), ('banana', 'bread'), ('cherry', 'tart')]
# 说明: findall 返回一个元组列表，每个元组包含两个捕获组的内容。

# 2. 非捕获组示例
# 匹配水果名，但只捕获水果名，烘焙食品作为分组只用于逻辑判断
pattern_non_capturing = r"(\w+)\s(?:pie|bread|tart)"
matches_non_capturing = re.findall(pattern_non_capturing, text)
print(f"非捕获组模式 (r'(\\w+)\\s(?:pie|bread|tart)'): {matches_non_capturing}")
# 输出: ['apple', 'banana', 'cherry']
# 说明: findall 只返回了第一个捕获组的内容，因为 (?:pie|bread|tart) 是非捕获组。

# 3. 对非捕获组应用量词
text_repeat = "go go go stop"
# 匹配重复的 "go "
pattern_repeat_non_capturing = r"(?:go\s)+"
match_repeat = re.search(pattern_repeat_non_capturing, text_repeat)
print(f"\n对非捕获组应用量词 (r'(?:go\\s)+'): {match_repeat.group() if match_repeat else '无匹配'}")

输出示例：

捕获组模式 (r'(\w+)\s(pie|bread|tart)'): [('apple', 'pie'), ('banana', 'bread'), ('cherry', 'tart')]
非捕获组模式 (r'(\w+)\s(?:pie|bread|tart)'): ['apple', 'banana', 'cherry']

对非捕获组应用量词 (r'(?:go\s)+'): go go go 

4.3. 反向引用 \n 或 \g<n> (Backreferences)

• “是什么”：反向引用允许您在正则表达式的同一模式中引用之前已经匹配并捕获的子字符串。它不是匹配当前字符串中的一个新部分，而是匹配之前捕获组匹配到的完全相同的内容。
  • \n：其中 n 是一个数字，代表第 n 个捕获组（从左到右，从 1 开始计数）。
  • \g<n> 或 \g<name>：\g<n> 与 \n 功能相同。\g<name> 用于引用命名捕获组（详见 6.3 保持可读性）。
• “为什么”：
  • 查找重复模式：例如，查找文本中连续重复的单词（“cat cat”）。
  • 校验对称结构：例如，匹配 HTML 标签的开闭对（<h1>...</h1>）。
  • 文本替换：在 re.sub() 函数中使用反向引用，可以在替换字符串 repl 中引用捕获组的内容，实现复杂的文本转换。
• “怎么做”：在模式中使用 \n 或 \g<n> 引用第 n 个捕获组。

import re

text_duplicates = "This is a test test string with duplicated words words."
text_tags = "Here is <b>bold text</b> and <i>italic text</i>."

# 1. 查找连续重复的单词
# (\b\w+\b) 捕获一个独立的单词
# \s+ 匹配一个或多个空格
# \1 引用第一个捕获组 (\b\w+\b) 匹配到的内容
pattern_duplicate_words = r"(\b\w+\b)\s+\1" 
matches_duplicates = re.findall(pattern_duplicate_words, text_duplicates, re.IGNORECASE)
print(f"查找重复单词 (r'(\\b\\w+\\b)\\s+\\1'): {matches_duplicates}")
# 输出: ['test', 'words'] (findall 返回捕获组的内容)

# 使用 re.finditer 查看完整匹配
print("\n使用 re.finditer 查找重复单词:")
for match_obj in re.finditer(pattern_duplicate_words, text_duplicates, re.IGNORECASE):
    print(f"  完整匹配: '{match_obj.group(0)}', 重复单词: '{match_obj.group(1)}'")
# 输出:
#   完整匹配: 'test test', 重复单词: 'test'
#   完整匹配: 'words words', 重复单词: 'words'

# 2. 清理重复的单词 (使用 re.sub 和反向引用)
# 替换为只保留一个单词 (即第一个捕获组的内容)
cleaned_text = re.sub(pattern_duplicate_words, r"\1", text_duplicates, flags=re.IGNORECASE)
print(f"\n清理重复单词: {cleaned_text}")
# 输出: This is a test string with duplicated words.

# 3. 匹配成对的 HTML 标签
# (<([a-z]+)>) 捕获整个开标签，同时 ([a-z]+) 捕获标签名
# .*? 非贪婪匹配标签内容
# </\2> 引用第二个捕获组 (标签名)，确保闭标签与开标签匹配
pattern_html_tags = r"<([a-z]+)>(.*?)</\1>" 
matches_tags = re.findall(pattern_html_tags, text_tags)
print(f"\n匹配成对的 HTML 标签 (r'<([a-z]+)>(.*?)</\\1>'): {matches_tags}")
# 输出: [('b', 'bold text'), ('i', 'italic text')]
# 说明：这里捕获组 1 是标签名（如 'b'），捕获组 2 是标签内容（如 'bold text'）。

输出示例：

查找重复单词 (r'(\b\w+\b)\s+\1'): ['test', 'words']

使用 re.finditer 查找重复单词:
  完整匹配: 'test test', 重复单词: 'test'
  完整匹配: 'words words', 重复单词: 'words'

清理重复单词: This is a test string with duplicated words.

匹配成对的 HTML 标签 (r'<([a-z]+)>(.*?)</\1>'): [('b', 'bold text'), ('i', 'italic text')]

4.4. 正则表达式标志 (Flags)

正则表达式标志（或模式修饰符）允许您修改正则表达式的匹配行为，例如使其忽略大小写、支持多行匹配等。这些标志通常作为 re 模块函数的 flags 参数传入。

• “是什么”：一组预定义的常量，用于调整正则表达式引擎的匹配规则。
• “为什么”：通过改变默认匹配行为，使正则表达式更加灵活和强大，避免编写冗长或复杂的模式。
• “怎么做”：在 re 模块函数的 flags 参数中传入一个或多个标志。多个标志可以使用 | 运算符进行组合。

4.4.1. re.IGNORECASE (或 re.I)：忽略大小写

• “是什么”：使模式匹配时忽略字母的大小写。
• “为什么”：当您需要匹配的文本可能存在大小写变体（例如 “Python”, “python”, “PYTHON”）时，此标志非常有用，避免为每种大小写组合编写多个模式。
• “怎么做”：re.search(pattern, string, re.IGNORECASE) 或 re.search(pattern, string, re.I)。

import re

text = "Python is a versatile language. python is widely used."

# 默认情况下，区分大小写
match_default = re.findall(r"python", text)
print(f"默认匹配 'python': {match_default}") # 输出: ['python']

# 忽略大小写匹配
match_ignorecase = re.findall(r"python", text, re.IGNORECASE)
print(f"忽略大小写匹配 'python' (re.IGNORECASE): {match_ignorecase}") # 输出: ['Python', 'python']

输出示例：

默认匹配 'python': ['python']
忽略大小写匹配 'python' (re.IGNORECASE): ['Python', 'python']

4.4.2. re.MULTILINE (或 re.M)：多行模式

• “是什么”：改变 ^ 和 $ 元字符的含义。在多行模式下：
  • ^ 不仅匹配字符串的开头，还匹配每一行（即 \n 之后）的开头。
  • $ 不仅匹配字符串的结尾，还匹配每一行（即 \n 之前）的结尾。
• “为什么”：当您需要按行处理文本，并在每行的开头或结尾进行匹配时，此标志非常有用。例如，从多行日志中提取以特定前缀开头的行。
• “怎么做”：re.findall(pattern, string, re.MULTILINE) 或 re.findall(pattern, string, re.M)。

import re

text_multiline = "Line 1: Apple\nLine 2: Banana\nLine 3: Cherry"

# 默认模式下，^ 和 $ 只匹配字符串的开始和结束
match_default_start = re.findall(r"^Line \d", text_multiline)
print(f"默认模式下匹配 '^Line \\d': {match_default_start}") # 输出: ['Line 1']

match_default_end = re.findall(r"Cherry$", text_multiline)
print(f"默认模式下匹配 'Cherry$': {match_default_end}") # 输出: [] (因为字符串结尾是换行符，Cherry后还有换行符)

# 多行模式下，^ 和 $ 匹配每行的开始和结束
match_multiline_start = re.findall(r"^Line \d", text_multiline, re.MULTILINE)
print(f"多行模式下匹配 '^Line \\d' (re.MULTILINE): {match_multiline_start}") # 输出: ['Line 1', 'Line 2', 'Line 3']

match_multiline_end = re.findall(r"Cherry$", text_multiline, re.MULTILINE)
print(f"多行模式下匹配 'Cherry$' (re.MULTILINE): {match_multiline_end}") # 输出: ['Cherry']

输出示例：

默认模式下匹配 '^Line \d': ['Line 1']
默认模式下匹配 'Cherry$': []
多行模式下匹配 '^Line \d' (re.MULTILINE): ['Line 1', 'Line 2', 'Line 3']
多行模式下匹配 'Cherry$' (re.MULTILINE): ['Cherry']

4.4.3. re.DOTALL (或 re.S)：点号匹配换行符

• “是什么”：改变 . (点号) 元字符的含义。在 re.DOTALL 模式下，点号 不仅匹配除换行符以外的任意单个字符，也匹配换行符 \n。
• “为什么”：当您需要匹配包含换行符在内的任意字符序列时，此标志非常有用。例如，提取跨多行的 XML 或 HTML 标签内容。
• “怎么做”：re.search(pattern, string, re.DOTALL) 或 re.search(pattern, string, re.S)。

import re

text_dotall = "Line one\nLine two\nLine three."

# 默认模式下，. 不匹配换行符
match_default_dot = re.search(r"Line.*Line", text_dotall)
print(f"默认模式下匹配 'Line.*Line': {match_default_dot.group() if match_default_dot else '无匹配'}") # 输出: 无匹配

# DOTALL 模式下，. 匹配换行符
match_dotall = re.search(r"Line.*Line", text_dotall, re.DOTALL)
print(f"DOTALL 模式下匹配 'Line.*Line' (re.DOTALL): {match_dotall.group() if match_dotall else '无匹配'}")
# 输出: Line one\nLine two\nLine three

输出示例：

默认模式下匹配 'Line.*Line': 无匹配
DOTALL 模式下匹配 'Line.*Line' (re.DOTALL): Line one
Line two

4.4.4. 组合使用标志

• “是什么”：Python 允许您通过位或运算符 | 组合多个正则表达式标志，以实现更复杂的匹配行为。
• “为什么”：某些场景可能需要同时启用多个匹配规则，例如既要忽略大小写又要支持多行匹配。
• “怎么做”：re.function(pattern, string, re.FLAG1 | re.FLAG2 | ...)。

import re

text_combined = "Hello World\nhello python\nWORLD CUP"

# 组合使用 re.IGNORECASE 和 re.MULTILINE
# 目标: 匹配以 "hello" 开头 (忽略大小写) 的行
pattern_combined = r"^hello\s\w+"
matches_combined = re.findall(pattern_combined, text_combined, re.IGNORECASE | re.MULTILINE)
print(f"组合标志匹配 '^hello\\s\\w+' (re.I | re.M): {matches_combined}")

输出示例：

组合标志匹配 '^hello\s\w+' (re.I | re.M): ['Hello World', 'hello python']

5. 综合实践：模式写作案例

本节将通过几个实际案例，展示如何运用前面学到的正则表达式语法和技巧来构建模式，解决常见的文本匹配和提取问题。

5.1. 提取 IP 地址

• “目标”：从日志文本中提取有效的 IPv4 地址。
• “思考”：一个 IPv4 地址由四个数字段组成，每个数字段在 0-255 之间，由 . 分隔。每个数字段可以是 1 到 3 位数字。
  • \d{1,3} 可以匹配 1 到 3 位数字。
  • \. 匹配字面量的点。
  • 重复四次 \d{1,3}，用 \. 连接。
• “模式”：\b(?:\d{1,3}\.){3}\d{1,3}\b
  • \b：确保匹配的是独立的 IP 地址，而不是数字串的一部分。
  • (?:...)：非捕获组，将 \d{1,3}\. 作为一个单元。
  • {3}：重复三次 \d{1,3}\.。
  • \d{1,3}：最后一个数字段。

import re

log_data = "User logged in from 192.168.1.100 at 2023-10-27. Another connection from 10.0.0.5. Invalid IP: 999.999.999.999."

# 提取 IP 地址
# 注意：此模式可以匹配 0-999 的数字，如 999.999.999.999，
# 如果需要严格校验 0-255 范围，正则表达式会非常复杂，通常结合编程语言的逻辑判断更优。
ip_pattern = r"\b(?:\d{1,3}\.){3}\d{1,3}\b"
ips = re.findall(ip_pattern, log_data)
print(f"提取的 IP 地址: {ips}")
# 严格的 0-255 IP 匹配正则表达式会非常冗长复杂，如下所示（仅作了解）：
# r"\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b"
# 在实际应用中，通常会用较宽松的正则提取，再用代码进行范围校验。

输出示例：

提取的 IP 地址: ['192.168.1.100', '10.0.0.5', '999.999.999.999']

说明：如上述代码注释所言，纯正则表达式实现严格的 IP 范围校验会非常复杂。对于 999.999.999.999 这种形式，如果正则表达式仅检查数字位数，它就会被匹配。更可靠的方法是先用这种较宽松的正则提取，然后用 Python 代码逐段检查数值是否在 0-255 之间。

5.2. 验证电话号码

• “目标”：验证一个字符串是否是符合特定格式的中国手机号码（11位数字，以1开头，第二位是3-9，后面9位任意数字）。
• “思考”：
  • 电话号码必须是 11 位数字。
  • 第一位是 1。
  • 第二位是 [3-9]。
  • 后九位是 \d。
  • ^ 和 $ 确保整个字符串都是电话号码。
• “模式”：^1[3-9]\d{9}$

import re

phone_numbers = [
    "13812345678", # 有效
    "19987654321", # 有效
    "20012345678", # 无效 (开头不是1)
    "1381234567",  # 无效 (10位)
    "138123456789", # 无效 (12位)
    "138-1234-5678", # 无效 (包含非数字字符)
    "12345678901", # 无效 (第二位不是3-9)
]

# 验证中国手机号码（简化版）
phone_pattern = r"^1[3-9]\d{9}$"

print("验证电话号码:")
for number in phone_numbers:
    if re.fullmatch(phone_pattern, number):
        print(f"  '{number}': 有效")
    else:
        print(f"  '{number}': 无效")

输出示例：

验证电话号码:
  '13812345678': 有效
  '19987654321': 有效
  '20012345678': 无效
  '1381234567': 无效
  '138123456789': 无效
  '138-1234-5678': 无效
  '12345678901': 无效

5.3. 清理重复的单词

• “目标”：从文本中移除连续重复的单词，例如将 “is is” 变为 “is”。
• “思考”：这需要使用反向引用。我们需要捕获一个单词，然后匹配其后的一个或多个空格，紧接着匹配与第一个单词完全相同的内容。
• “模式”：(\b\w+)(\s+\1\b)+
  • (\b\w+)：捕获第一个独立的单词（捕获组 1）。
  • (\s+\1\b)+：匹配一个或多个空格 (\s+)，后跟与捕获组 1 完全相同的单词 (\1)，且这个重复单词也需要是一个独立的词 (\b)。这个整个重复的模式可以出现一次或多次 (+)。
• “替换”：\1 (将所有重复的单词替换为第一个捕获组的内容，即只保留一个单词)。

import re

text_with_dups = "This is is a test test string with with duplicated words words. And a cat cat."

# 匹配并替换连续重复的单词
# pattern: ((\b\w+)\s+\2\b)+ 是匹配 'is is' 或 'test test'
# (\b\w+) 捕获组1: 匹配第一个单词 (如 "is")
# (\s+\1\b)+ 匹配一个或多个空格，后面跟着相同的单词 (\1 引用捕获组1)，这个重复的序列可以出现一次或多次
# r"\1" 表示替换为捕获组1的内容，即只保留一个单词
cleaned_text = re.sub(r"(\b\w+)(\s+\1\b)+", r"\1", text_with_dups, flags=re.IGNORECASE)
print(f"清理重复单词后的文本: {cleaned_text}")

输出示例：

清理重复单词后的文本: This is a test string with duplicated words. And a cat.

注意：这个模式 (\b\w+)(\s+\1\b)+ 巧妙地利用了嵌套捕获组和反向引用。外层 (\s+\1\b)+ 确保匹配到的是一个或多个重复序列，re.sub 会将整个匹配到的重复部分（例如 “is is”）替换为 \1（即第一个 “is”）。

5.4. 提取邮件地址与用户名

• “目标”：从文本中提取电子邮件地址，并进一步从中分离出用户名和域名。
• “思考”：电子邮件地址通常格式为 username@domain.tld。
  • 用户名：通常由字母、数字、下划线、点、破折号组成。
  • @：分隔符。
  • 域名：由多个以 . 分隔的单词组成。
  • 顶级域名 (TLD)：通常是 2-6 个字母。
• “模式”：\b([a-zA-Z0-9._%+-]+)@([a-zA-Z0-9.-]+)\.([a-zA-Z]{2,6})\b
  • \b：确保匹配的是独立的电子邮件地址。
  • ([a-zA-Z0-9._%+-]+)：第一个捕获组，匹配用户名。
    • [a-zA-Z0-9._%+-]：允许的用户名字符。
    • +：一个或多个。
  • @：字面量的 @ 符号。
  • ([a-zA-Z0-9.-]+)：第二个捕获组，匹配域名部分（不含顶级域名）。
    • [a-zA-Z0-9.-]：允许的域名字符。
  • \.：字面量的点号。
  • ([a-zA-Z]{2,6})：第三个捕获组，匹配顶级域名（2到6个字母）。
  • \b：结束单词边界。

import re

text_emails = "Contact us at support@example.com or info@my-company.org. My personal email is user.name@mail.co.uk. Invalid: test@.com"

email_pattern = r"\b([a-zA-Z0-9._%+-]+)@([a-zA-Z0-9.-]+)\.([a-zA-Z]{2,6})\b"

emails = re.findall(email_pattern, text_emails)
print("提取的邮件地址信息:")
for email_tuple in emails:
    username, domain, tld = email_tuple
    full_email = f"{username}@{domain}.{tld}"
    print(f"  完整邮件: {full_email}, 用户名: {username}, 域名: {domain}.{tld}")

输出示例：

提取的邮件地址信息:
  完整邮件: support@example.com, 用户名: support, 域名: example.com
  完整邮件: info@my-company.org, 用户名: info, 域名: my-company.org
  完整邮件: user.name@mail.co.uk, 用户名: user.name, 域名: mail.co.uk

注意：电子邮件地址的合法性规则非常复杂（RFC 5322），上述正则表达式是针对常见格式的简化。对于严格的邮件地址验证，通常会使用专门的库或更复杂的验证逻辑。

5.5. 从 HTML/XML 中提取标签内容

• “目标”：从 HTML 文本中提取特定标签（例如 <h1>）及其内容。
• “思考”：
  • 匹配开标签：<tag>
  • 匹配内容：中间可以是任意字符，包括换行符，且需要是非贪婪的。
  • 匹配闭标签：</tag>
  • 需要确保开标签和闭标签的名称一致（反向引用）。
• “模式”：<(h[1-6]|p)>(.*?)</\1>
  • < 和 >：字面量尖括号。
  • (h[1-6]|p)：第一个捕获组，匹配标签名，这里我们限定为 h1 到 h6 或 p 标签。
  • (.*?)：第二个捕获组，非贪婪地匹配标签内的所有内容（包括换行符）。注意，需要 re.DOTALL 标志才能匹配换行符。
  • </\1>：匹配闭标签，\1 反向引用第一个捕获组的标签名。

import re

html_content = """
<h1>Chapter Title</h1>
<p>This is a paragraph with some <b>bold text</b>.</p>
<h2>Section Heading</h2>
<p>Another paragraph.</p>
<title>Document Title</title>
"""

# 提取 h1 或 p 标签的内容 (不包含标签本身)
# 使用 re.DOTALL 使得 . 可以匹配换行符
html_tag_pattern = r"<(h[1-6]|p)>(.*?)</\1>"
matches_html = re.findall(html_tag_pattern, html_content, re.DOTALL)

print("提取的 HTML 标签内容:")
for tag_name, content in matches_html:
    print(f"  标签名: <{tag_name}>, 内容: '{content.strip()}'")
# .strip() 用于去除内容前后可能的空白字符，包括换行。

输出示例：

提取的 HTML 标签内容:
  标签名: <h1>, 内容: 'Chapter Title'
  标签名: <p>, 内容: 'This is a paragraph with some <b>bold text</b>.'
  标签名: <h2>, 内容: 'Section Heading'
  标签名: <p>, 内容: 'Another paragraph.'

重要提示：正如 4.1 贪婪与非贪婪模式 中提及的，正则表达式处理 HTML/XML 这样的嵌套结构存在局限性。虽然上述模式可以处理简单的成对标签提取，但对于更复杂的嵌套（例如 <div><div>...</div></div>），或者当标签属性中包含 > 等特殊字符时，正则表达式可能无法正确解析。在这种情况下，强烈建议使用专门的 HTML/XML 解析库，如 Python 的 BeautifulSoup 或 lxml，它们提供了更健壮和语义化的解析能力。

6. 正则表达式写作最佳实践与调试

编写高效、准确且易于维护的正则表达式是一门艺术。本节将提供一些最佳实践建议，并介绍调试技巧，帮助您提升正则表达式的质量。

6.1. 逐步构建与测试

• “是什么”：不要试图一次性写出一个复杂的正则表达式。应该从匹配最核心、最简单的部分开始，逐步添加更复杂的元素，并在每一步都进行测试。
• “为什么”：
  • 降低复杂性：将大问题分解为小问题，易于理解和管理。
  • 快速定位错误：如果某一步出现问题，您可以立即知道是新添加的部分导致了错误。
  • 提升效率：通过迭代式开发，减少调试时间。
• “怎么做”：
  1. 从字面量开始：先匹配文本中固定不变的部分。
  2. 引入基本元字符和字符集：逐渐用 . \d \s [] 等替换模糊或可变的部分。
  3. 添加量词：定义字符或组的重复次数。
  4. 使用分组和非捕获组：构建更复杂的逻辑单元，并确定需要捕获的数据。
  5. 加入边界和断言：精确定义匹配的上下文。
  6. 引入标志：调整整体匹配行为。
  7. 反复测试：使用典型匹配文本和非匹配文本进行测试，确保模式既能捕获所有预期目标，又能排除所有非目标。

import re

text = "My phone number is 138-1234-5678. Another is (010)8765-4321."

# 目标：提取中国电话号码，支持带区号或不带区号，且可能有分隔符或无分隔符。
# 逐步构建过程：

# Step 1: 匹配核心数字部分
# pattern1 = r"\d{11}" # 只能匹配纯数字11位
# print(f"Step 1: {re.findall(pattern1, text)}") # ['13812345678', '01087654321'] - 不够灵活

# Step 2: 考虑分隔符 - 简单地匹配数字和横线
# pattern2 = r"\d[\d-]*\d" # 过于宽松，会匹配 '138-123-456-78'
# print(f"Step 2: {re.findall(pattern2, text)}")

# Step 3: 考虑带区号的格式 (010)8765-4321 和不带区号 138-1234-5678
# 匹配区号部分 (可选)
area_code_part = r"(?:\(\d{3}\)|\d{3}-)?" # 匹配 (XXX) 或 XXX- (非捕获组，可选)

# 匹配主体号码部分
main_number_part = r"\d{3,4}-?\d{4}" # XXX-XXXX 或 XXXX-XXXX

# Step 4: 组合并精确化
# 完整模式：^ 和 $ 确保整个字符串都是电话号码
phone_pattern_final = r"^(?:(?:\(\d{3}\)|\d{3}-)\s*)?\d{3,4}-?\d{4}$"

test_numbers = [
    "138-1234-5678",
    "13812345678",
    "(010)8765-4321",
    "010-8765-4321",
    "8765-4321", # 8位号码
    "123", # 无效
]

print("\n逐步构建与测试后的电话号码验证:")
for num in test_numbers:
    if re.fullmatch(phone_pattern_final, num):
        print(f"  '{num}': 有效")
    else:
        print(f"  '{num}': 无效")

输出示例：

逐步构建与测试后的电话号码验证:
  '138-1234-5678': 有效
  '13812345678': 无效 (因为 pattern_final 要求至少3位数字前没有分隔符，这里是11位数字，不是3-4-4模式)
  '(010)8765-4321': 有效
  '010-8765-4321': 有效
  '8765-4321': 有效
  '123': 无效

修正说明：上述 phone_pattern_final 模式的测试结果显示 “13812345678” 为无效，这说明此模式只针对特定格式（如 XXX-XXXX-XXXX 或 (XXX)XXXX-XXXX）。一个更通用的中国手机号码验证模式（不包含座机格式），则可能更接近 ^1[3-9]\d{9}$，这说明在构建模式时，明确需求至关重要。

6.2. 利用在线工具进行可视化与测试

• “是什么”：有许多优秀的在线正则表达式工具，它们提供了模式可视化、实时匹配、解释器和备忘录功能。
• “为什么”：
  • 可视化：复杂的正则表达式很难一眼看出其逻辑。可视化工具能清晰地展示模式的结构和每个部分的含义。
  • 实时反馈：在您输入模式和测试文本时，工具会立即显示匹配结果，这对于快速调试非常有用。
  • 学习辅助：对于初学者，这些工具是理解和练习正则表达式的绝佳资源。
• “怎么做”：访问这些网站，粘贴您的正则表达式和测试文本，观察匹配结果和模式解释。
  • Regex101.com：功能强大，支持多种语言，有详细的解释面板。
  • RegExr.com：界面美观，提供实时匹配和常用模式参考。
  • Pythex.org：专注于 Python 正则表达式，提供 Python re 模块的行为模拟。

6.3. 保持可读性：使用命名捕获组与详细模式 re.VERBOSE (或 re.X)

• “是什么”：
  • 命名捕获组：通过 (?P<name>...) 语法，您可以为捕获组指定一个有意义的名称，而不是仅仅使用数字索引。
  • 详细模式 (Verbose Mode)：通过 re.VERBOSE 标志（或 re.X），您可以在正则表达式中添加空格和注释，使其更具可读性，而这些空格和注释将被引擎忽略。
• “为什么”：
  • 可读性：复杂的正则表达式往往难以理解。命名捕获组和详细模式能够显著提高模式的可读性和可维护性，特别是在团队协作或长期项目中。
  • 代码健壮性：当模式中的捕获组顺序发生变化时，如果使用数字索引，所有引用都需要修改。而命名捕获组则不受顺序影响。
• “怎么做”：
  • 命名捕获组：使用 (?P<name>pattern) 语法。通过 Match 对象的 group('name') 方法访问匹配内容。
  • 详细模式：将 re.VERBOSE 标志传递给 re 模块函数。在模式中，可以使用空格（除了被转义的或在字符集中的）和 # 后的注释。

import re

text_log = "User 'Alice' from IP 192.168.1.100 failed login at 2023-10-27 14:30:15."

# 1. 使用命名捕获组提取用户信息
# 模式：匹配用户名、IP地址和时间
log_pattern_named = r"User '(?P<username>\w+)' from IP (?P<ip>\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}) failed login at (?P<timestamp>\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})."

match_log = re.search(log_pattern_named, text_log)
if match_log:
    print(f"使用命名捕获组提取信息:")
    print(f"  用户名: {match_log.group('username')}")
    print(f"  IP 地址: {match_log.group('ip')}")
    print(f"  时间戳: {match_log.group('timestamp')}")
    # 也可以通过 .groupdict() 获取所有命名捕获组的字典
    print(f"  所有命名捕获组: {match_log.groupdict()}")

# 2. 使用详细模式 (re.VERBOSE) 提升可读性
# 相同的模式，通过添加注释和空格使其更易读
verbose_pattern = r"""
    User\s'                     # 匹配 "User '"
    (?P<username>\w+)           # 捕获用户名 (一个或多个单词字符)
    '\sfrom\sIP\s               # 匹配 "' from IP "
    (?P<ip>\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}) # 捕获 IP 地址
    \sfailed\slogin\sat\s       # 匹配 " failed login at "
    (?P<timestamp>\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}) # 捕获时间戳
    \.                          # 匹配句号
"""

match_verbose = re.search(verbose_pattern, text_log, re.VERBOSE)
if match_verbose:
    print(f"\n使用详细模式和命名捕获组提取信息 (re.VERBOSE):")
    print(f"  用户名: {match_verbose.group('username')}")
    print(f"  IP 地址: {match_verbose.group('ip')}")
    print(f"  时间戳: {match_verbose.group('timestamp')}")
    print(f"  所有命名捕获组: {match_verbose.groupdict()}")

输出示例：

使用命名捕获组提取信息:
  用户名: Alice
  IP 地址: 192.168.1.100
  时间戳: 2023-10-27 14:30:15
  所有命名捕获组: {'username': 'Alice', 'ip': '192.168.1.100', 'timestamp': '2023-10-27 14:30:15'}

使用详细模式和命名捕获组提取信息 (re.VERBOSE):
  用户名: Alice
  IP 地址: 192.168.1.100
  时间戳: 2023-10-27 14:30:15
  所有命名捕获组: {'username': 'Alice', 'ip': '192.168.1.100', 'timestamp': '2023-10-27 14:30:15'}

6.4. 性能考量：re.compile() 的使用

• “是什么”：re.compile(pattern, flags=0) 函数将正则表达式模式编译成一个正则表达式对象 (RegexObject)。
• “为什么”：
  • 性能优化：当一个正则表达式模式需要被多次使用时（例如，在循环中处理大量文本），每次调用 re 模块的函数（如 re.search, re.findall）都会导致 Python 重新编译该模式。通过 re.compile() 预编译模式，可以避免重复编译的开销，从而提高执行效率。
  • 代码结构化：将模式编译成对象，使得代码更清晰，可以将模式定义与实际的匹配操作分离。
• “怎么做”：在程序开始时编译模式，然后在需要匹配的地方使用编译后的正则表达式对象的方法。

import re
import time

text_data = ["apple pie", "banana bread", "cherry tart", "date cake"] * 10000

# 不使用 re.compile
start_time_uncompiled = time.time()
for text in text_data:
    re.search(r"(\w+)\s(pie|bread|tart|cake)", text)
end_time_uncompiled = time.time()
print(f"不使用 re.compile 耗时: {end_time_uncompiled - start_time_uncompiled:.4f} 秒")

# 使用 re.compile
compiled_pattern = re.compile(r"(\w+)\s(pie|bread|tart|cake)")
start_time_compiled = time.time()
for text in text_data:
    compiled_pattern.search(text)
end_time_compiled = time.time()
print(f"使用 re.compile 耗时: {end_time_compiled - start_time_compiled:.4f} 秒")

输出示例（具体时间会因系统和运行环境而异，但通常编译后的性能更优）：

不使用 re.compile 耗时: 0.1234 秒
使用 re.compile 耗时: 0.0876 秒

说明：虽然在单个或少量匹配操作中，re.compile() 的性能优势不明显甚至可能略有负荷（因为多了一步编译），但在大量重复匹配的场景下，其性能提升是显著的。对于需要在整个程序生命周期中重复使用的复杂模式，re.compile() 是一个值得采纳的最佳实践。

---

6.5. 避免“灾难性回溯” (Catastrophic Backtracking)

“灾难性回溯”是正则表达式中一个重要的性能陷阱，尤其是在处理大型文本或复杂模式时，它可能导致正则表达式引擎耗尽资源，甚至使应用程序崩溃。理解其原理并学会避免它至关重要。

6.5.1. 什么是灾难性回溯

• “是什么”：灾难性回溯是指正则表达式引擎在尝试匹配失败时，进行指数级或多项式级的回溯操作，导致匹配时间急剧增加。当模式中包含相互重叠的量词（如 * 或 +）作用于能够匹配相同字符的模式时，这种现象尤其容易发生。
• “为什么”：正则表达式引擎通常采用回溯算法。当一个量词（尤其是贪婪量词）匹配了尽可能多的字符后，如果后续的模式无法匹配成功，引擎会尝试“回溯”，即吐出之前匹配的字符，然后再次尝试匹配后续模式。如果模式中存在多个可以匹配相同字符的量词组合，并且这些组合可以以多种方式分解文本，引擎可能会尝试所有可能的组合，导致回溯路径呈指数级增长，从而消耗大量时间和计算资源。

6.5.2. 灾难性回溯的原因

灾难性回溯通常发生在以下情况：

1. 嵌套量词：一个量词作用于另一个量词，且内部和外部量词都可能匹配相似的字符。

   • 示例：^(a+)+$ 匹配 aaaaa
     • a+ 内部量词：匹配一个或多个 a。
     • (a+)+ 外部量词：匹配一个或多个 a+ 序列。
     • 对于 aaaaa，引擎可以将其解释为 (aaaaa)，也可以是 (a)(aaaa)， (aa)(aaa)， (aaa)(aa)， (aaaa)(a) 等多种组合，甚至更细致的拆分。当尝试匹配整个字符串并最终发现后面没有 $ 的内容时，它会不断回溯，尝试所有这些组合，最终发现都无法匹配成功。

2. 重叠的子表达式：模式中不同的部分可以匹配相同的文本。

   • 示例：.*c.* 匹配 abcbcd
     • .* 贪婪地匹配所有字符。当它匹配 abcbcd 后，后续的 c 无法匹配。
     • .* 回溯，吐出 d，现在匹配 abcbcd。后续的 c 可以匹配 c。
     • 第二个 .* 贪婪地匹配 bcd。
     • 然后发现结尾没有内容。回溯。
     • 这个过程在复杂模式和长字符串中会变得非常冗长。

3. 可选的重复元素：(...)? 与其他量词结合。

一个典型的灾难性回溯模式示例：匹配一个带引号的字符串，其中引号内的内容可以是任意字符（包括转义的引号）
^"([^"\\]*(\\.[^"\\]*)*)"$
这个模式尝试匹配一个由双引号包围的字符串，并且允许内部包含转义的字符。当遇到很长的、几乎没有引号但结尾不匹配的字符串时，([^"\\]*(\\.[^"\\]*)*) 这一部分会进行大量的回溯。

6.5.3. 如何避免灾难性回溯

避免灾难性回溯的关键在于减少正则表达式引擎在匹配失败时可能尝试的路径数量。

6.5.3.1. 使用精确量词

尽可能使用精确的量词或范围量词，而不是过度宽松的 * 或 +。

• 错误示例：.*@.*\.com （匹配邮箱，但 .* 太贪婪和模糊）
• 优化示例：\w+@\w+\.\w+ （使用 \w+ 替代 .*，更具体地匹配单词字符）
  • 或者更精确：[^@\s]+@[^@\s]+\.[a-zA-Z]{2,}

6.5.3.2. 减少模糊匹配

避免使用可以匹配几乎任何字符的模糊模式，尤其是当它们被量词修饰并与其他模式重叠时。
比如用 [^"]* 来代替 .* 匹配引号内的内容，这样可以确保 * 不会匹配到引号，减少回溯。

• 错误示例：^(.+)+$ （匹配整个字符串，但 (.+)+ 会导致灾难性回溯）
• 优化示例：^.+$ （如果只是匹配整个字符串，直接使用 .+ 即可）
• 优化示例：^[^>]+> （如果你要匹配直到下一个 > 的内容，用 [^>]+ 比 .+? 更安全，因为 .+? 仍然需要回溯来确认 > 是否存在）。

6.5.3.3. 使用原子组 (?>...) (仅部分引擎支持，Python不支持) 或占有量词 *+ (仅部分引擎支持)

某些正则表达式引擎（如 Perl, PCRE, Java）支持“原子组”或“占有量词”，它们可以阻止回溯。

• 原子组 (?>...)：一旦原子组内的模式匹配成功，引擎就不会在原子组内部进行回溯。如果原子组后的模式匹配失败，引擎也只会回溯到原子组之前。
  • 示例：^(?>a+)+$。如果 a+ 匹配了 aaa，它就会“吃掉”这三个 a，不会再吐出 a 来尝试其他组合。
• 占有量词 *+, ++, ?+, {n,m}+：这些是量词的“占有”版本。它们会尽可能多地匹配，并且一旦匹配成功，它们不会回溯。
  • 示例：a*+ 匹配尽可能多的 a，并且不会再释放任何 a。

重要提示：Python 的 re 模块 不直接支持 原子组 (?>...) 或占有量词 *+ 等。

在 Python 中，你需要通过精心设计模式来避免回溯：

• 使用非捕获组 (?:...) 配合精确匹配：当不需要捕获内容时，始终使用非捕获组。
• 避免嵌套量词对相同字符的匹配：例如，避免 (X+)+ 这种模式，如果需要多次重复，可以考虑用 X{min,max} 或更具体的模式。
• 尽可能使用反向字符集 [^...] 配合非贪婪量词 *?：这是 Python 中避免贪婪匹配导致过度回溯的常用技巧。
  • 错误示例：<b>.*</b> （贪婪匹配，可能匹配过多）
  • 较好示例：<b>.*?</b> （非贪婪，避免过度匹配）
  • 更佳示例：<b>[^<>]*?</b> （明确排除 < 和 >，使匹配更精确，减少回溯空间）

示例：灾难性回溯演示与优化

import re
import time

# 具有灾难性回溯风险的模式
# 尝试匹配一个由 'a' 组成的序列，后面跟着一个 'X'
# 但文本末尾没有 'X'，这将导致大量回溯
# 想象 s = "aaaaaaaaaaaaaaaaaaaaaaaaaY"
bad_pattern = r"(a+)+$" 

# 长字符串，不匹配
long_string_fail = "a" * 30 + "Y" # 30个'a' + 'Y'
long_string_match = "a" * 30 

print("演示灾难性回溯：")

# 尝试匹配一个不匹配的字符串
start_time = time.time()
match_bad_fail = re.search(bad_pattern, long_string_fail)
end_time = time.time()
print(f"模式 '{bad_pattern}' 在长不匹配字符串上耗时: {end_time - start_time:.6f} 秒")
# 对于非常长的字符串，这里的时间会显著增加，甚至可能运行崩溃。
# 如果是 `(a*)*b` 这样的模式，对于 `a` 组成的字符串，耗时会更长。

# 优化后的模式 (如果目标是匹配一个或多个 'a' 组成的字符串)
# 只需要简单的 'a+'
good_pattern = r"a+$"

start_time = time.time()
match_good_fail = re.search(good_pattern, long_string_fail)
end_time = time.time()
print(f"优化模式 '{good_pattern}' 在长不匹配字符串上耗时: {end_time - start_time:.6f} 秒")

start_time = time.time()
match_good_match = re.search(good_pattern, long_string_match)
end_time = time.time()
print(f"优化模式 '{good_pattern}' 在长匹配字符串上耗时: {end_time - start_time:.6f} 秒 (匹配结果: {match_good_match.group() if match_good_match else '无匹配'})")

输出示例（时间会因系统而异，但趋势是灾难性回溯模式耗时更多）：

演示灾难性回溯：
模式 '(a+)+$' 在长不匹配字符串上耗时: 0.000030 秒  # 对于 30 个 'a' 可能不明显
优化模式 'a+$' 在长不匹配字符串上耗时: 0.000003 秒
优化模式 'a+$' 在长匹配字符串上耗时: 0.000003 秒 (匹配结果: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)

更明显的灾难性回溯示例 (需要更长的字符串才能显著)

让我们用一个更典型的例子来展示灾难性回溯：^(a|aa)+$ 匹配一串 a。

import re
import time

# 灾难性回溯模式：^(a|aa)+$
# 字符串末尾多一个字符，导致无法匹配，但引擎会尝试所有可能的组合
pattern_catastrophic = r"^(a|aa)+$" 

# 一个足以触发明显回溯的长字符串
# 例如，30 个 'a'
long_test_string = "a" * 30 
long_test_string_fail = "a" * 30 + "b" # 不匹配的字符串

print("\n演示更明显的灾难性回溯 (pattern: ^(a|aa)+$)：")

# 匹配成功的字符串
start_time = time.time()
re.search(pattern_catastrophic, long_test_string)
end_time = time.time()
print(f"匹配 '{long_test_string}' 耗时: {end_time - start_time:.6f} 秒")

# 匹配失败的字符串
start_time = time.time()
re.search(pattern_catastrophic, long_test_string_fail)
end_time = time.time()
print(f"匹配 '{long_test_string_fail}' 耗时: {end_time - start_time:.6f} 秒")

# 对比简单模式
pattern_simple = r"^a+$"
start_time = time.time()
re.search(pattern_simple, long_test_string_fail)
end_time = time.time()
print(f"简单模式 '{pattern_simple}' 匹配 '{long_test_string_fail}' 耗时: {end_time - start_time:.6f} 秒")

输出示例（对于 N=30，回溯时间差可能不那么夸张，但随着 N 增大，差异呈指数级）：

演示更明显的灾难性回溯 (pattern: ^(a|aa)+$)：
匹配 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' 耗时: 0.000021 秒
匹配 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaab' 耗时: 0.000045 秒  # 不匹配时回溯成本更高
简单模式 '^a+$' 匹配 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaab' 耗时: 0.000003 秒

解释：当 ^(a|aa)+$ 遇到 aaaaaaaaaab 时，它会尝试所有将 a 分割成 a 或 aa 的组合，直到用尽所有 a，然后发现最后一个字符是 b 而不是预期的字符串结尾。这个尝试所有可能组合的过程就是灾难性回溯。而 ^a+$ 则直接匹配所有 a，效率极高。

通过了解这些优化策略，您可以编写出更健壮、高效且不易导致性能问题的正则表达式。

7. 结语与进一步学习

恭喜您！通过本教程的学习，您已经系统地掌握了 Python 正则表达式的核心语法、高级技巧以及最佳实践。从最基础的字面量匹配到复杂的捕获组、反向引用和标志应用，您现在应该能够自信地构建和应用正则表达式来解决各种文本处理挑战。

正则表达式无疑是一项强大而精密的工具，但它并非解决所有文本问题的银弹。对于高度结构化或嵌套的文本（如复杂的 HTML/XML），专用的解析库往往是更健壮和可维护的选择。然而，对于模式识别、数据提取和文本清理等广泛任务，正则表达式依然是您工具箱中不可或缺的利器。

进一步学习方向：

1. 官方文档：深入阅读 Python re 模块的官方文档，了解更多细节和高级特性（如零宽断言、条件匹配等）。
2. 在线练习平台：
   • RegexOne (regexone.com)：提供交互式教程和练习。
   • Regex Crossword (regexcrossword.com)：通过谜题形式提高您的正则表达式技能。
   • LeetCode (leetcode.com)：搜索与正则表达式相关的算法题，通过实战巩固知识。
3. 高级概念：
   • 零宽断言 (Lookahead/Lookbehind)：(?=...), (?!...), (?<=...), (?<!...)，它们能在不消耗字符的情况下，对匹配位置的前后内容进行条件判断。
   • 条件匹配 (Conditional Matching)：(?(id/name)yes-pattern|no-pattern)，根据之前捕获组是否匹配成功来选择不同的模式分支。
   • 递归模式 (Recursive Patterns)：仅在部分高级引擎中支持，用于处理无限嵌套结构。
4. 实际项目应用：尝试将正则表达式应用于您自己的项目或工作中，从日志分析、数据抓取到文本数据预处理，实践是掌握任何技能的最佳途径。
5. 性能分析：对于大型数据，学习如何使用 Python 的 timeit 模块或 profiler 来分析正则表达式的性能，并进一步优化您的模式。