简体中文 繁體中文 English 日本語 Deutsch 한국 사람 بالعربية TÜRKÇE português คนไทย Français

开启辅助访问 切换到宽版

站内搜索

搜索

活动公告

通知：是的！我们正在计划一个大动作！
11-02 12:46
通知：Telegram 推送频道https://t.me/+2tB3a7aKXlw2YjA1 及时接收第一手论坛帖子信息～
10-23 09:32
通知：本站资源由网友上传分享，如有违规等问题请到版务模块进行投诉，将及时处理！
10-23 09:31
通知：加入QQ社群吧 https://qm.qq.com/q/QZibQd1hiq
10-23 09:28
通知：签到时间调整为每日4:00（东八区）
10-23 09:26
>社区 > 科技 > 经验交流 >帖子
本版发帖返回

正则表达式在Python字符串处理中的全面应用从简单匹配到复杂文本解析掌握这一必备编程技能提升开发效率

威震华夏关云长

3万

主题

349

科技点

3万

积分

大区版主

木柜子打湿

积分
31898

三倍冰淇淋无人之境【一阶】财Doro小樱（小丑装）立华奏以外的星空【二阶】⑨的冰沙
发表于 2025-9-11 09:00:00 | 显示全部楼层 |阅读模式

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要 登录 才可以下载或查看，没有账号？立即注册

x
引言

正则表达式（Regular Expression，简称regex）是一种强大的文本处理工具，它提供了一种灵活的方式来匹配、搜索、替换和验证文本。在Python编程中，正则表达式是处理字符串的必备技能，无论是简单的数据验证还是复杂的文本解析，正则表达式都能大大提高开发效率。

正则表达式最初由数学家Stephen Kleene在1950年代提出，后来被广泛应用于各种编程语言和工具中。在Python中，通过内置的re模块，我们可以充分利用正则表达式的强大功能。掌握正则表达式不仅能够简化代码，还能解决许多复杂的文本处理问题。

本文将从正则表达式的基础知识开始，逐步深入到高级应用，帮助读者全面掌握正则表达式在Python字符串处理中的应用，从简单匹配到复杂文本解析，提升开发效率。

正则表达式基础

什么是正则表达式

正则表达式是一种特殊的字符序列，它使用单个字符串来描述、匹配一系列符合某个句法规则的字符串。正则表达式由普通字符（如字母、数字）和特殊字符（称为”元字符”）组成，通过这些字符的组合，可以构建出复杂的匹配模式。

基本语法

正则表达式的基本语法包括：

1. 普通字符：如字母、数字、下划线等，它们匹配自身。例如：a匹配字符”a”，1匹配数字”1”。
2. 例如：a匹配字符”a”，1匹配数字”1”。
3. 元字符：具有特殊含义的字符，如.、*、+、?、^、$、\、|、()、[]、{}等。.：匹配除换行符外的任意单个字符。*：匹配前面的子表达式零次或多次。+：匹配前面的子表达式一次或多次。?：匹配前面的子表达式零次或一次。^：匹配字符串的开始位置。$：匹配字符串的结束位置。\：转义字符，用于匹配特殊字符本身。|：选择符，匹配|左右任意一个表达式。()：分组，将括号内的表达式作为一个整体。[]：字符类，匹配方括号中的任意一个字符。{}：量词，指定匹配次数。
4. .：匹配除换行符外的任意单个字符。
5. *：匹配前面的子表达式零次或多次。
6. +：匹配前面的子表达式一次或多次。
7. ?：匹配前面的子表达式零次或一次。
8. ^：匹配字符串的开始位置。
9. $：匹配字符串的结束位置。
10. \：转义字符，用于匹配特殊字符本身。
11. |：选择符，匹配|左右任意一个表达式。
12. ()：分组，将括号内的表达式作为一个整体。
13. []：字符类，匹配方括号中的任意一个字符。
14. {}：量词，指定匹配次数。
15. 字符类：使用方括号[]定义，匹配其中的任意一个字符。[abc]：匹配”a”、”b”或”c”。[a-z]：匹配任意小写字母。[A-Z]：匹配任意大写字母。[0-9]：匹配任意数字。[a-zA-Z0-9]：匹配任意字母或数字。
16. [abc]：匹配”a”、”b”或”c”。
17. [a-z]：匹配任意小写字母。
18. [A-Z]：匹配任意大写字母。
19. [0-9]：匹配任意数字。
20. [a-zA-Z0-9]：匹配任意字母或数字。
21. 预定义字符类：\d：匹配任意数字，相当于[0-9]。\D：匹配任意非数字字符，相当于[^0-9]。\w：匹配任意单词字符（字母、数字、下划线），相当于[a-zA-Z0-9_]。\W：匹配任意非单词字符，相当于[^a-zA-Z0-9_]。\s：匹配任意空白字符（空格、制表符、换行符等）。\S：匹配任意非空白字符。
22. \d：匹配任意数字，相当于[0-9]。
23. \D：匹配任意非数字字符，相当于[^0-9]。
24. \w：匹配任意单词字符（字母、数字、下划线），相当于[a-zA-Z0-9_]。
25. \W：匹配任意非单词字符，相当于[^a-zA-Z0-9_]。
26. \s：匹配任意空白字符（空格、制表符、换行符等）。
27. \S：匹配任意非空白字符。
28. 量词：指定匹配的次数。{n}：匹配恰好n次。{n,}：匹配至少n次。{n,m}：匹配至少n次，至多m次。*：匹配0次或多次，相当于{0,}。+：匹配1次或多次，相当于{1,}。?：匹配0次或1次，相当于{0,1}。
29. {n}：匹配恰好n次。
30. {n,}：匹配至少n次。
31. {n,m}：匹配至少n次，至多m次。
32. *：匹配0次或多次，相当于{0,}。
33. +：匹配1次或多次，相当于{1,}。
34. ?：匹配0次或1次，相当于{0,1}。

普通字符：如字母、数字、下划线等，它们匹配自身。

• 例如：a匹配字符”a”，1匹配数字”1”。

元字符：具有特殊含义的字符，如.、*、+、?、^、$、\、|、()、[]、{}等。

• .：匹配除换行符外的任意单个字符。
• *：匹配前面的子表达式零次或多次。
• +：匹配前面的子表达式一次或多次。
• ?：匹配前面的子表达式零次或一次。
• ^：匹配字符串的开始位置。
• $：匹配字符串的结束位置。
• \：转义字符，用于匹配特殊字符本身。
• |：选择符，匹配|左右任意一个表达式。
• ()：分组，将括号内的表达式作为一个整体。
• []：字符类，匹配方括号中的任意一个字符。
• {}：量词，指定匹配次数。

字符类：使用方括号[]定义，匹配其中的任意一个字符。

• [abc]：匹配”a”、”b”或”c”。
• [a-z]：匹配任意小写字母。
• [A-Z]：匹配任意大写字母。
• [0-9]：匹配任意数字。
• [a-zA-Z0-9]：匹配任意字母或数字。

预定义字符类：

• \d：匹配任意数字，相当于[0-9]。
• \D：匹配任意非数字字符，相当于[^0-9]。
• \w：匹配任意单词字符（字母、数字、下划线），相当于[a-zA-Z0-9_]。
• \W：匹配任意非单词字符，相当于[^a-zA-Z0-9_]。
• \s：匹配任意空白字符（空格、制表符、换行符等）。
• \S：匹配任意非空白字符。

量词：指定匹配的次数。

• {n}：匹配恰好n次。
• {n,}：匹配至少n次。
• {n,m}：匹配至少n次，至多m次。
• *：匹配0次或多次，相当于{0,}。
• +：匹配1次或多次，相当于{1,}。
• ?：匹配0次或1次，相当于{0,1}。

Python中的re模块

Python中的re模块提供了正则表达式的支持，它包含了一系列函数用于正则表达式的匹配、搜索、替换和分割等操作。在使用re模块之前，需要先导入它：
  2. import re
复制代码

主要函数和方法

1. re.compile(pattern, flags=0)：编译正则表达式，返回一个正则表达式对象。编译后的正则表达式对象可以重复使用，提高效率。flags参数用于指定匹配模式，如re.IGNORECASE（忽略大小写）、re.MULTILINE（多行模式）等。
2. 编译后的正则表达式对象可以重复使用，提高效率。
3. flags参数用于指定匹配模式，如re.IGNORECASE（忽略大小写）、re.MULTILINE（多行模式）等。
4. re.match(pattern, string, flags=0)：尝试从字符串的起始位置匹配一个模式。如果匹配成功，返回一个匹配对象；否则返回None。只匹配字符串的开始部分。
5. 如果匹配成功，返回一个匹配对象；否则返回None。
6. 只匹配字符串的开始部分。
7. re.search(pattern, string, flags=0)：扫描整个字符串，返回第一个成功的匹配。如果匹配成功，返回一个匹配对象；否则返回None。与match()不同，search()会扫描整个字符串。
8. 如果匹配成功，返回一个匹配对象；否则返回None。
9. 与match()不同，search()会扫描整个字符串。
10. re.findall(pattern, string, flags=0)：查找字符串中所有匹配的子串，返回一个列表。如果没有匹配，返回空列表。
11. 如果没有匹配，返回空列表。
12. re.finditer(pattern, string, flags=0)：查找字符串中所有匹配的子串，返回一个迭代器。每个迭代元素是一个匹配对象。
13. 每个迭代元素是一个匹配对象。
14. re.sub(pattern, repl, string, count=0, flags=0)：替换字符串中所有匹配的子串。repl可以是字符串或函数。count参数指定最大替换次数，默认为0（替换所有匹配）。
15. repl可以是字符串或函数。
16. count参数指定最大替换次数，默认为0（替换所有匹配）。
17. re.split(pattern, string, maxsplit=0, flags=0)：根据匹配的子串分割字符串。maxsplit参数指定最大分割次数，默认为0（分割所有匹配）。
18. maxsplit参数指定最大分割次数，默认为0（分割所有匹配）。

re.compile(pattern, flags=0)：编译正则表达式，返回一个正则表达式对象。

• 编译后的正则表达式对象可以重复使用，提高效率。
• flags参数用于指定匹配模式，如re.IGNORECASE（忽略大小写）、re.MULTILINE（多行模式）等。

re.match(pattern, string, flags=0)：尝试从字符串的起始位置匹配一个模式。

• 如果匹配成功，返回一个匹配对象；否则返回None。
• 只匹配字符串的开始部分。

re.search(pattern, string, flags=0)：扫描整个字符串，返回第一个成功的匹配。

• 如果匹配成功，返回一个匹配对象；否则返回None。
• 与match()不同，search()会扫描整个字符串。

re.findall(pattern, string, flags=0)：查找字符串中所有匹配的子串，返回一个列表。

• 如果没有匹配，返回空列表。

re.finditer(pattern, string, flags=0)：查找字符串中所有匹配的子串，返回一个迭代器。

• 每个迭代元素是一个匹配对象。

re.sub(pattern, repl, string, count=0, flags=0)：替换字符串中所有匹配的子串。

• repl可以是字符串或函数。
• count参数指定最大替换次数，默认为0（替换所有匹配）。

re.split(pattern, string, maxsplit=0, flags=0)：根据匹配的子串分割字符串。

• maxsplit参数指定最大分割次数，默认为0（分割所有匹配）。

匹配对象

当match()或search()函数成功匹配时，它们会返回一个匹配对象（Match对象）。匹配对象提供了以下方法：

1. group([group1, …])：返回一个或多个匹配的子组。group()或group(0)返回整个匹配。group(1)、group(2)等返回第1、第2个捕获组的内容。
2. group()或group(0)返回整个匹配。
3. group(1)、group(2)等返回第1、第2个捕获组的内容。
4. groups(default=None)：返回所有子组的元组。如果没有匹配的子组，返回空元组。
5. 如果没有匹配的子组，返回空元组。
6. groupdict(default=None)：返回所有命名子组的字典。键是子组名，值是匹配的内容。
7. 键是子组名，值是匹配的内容。
8. start([group])：返回匹配的起始位置。如果指定了group，则返回指定组的起始位置。
9. 如果指定了group，则返回指定组的起始位置。
10. end([group])：返回匹配的结束位置。如果指定了group，则返回指定组的结束位置。
11. 如果指定了group，则返回指定组的结束位置。
12. span([group])：返回一个包含匹配(start, end)位置的元组。如果指定了group，则返回指定组的(start, end)位置。
13. 如果指定了group，则返回指定组的(start, end)位置。

group([group1, …])：返回一个或多个匹配的子组。

• group()或group(0)返回整个匹配。
• group(1)、group(2)等返回第1、第2个捕获组的内容。

groups(default=None)：返回所有子组的元组。

• 如果没有匹配的子组，返回空元组。

groupdict(default=None)：返回所有命名子组的字典。

• 键是子组名，值是匹配的内容。

start([group])：返回匹配的起始位置。

• 如果指定了group，则返回指定组的起始位置。

end([group])：返回匹配的结束位置。

• 如果指定了group，则返回指定组的结束位置。

span([group])：返回一个包含匹配(start, end)位置的元组。

• 如果指定了group，则返回指定组的(start, end)位置。

编译标志

re模块提供了一些编译标志，用于修改正则表达式的行为：

1. re.IGNORECASE或re.I：忽略大小写。例如：re.findall(r'[a-z]', 'Hello World', re.I)会匹配所有字母，不区分大小写。
2. 例如：re.findall(r'[a-z]', 'Hello World', re.I)会匹配所有字母，不区分大小写。
3. re.MULTILINE或re.M：多行模式。使^和$匹配每行的开始和结束，而不仅仅是整个字符串的开始和结束。例如：re.findall(r'^\w+', 'Hello\nWorld', re.M)会匹配”Hello”和”World”。
4. 使^和$匹配每行的开始和结束，而不仅仅是整个字符串的开始和结束。
5. 例如：re.findall(r'^\w+', 'Hello\nWorld', re.M)会匹配”Hello”和”World”。
6. re.DOTALL或re.S：使.匹配包括换行符在内的所有字符。默认情况下，.不匹配换行符。例如：re.search(r'.+', 'Hello\nWorld', re.S)会匹配整个字符串”Hello\nWorld”。
7. 默认情况下，.不匹配换行符。
8. 例如：re.search(r'.+', 'Hello\nWorld', re.S)会匹配整个字符串”Hello\nWorld”。
9.
  2. re.VERBOSE或re.X：详细模式。允许正则表达式分成多行，并添加注释，提高可读性。例如：
  3. “`python
  4. pattern = r”“”
  5. \d{3}    # 匹配3位数字（区号）# 匹配连字符
  6. \d{4}    # 匹配4位数字（前缀）# 匹配连字符
  7. \d{4}    # 匹配4位数字（后缀）
  8. “””
  9. re.compile(pattern, re.VERBOSE)”`
复制代码
10. 允许正则表达式分成多行，并添加注释，提高可读性。
11.
  2. 例如：
  3. “`python
  4. pattern = r”“”
  5. \d{3}    # 匹配3位数字（区号）# 匹配连字符
  6. \d{4}    # 匹配4位数字（前缀）# 匹配连字符
  7. \d{4}    # 匹配4位数字（后缀）
  8. “””
  9. re.compile(pattern, re.VERBOSE)”`
复制代码
12.
  2. # 匹配连字符
  3. \d{4}    # 匹配4位数字（前缀）
复制代码
13.
  2. # 匹配连字符
  3. \d{4}    # 匹配4位数字（后缀）
  4. “””
  5. re.compile(pattern, re.VERBOSE)
复制代码
14. re.ASCII或re.A：使\w、\W、\b、\B、\d、\D、\s和\S只匹配ASCII字符，而不是Unicode字符。在Python 3中，默认情况下这些字符类匹配Unicode字符。
15. 在Python 3中，默认情况下这些字符类匹配Unicode字符。
16. re.UNICODE或re.U：使\w、\W、\b、\B、\d、\D、\s和\S匹配Unicode字符。在Python 3中，这是默认行为。
17. 在Python 3中，这是默认行为。

re.IGNORECASE或re.I：忽略大小写。

• 例如：re.findall(r'[a-z]', 'Hello World', re.I)会匹配所有字母，不区分大小写。

re.MULTILINE或re.M：多行模式。

• 使^和$匹配每行的开始和结束，而不仅仅是整个字符串的开始和结束。
• 例如：re.findall(r'^\w+', 'Hello\nWorld', re.M)会匹配”Hello”和”World”。

re.DOTALL或re.S：使.匹配包括换行符在内的所有字符。

• 默认情况下，.不匹配换行符。
• 例如：re.search(r'.+', 'Hello\nWorld', re.S)会匹配整个字符串”Hello\nWorld”。

re.VERBOSE或re.X：详细模式。

• 允许正则表达式分成多行，并添加注释，提高可读性。
•
  2. 例如：
  3. “`python
  4. pattern = r”“”
  5. \d{3}    # 匹配3位数字（区号）# 匹配连字符
  6. \d{4}    # 匹配4位数字（前缀）# 匹配连字符
  7. \d{4}    # 匹配4位数字（后缀）
  8. “””
  9. re.compile(pattern, re.VERBOSE)”`
复制代码
•
  2. # 匹配连字符
  3. \d{4}    # 匹配4位数字（前缀）
复制代码
•
  2. # 匹配连字符
  3. \d{4}    # 匹配4位数字（后缀）
  4. “””
  5. re.compile(pattern, re.VERBOSE)
复制代码

•
  2. # 匹配连字符
  3. \d{4}    # 匹配4位数字（前缀）
复制代码
•
  2. # 匹配连字符
  3. \d{4}    # 匹配4位数字（后缀）
  4. “””
  5. re.compile(pattern, re.VERBOSE)
复制代码

re.ASCII或re.A：使\w、\W、\b、\B、\d、\D、\s和\S只匹配ASCII字符，而不是Unicode字符。

• 在Python 3中，默认情况下这些字符类匹配Unicode字符。

re.UNICODE或re.U：使\w、\W、\b、\B、\d、\D、\s和\S匹配Unicode字符。

• 在Python 3中，这是默认行为。

简单匹配

字符匹配

最基本的正则表达式是字符匹配，它匹配指定的字符。
  2. import re
  4. # 匹配单个字符
  5. result = re.search(r'a', 'apple')
  6. print(result.group())  # 输出: a
  8. # 匹配多个字符
  9. result = re.search(r'apple', 'I like apple')
  10. print(result.group())  # 输出: apple
复制代码

字符类

字符类使用方括号[]定义，匹配其中的任意一个字符。
  2. import re
  4. # 匹配任意一个元音字母
  5. result = re.search(r'[aeiou]', 'hello')
  6. print(result.group())  # 输出: e
  8. # 匹配任意一个数字
  9. result = re.search(r'[0-9]', 'Python 3.9')
  10. print(result.group())  # 输出: 3
  12. # 匹配任意一个非元音字母
  13. result = re.search(r'[^aeiou]', 'hello')
  14. print(result.group())  # 输出: h
复制代码

预定义字符类

预定义字符类提供了简写方式，用于匹配常见的字符类型。
  2. import re
  4. # 匹配任意数字
  5. result = re.search(r'\d', 'Python 3.9')
  6. print(result.group())  # 输出: 3
  8. # 匹配任意非数字字符
  9. result = re.search(r'\D', '123abc')
  10. print(result.group())  # 输出: a
  12. # 匹配任意单词字符
  13. result = re.search(r'\w', 'hello world')
  14. print(result.group())  # 输出: h
  16. # 匹配任意非单词字符
  17. result = re.search(r'\W', 'hello world')
  18. print(result.group())  # 输出: (空格)
  20. # 匹配任意空白字符
  21. result = re.search(r'\s', 'hello world')
  22. print(result.group())  # 输出: (空格)
  24. # 匹配任意非空白字符
  25. result = re.search(r'\S', '   hello')
  26. print(result.group())  # 输出: h
复制代码

量词

量词用于指定匹配的次数。
  2. import re
  4. # 匹配0次或多次
  5. result = re.search(r'ab*c', 'ac')
  6. print(result.group())  # 输出: ac
  8. result = re.search(r'ab*c', 'abc')
  9. print(result.group())  # 输出: abc
  11. result = re.search(r'ab*c', 'abbbc')
  12. print(result.group())  # 输出: abbbc
  14. # 匹配1次或多次
  15. result = re.search(r'ab+c', 'ac')
  16. print(result)  # 输出: None
  18. result = re.search(r'ab+c', 'abc')
  19. print(result.group())  # 输出: abc
  21. result = re.search(r'ab+c', 'abbbc')
  22. print(result.group())  # 输出: abbbc
  24. # 匹配0次或1次
  25. result = re.search(r'ab?c', 'ac')
  26. print(result.group())  # 输出: ac
  28. result = re.search(r'ab?c', 'abc')
  29. print(result.group())  # 输出: abc
  31. result = re.search(r'ab?c', 'abbc')
  32. print(result)  # 输出: None
  34. # 指定匹配次数
  35. result = re.search(r'a{3}', 'aaa')
  36. print(result.group())  # 输出: aaa
  38. result = re.search(r'a{3}', 'aa')
  39. print(result)  # 输出: None
  41. result = re.search(r'a{2,4}', 'aa')
  42. print(result.group())  # 输出: aa
  44. result = re.search(r'a{2,4}', 'aaa')
  45. print(result.group())  # 输出: aaa
  47. result = re.search(r'a{2,4}', 'aaaaa')
  48. print(result.group())  # 输出: aaaa
  50. result = re.search(r'a{2,}', 'aa')
  51. print(result.group())  # 输出: aa
  53. result = re.search(r'a{2,}', 'aaaaa')
  54. print(result.group())  # 输出: aaaaa
复制代码

边界匹配

边界匹配用于指定匹配的位置。
  2. import re
  4. # 匹配字符串的开始
  5. result = re.search(r'^hello', 'hello world')
  6. print(result.group())  # 输出: hello
  8. result = re.search(r'^hello', 'world hello')
  9. print(result)  # 输出: None
  11. # 匹配字符串的结束
  12. result = re.search(r'world$', 'hello world')
  13. print(result.group())  # 输出: world
  15. result = re.search(r'world$', 'world hello')
  16. print(result)  # 输出: None
  18. # 匹配单词边界
  19. result = re.search(r'\bhello\b', 'hello world')
  20. print(result.group())  # 输出: hello
  22. result = re.search(r'\bhello\b', 'helloworld')
  23. print(result)  # 输出: None
  25. result = re.search(r'\Bhello\B', 'helloworld')
  26. print(result)  # 输出: hello
复制代码

进阶匹配

分组和捕获

分组使用圆括号()实现，它可以将多个字符作为一个整体，并且可以捕获匹配的内容。
  2. import re
  4. # 分组
  5. result = re.search(r'(ab)+', 'ababab')
  6. print(result.group())  # 输出: ababab
  7. print(result.group(1))  # 输出: ab
  9. # 捕获组
  10. result = re.search(r'(\d{4})-(\d{2})-(\d{2})', '2023-05-15')
  11. print(result.group())  # 输出: 2023-05-15
  12. print(result.group(1))  # 输出: 2023
  13. print(result.group(2))  # 输出: 05
  14. print(result.group(3))  # 输出: 15
  15. print(result.groups())  # 输出: ('2023', '05', '15')
复制代码

非捕获分组

有时候我们只需要分组的功能，而不需要捕获匹配的内容，这时可以使用非捕获分组(?:...)。
  2. import re
  4. # 非捕获分组
  5. result = re.search(r'(?:ab)+', 'ababab')
  6. print(result.group())  # 输出: ababab
  7. print(result.groups())  # 输出: ()
  9. # 比较捕获分组和非捕获分组
  10. result = re.search(r'(ab)+', 'ababab')
  11. print(result.groups())  # 输出: ('ab',)
  13. result = re.search(r'(?:ab)+', 'ababab')
  14. print(result.groups())  # 输出: ()
复制代码

命名分组

命名分组使用(?P<name>...)语法，可以为分组指定一个名称，便于后续引用。
  2. import re
  4. # 命名分组
  5. result = re.search(r'(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})', '2023-05-15')
  6. print(result.group())  # 输出: 2023-05-15
  7. print(result.group('year'))  # 输出: 2023
  8. print(result.group('month'))  # 输出: 05
  9. print(result.group('day'))  # 输出: 15
  10. print(result.groupdict())  # 输出: {'year': '2023', 'month': '05', 'day': '15'}
复制代码

反向引用

反向引用允许我们引用前面捕获组匹配的内容，使用\1、\2等语法。
  2. import re
  4. # 反向引用
  5. result = re.search(r'(\w+)\s+\1', 'hello hello')
  6. print(result.group())  # 输出: hello hello
  8. result = re.search(r'(\w+)\s+\1', 'hello world')
  9. print(result)  # 输出: None
  11. # 使用命名分组的反向引用
  12. result = re.search(r'(?P<word>\w+)\s+(?P=word)', 'hello hello')
  13. print(result.group())  # 输出: hello hello
复制代码

选择符

选择符|用于匹配多个可能的模式之一。
  2. import re
  4. # 选择符
  5. result = re.search(r'cat|dog', 'I have a cat')
  6. print(result.group())  # 输出: cat
  8. result = re.search(r'cat|dog', 'I have a dog')
  9. print(result.group())  # 输出: dog
  11. # 与分组结合使用
  12. result = re.search(r'I have a (cat|dog)', 'I have a cat')
  13. print(result.group())  # 输出: I have a cat
  14. print(result.group(1))  # 输出: cat
复制代码

贪婪与非贪婪匹配

默认情况下，量词是贪婪的，它们会尽可能多地匹配字符。非贪婪匹配（也称为懒惰匹配）使用?后缀，会尽可能少地匹配字符。
  2. import re
  4. # 贪婪匹配
  5. result = re.search(r'<.*>', '<div>hello</div>')
  6. print(result.group())  # 输出: <div>hello</div>
  8. # 非贪婪匹配
  9. result = re.search(r'<.*?>', '<div>hello</div>')
  10. print(result.group())  # 输出: <div>
  12. # 贪婪与非贪婪的对比
  13. result = re.search(r'a+', 'aaa')
  14. print(result.group())  # 输出: aaa
  16. result = re.search(r'a+?', 'aaa')
  17. print(result.group())  # 输出: a
  19. result = re.search(r'a{2,4}', 'aaaaa')
  20. print(result.group())  # 输出: aaaa
  22. result = re.search(r'a{2,4}?', 'aaaaa')
  23. print(result.group())  # 输出: aa
复制代码

复杂文本解析

前瞻和后顾

前瞻和后顾是零宽断言，它们匹配特定的位置，但不消耗字符。

1. 正向先行断言(?=...)：匹配后面是特定模式的位置。
2. 负向先行断言(?!...)：匹配后面不是特定模式的位置。
3. 正向后行断言(?<=...)：匹配前面是特定模式的位置。
4. 负向后行断言(?<!...)：匹配前面不是特定模式的位置。
  2. import re
  4. # 正向先行断言
  5. result = re.search(r'\w+(?=\s+apple)', 'I like apple')
  6. print(result.group())  # 输出: like
  8. # 负向先行断言
  9. result = re.search(r'\w+(?!\s+apple)', 'I like apple')
  10. print(result.group())  # 输出: I
  12. # 正向后行断言
  13. result = re.search(r'(?<=I\s+)\w+', 'I like apple')
  14. print(result.group())  # 输出: like
  16. # 负向后行断言
  17. result = re.search(r'(?<!I\s+)\w+', 'I like apple')
  18. print(result.group())  # 输出: apple
复制代码

条件匹配

条件匹配使用(?(id/name)yes-pattern|no-pattern)语法，根据指定的组是否存在来选择匹配的模式。
  2. import re
  4. # 条件匹配
  5. pattern = r'(\d+)?(?(1)\.\d+|\.\d+)'
  6. result = re.search(pattern, '123.456')
  7. print(result.group())  # 输出: 123.456
  9. result = re.search(pattern, '.456')
  10. print(result.group())  # 输出: .456
  12. result = re.search(pattern, '123')
  13. print(result)  # 输出: None
复制代码

回溯控制

回溯控制使用(?>...)语法，也称为原子组，一旦匹配，就不会回溯。
  2. import re
  4. # 回溯控制
  5. result = re.search(r'(?>a+)b', 'aaab')
  6. print(result.group())  # 输出: aaab
  8. result = re.search(r'(?>a+)a', 'aaa')
  9. print(result)  # 输出: None
  11. # 对比普通分组
  12. result = re.search(r'(a+)a', 'aaa')
  13. print(result.group())  # 输出: aaa
复制代码

实际应用案例

数据提取

正则表达式常用于从文本中提取特定格式的数据。
  2. import re
  4. # 提取电子邮件地址
  5. text = "Contact us at info@example.com or support@example.org"
  6. emails = re.findall(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b', text)
  7. print(emails)  # 输出: ['info@example.com', 'support@example.org']
  9. # 提取URL
  10. text = "Visit our website at https://www.example.com or http://example.org"
  11. urls = re.findall(r'https?://(?:[-\w.]|(?:%[\da-fA-F]{2}))+', text)
  12. print(urls)  # 输出: ['https://www.example.com', 'http://example.org']
  14. # 提取电话号码
  15. text = "Call us at (123) 456-7890 or 123-456-7890"
  16. phone_numbers = re.findall(r'\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}', text)
  17. print(phone_numbers)  # 输出: ['(123) 456-7890', '123-456-7890']
  19. # 提取日期
  20. text = "The event will be held on 2023-05-15 and 2023/06/20"
  21. dates = re.findall(r'\d{4}[-/]\d{2}[-/]\d{2}', text)
  22. print(dates)  # 输出: ['2023-05-15', '2023/06/20']
复制代码

数据验证

正则表达式常用于验证数据是否符合特定格式。
  2. import re
  4. # 验证电子邮件地址
  5. def is_valid_email(email):
  6.     pattern = r'^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}$'
  7.     return bool(re.match(pattern, email))
  9. print(is_valid_email('user@example.com'))  # 输出: True
  10. print(is_valid_email('invalid.email'))  # 输出: False
  12. # 验证URL
  13. def is_valid_url(url):
  14.     pattern = r'^https?://(?:[-\w.]|(?:%[\da-fA-F]{2}))+[^\s]*$'
  15.     return bool(re.match(pattern, url))
  17. print(is_valid_url('https://www.example.com'))  # 输出: True
  18. print(is_valid_url('example.com'))  # 输出: False
  20. # 验证密码强度
  21. def is_strong_password(password):
  22.     # 至少8个字符，包含大写字母、小写字母、数字和特殊字符
  23.     pattern = r'^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$'
  24.     return bool(re.match(pattern, password))
  26. print(is_strong_password('Password123!'))  # 输出: True
  27. print(is_strong_password('password'))  # 输出: False
复制代码

数据替换

正则表达式常用于替换文本中的特定模式。
  2. import re
  4. # 替换电子邮件地址
  5. text = "Contact us at info@example.com or support@example.org"
  6. new_text = re.sub(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b', '[EMAIL]', text)
  7. print(new_text)  # 输出: Contact us at [EMAIL] or [EMAIL]
  9. # 替换HTML标签
  10. html = "<div><p>Hello, <b>world</b>!</p></div>"
  11. plain_text = re.sub(r'<[^>]+>', '', html)
  12. print(plain_text)  # 输出: Hello, world!
  14. # 格式化电话号码
  15. text = "Call us at (123) 456-7890 or 123-456-7890"
  16. formatted_numbers = re.sub(r'\(?(\d{3})\)?[-.\s]?(\d{3})[-.\s]?(\d{4})', r'\1.\2.\3', text)
  17. print(formatted_numbers)  # 输出: Call us at 123.456.7890 or 123.456.7890
  19. # 删除多余的空格
  20. text = "This   is   a   text   with   extra   spaces"
  21. cleaned_text = re.sub(r'\s+', ' ', text)
  22. print(cleaned_text)  # 输出: This is a text with extra spaces
复制代码

数据分割

正则表达式常用于根据特定模式分割文本。
  2. import re
  4. # 分割文本为句子
  5. text = "Hello! How are you? I'm fine, thanks."
  6. sentences = re.split(r'[.!?]', text)
  7. print(sentences)  # 输出: ['Hello', ' How are you', " I'm fine, thanks", '']
  9. # 分割CSV行（考虑引号内的逗号）
  10. csv_line = 'John,Doe,"New York, NY",30'
  11. fields = re.split(r',(?=(?:[^"]*"[^"]*")*[^"]*$)', csv_line)
  12. print(fields)  # 输出: ['John', 'Doe', '"New York, NY"', '30']
  14. # 分割日志条目
  15. log = "2023-05-15 10:30:00 INFO This is a log message"
  16. parts = re.split(r'\s+', log, 3)
  17. print(parts)  # 输出: ['2023-05-15', '10:30:00', 'INFO', 'This is a log message']
复制代码

复杂文本解析

正则表达式可以用于解析复杂的文本结构。
  2. import re
  4. # 解析INI文件
  5. ini_content = """
  6. [database]
  7. host = localhost
  8. port = 3306
  9. username = root
  10. password = secret
  12. [server]
  13. host = 0.0.0.0
  14. port = 8080
  15. debug = true
  16. """
  18. config = {}
  19. current_section = None
  21. for line in ini_content.split('\n'):
  22.     line = line.strip()
  23.     if not line or line.startswith(';') or line.startswith('#'):
  24.         continue
  25.    
  26.     section_match = re.match(r'^\[([^\]]+)\]$', line)
  27.     if section_match:
  28.         current_section = section_match.group(1)
  29.         config[current_section] = {}
  30.         continue
  31.    
  32.     if current_section:
  33.         key_value_match = re.match(r'^([^=]+)=(.*)$', line)
  34.         if key_value_match:
  35.             key = key_value_match.group(1).strip()
  36.             value = key_value_match.group(2).strip()
  37.             config[current_section][key] = value
  39. print(config)
  40. # 输出: {
  41. #     'database': {
  42. #         'host': 'localhost',
  43. #         'port': '3306',
  44. #         'username': 'root',
  45. #         'password': 'secret'
  46. #     },
  47. #     'server': {
  48. #         'host': '0.0.0.0',
  49. #         'port': '8080',
  50. #         'debug': 'true'
  51. #     }
  52. # }
  54. # 解析简单的XML/HTML标签
  55. html = """
  56. <div class="container">
  57.     <h1 id="title">Welcome</h1>
  58.     <p class="content">This is a paragraph.</p>
  59.     <a href="https://example.com">Link</a>
  60. </div>
  61. """
  63. tags = re.findall(r'<(\w+)(?:\s+([^>]*))?>', html)
  64. print(tags)
  65. # 输出: [('div', 'class="container"'), ('h1', 'id="title"'), ('p', 'class="content"'), ('a', 'href="https://example.com"')]
  67. # 提取标签内容
  68. contents = re.findall(r'<(\w+)(?:\s+[^>]*)?>(.*?)</\1>', html, re.DOTALL)
  69. print(contents)
  70. # 输出: [('div', '\n    <h1 id="title">Welcome</h1>\n    <p class="content">This is a paragraph.</p>\n    <a href="https://example.com">Link</a>\n'), ('h1', 'Welcome'), ('p', 'This is a paragraph.'), ('a', 'Link')]
复制代码

性能优化和最佳实践

编译正则表达式

如果同一个正则表达式需要多次使用，最好先编译它。
  2. import re
  4. # 不推荐：每次使用都重新编译
  5. for i in range(100):
  6.     result = re.search(r'\d+', 'abc123def')
  8. # 推荐：先编译，然后重复使用
  9. pattern = re.compile(r'\d+')
  10. for i in range(100):
  11.     result = pattern.search('abc123def')
复制代码

使用原始字符串

在Python中，使用原始字符串（以r前缀）来定义正则表达式可以避免转义字符的问题。
  2. import re
  4. # 不推荐：需要双重转义
  5. pattern = re.compile('\\d+')
  7. # 推荐：使用原始字符串
  8. pattern = re.compile(r'\d+')
复制代码

避免回溯灾难

回溯灾难是指正则表达式在匹配失败时需要进行大量回溯，导致性能急剧下降。避免回溯灾难的方法包括：

1. 使用原子组(?>...)
2. 使用占有量词*+,++,?+,{n,m}+
3. 避免嵌套量词，如(a+)+
4. 使用更具体的模式，减少不必要的匹配
  2. import re
  3. import time
  5. # 可能导致回溯灾难的模式
  6. bad_pattern = re.compile(r'(a+)+b')
  8. # 优化的模式
  9. good_pattern = re.compile(r'a+b')
  11. # 测试性能
  12. test_string = 'a' * 30 + 'c'
  14. start_time = time.time()
  15. bad_pattern.search(test_string)
  16. bad_time = time.time() - start_time
  18. start_time = time.time()
  19. good_pattern.search(test_string)
  20. good_time = time.time() - start_time
  22. print(f"Bad pattern time: {bad_time:.6f} seconds")
  23. print(f"Good pattern time: {good_time:.6f} seconds")
复制代码

使用适当的函数

根据需求选择合适的函数：

• re.match()：只检查字符串开头是否匹配
• re.search()：检查整个字符串中是否有匹配
• re.findall()：查找所有匹配的子串
• re.finditer()：查找所有匹配的子串，返回迭代器
• re.sub()：替换匹配的子串
• re.split()：根据匹配的子串分割字符串
  2. import re
  4. text = "The quick brown fox jumps over the lazy dog. The dog is not that lazy."
  6. # 只检查开头
  7. if re.match(r'The', text):
  8.     print("Text starts with 'The'")
  10. # 查找所有匹配
  11. words = re.findall(r'\b\w{4}\b', text)
  12. print(words)  # 输出: ['over', 'lazy', 'that', 'lazy']
  14. # 使用迭代器处理大量匹配
  15. for match in re.finditer(r'\b(\w)(\w+)(\w)\b', text):
  16.     word = match.group(0)
  17.     first = match.group(1)
  18.     middle = match.group(2)
  19.     last = match.group(3)
  20.     print(f"Word: {word}, First: {first}, Middle: {middle}, Last: {last}")
  22. # 替换匹配
  23. new_text = re.sub(r'\blazy\b', 'energetic', text)
  24. print(new_text)
  26. # 分割字符串
  27. sentences = re.split(r'\.\s*', text)
  28. print(sentences)
复制代码

使用详细模式提高可读性

对于复杂的正则表达式，使用re.VERBOSE标志可以提高可读性。
  2. import re
  4. # 不推荐：难以阅读
  5. pattern = re.compile(r'(?:(\d{1,3})\.){3}\d{1,3}')
  7. # 推荐：使用详细模式
  8. pattern = re.compile(r"""
  9.     (?:                 # 开始非捕获分组
  10.         (\d{1,3})       # 匹配1到3位数字（捕获组）
  11.         \.              # 匹配点号
  12.     ){3}                # 结束分组，重复3次
  13.     \d{1,3}             # 匹配1到3位数字
  14. """, re.VERBOSE)
复制代码

测试和调试正则表达式

使用在线工具或Python的re.debug标志来测试和调试正则表达式。
  2. import re
  4. # 使用re.debug标志（Python 3.11+）
  5. try:
  6.     pattern = re.compile(r'\d+', re.DEBUG)
  7. except AttributeError:
  8.     print("re.DEBUG is not available in this Python version")
  10. # 手动测试
  11. test_cases = [
  12.     ('abc123def', True),
  13.     ('abcdef', False),
  14.     ('123', True),
  15.     ('', False)
  16. ]
  18. pattern = re.compile(r'\d+')
  19. for test_string, expected in test_cases:
  20.     result = bool(pattern.search(test_string))
  21.     print(f"Test: '{test_string}', Expected: {expected}, Result: {result}, {'PASS' if result == expected else 'FAIL'}")
复制代码

总结

正则表达式是Python中处理字符串的强大工具，从简单的字符匹配到复杂的文本解析，它都能提供高效的解决方案。通过本文的学习，我们了解了正则表达式的基础知识、Python中的re模块、简单匹配、进阶匹配、复杂文本解析以及实际应用案例。

掌握正则表达式需要大量的练习和实践。在实际开发中，我们应该根据具体需求选择合适的正则表达式模式，并注意性能优化和最佳实践。同时，也要注意正则表达式的局限性，对于非常复杂的文本解析任务，可能需要结合其他解析技术。

正则表达式是一项必备的编程技能，掌握它将大大提高开发效率，使字符串处理变得更加简单和高效。希望本文能够帮助读者全面了解正则表达式在Python中的应用，并在实际项目中灵活运用。
编程, 必备, 文本, 字符串, 解析
回复

使用道具 举报

mai2

0

主题

645

科技点

436

积分

候风辨气

积分
436
发表于 2025-9-11 09:46:57 | 显示全部楼层
感謝分享
温馨提示：看帖回帖是一种美德，您的每一次发帖、回帖都是对论坛最大的支持，谢谢！ [这是默认签名,点我更换签名]
回复 支持 反对

使用道具 举报

返回列表 发新帖
您需要登录后才可以回帖 登录 | 立即注册
高级模式
B Color Image Link Quote Code Smilies

本版积分规则

友情链接

keba
磕巴白菜
别管 别听 就是玩
二次元论坛
二次元论坛
按下F逃离世界！
次元宅社
次元宅社
开放、共创，CHANGE SEKAI！
频道订阅

频道订阅

加入社群

加入社群

联系我们|TG频道|RSS

Powered by Pixtech

© 2025 Pixtech Team.