如何使用Python进行正则表达式匹配（re模块）？-Python教程-PHP中文网

re模块是Python处理正则表达式的核心工具，提供re.search()（全文查找首个匹配）、re.match()（仅从字符串开头匹配）、re.findall()（返回所有匹配）、re.sub()（替换匹配项）和re.compile()（预编译提升性能）等关键函数；需注意使用原始字符串避免转义错误，区分贪婪与非贪婪匹配，合理使用分组捕获和非捕获组，并通过预编译及精确模式优化性能，避免回溯失控等问题。

如何使用python进行正则表达式匹配（re模块）？

Python的

re

登录后复制

模块是处理正则表达式的核心工具，它提供了一系列函数来查找、替换、分割字符串，是文本处理中不可或缺的利器。无论你是需要从日志文件中提取特定信息，还是校验用户输入的格式，

re

登录后复制

模块都能以其强大的模式匹配能力助你一臂之力。

解决方案

掌握

re

登录后复制

模块，核心在于理解其几个关键函数和正则表达式本身的语法。在我看来，这就像是学习一门新的微型编程语言，一旦上手，你会发现它在处理文本时的效率远超常规的字符串操作。

最常用的几个函数包括：

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

登录后复制

: 这个函数会在整个字符串中寻找第一个匹配项。一旦找到，它会返回一个匹配对象（Match Object）；如果没找到，则返回

None

登录后复制

。记住，它不要求匹配从字符串的开头开始。

立即学习“Python免费学习笔记（深入）”；

import re

text = "我的电话是 138-1234-5678，办公室电话是 010-87654321。"
# 查找手机号
match = re.search(r'\d{3}-\d{4}-\d{4}', text)
if match:
    print(f"找到的手机号: {match.group(0)}")
    # 结果: 找到的手机号: 138-1234-5678
else:
    print("未找到手机号。")

登录后复制

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

登录后复制

: 与

re.search()

登录后复制

不同，

re.match()

登录后复制

只尝试从字符串的开头进行匹配。如果字符串开头不符合模式，即使后面有匹配项，它也会返回

None

登录后复制

。

import re

text = "电话是 138-1234-5678。"
# 尝试从开头匹配手机号
match_start = re.match(r'\d{3}-\d{4}-\d{4}', text)
if match_start:
    print(f"从开头匹配到: {match_start.group(0)}")
else:
    print("从开头未匹配到手机号。") # 会输出这个，因为“电话是 ”不符合模式

登录后复制

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

登录后复制

: 如果你需要找到所有非重叠的匹配项，并以列表形式返回它们，

re.findall()

登录后复制

就是你的首选。它会遍历整个字符串，把所有符合模式的子串都找出来。

import re

text = "邮件地址有 test@example.com 和 user@domain.org。"
# 查找所有邮件地址
emails = re.findall(r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}', text)
print(f"找到的邮件地址: {emails}")
# 结果: 找到的邮件地址: ['test@example.com', 'user@domain.org']

登录后复制

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

登录后复制

: 替换字符串中的匹配项。

repl

登录后复制

可以是字符串，也可以是一个函数。

count

登录后复制

参数可以限制替换的次数。

import re

text = "我很喜欢 Python，Python 编程很有趣。"
# 将所有“Python”替换为“Java”
new_text = re.sub(r'Python', 'Java', text)
print(f"替换后的文本: {new_text}")
# 结果: 替换后的文本: 我很喜欢 Java，Java 编程很有趣。

# 只替换第一个
new_text_one = re.sub(r'Python', 'Java', text, count=1)
print(f"替换第一个后的文本: {new_text_one}")
# 结果: 替换第一个后的文本: 我很喜欢 Java，Python 编程很有趣。

登录后复制

re.compile(pattern, flags=0)

登录后复制

: 当你需要多次使用同一个正则表达式时，预编译它会显著提升性能。它会返回一个正则表达式对象，然后你可以用这个对象调用

search()

登录后复制

match()

登录后复制

findall()

登录后复制

sub()

登录后复制

等方法。

import re

# 编译正则表达式
phone_pattern = re.compile(r'\d{3}-\d{4}-\d{4}')

text1 = "我的手机是 139-8765-4321。"
text2 = "联系方式是 130-1111-2222。"

match1 = phone_pattern.search(text1)
if match1:
    print(f"文本1中找到: {match1.group(0)}")

match2 = phone_pattern.search(text2)
if match2:
    print(f"文本2中找到: {match2.group(0)}")

登录后复制

re.search()与re.match()：匹配起始点的关键差异在哪里？

这是初学者最常感到困惑的地方之一，也是我当年踩过的小坑。简单来说，

re.match()

登录后复制

只在字符串的开头寻找匹配。如果模式在字符串的第一个字符处不匹配，那么

re.match()

登录后复制

就直接放弃了，返回

None

登录后复制

，即使字符串后面有符合模式的部分。它就像一个非常固执的守门员，只看你是不是从大门进来的。

而

re.search()

登录后复制

则要灵活得多，它会扫描整个字符串，寻找第一个能匹配模式的位置。它会从左到右逐个字符地尝试匹配，直到找到第一个符合模式的子串。你可以把它想象成一个侦探，会在整个房间里搜寻线索，而不是只盯着入口。

举个例子：

import re

text = "apple banana orange"
pattern = r"banana"

# re.match() 尝试从开头匹配 "banana"
match_m = re.match(pattern, text)
print(f"re.match() 结果: {match_m}") # 输出: re.match() 结果: None (因为开头是 "apple")

# re.search() 在整个字符串中查找 "banana"
match_s = re.search(pattern, text)
print(f"re.search() 结果: {match_s.group(0) if match_s else None}") # 输出: re.search() 结果: banana

登录后复制

所以，当你明确知道你的模式应该从字符串的起始位置开始时，使用

re.match()

登录后复制

。这通常用于验证整个字符串是否符合某种格式，比如验证一个URL或者一个完整的身份证号。而当你需要在字符串的任何位置查找某个模式时，

re.search()

登录后复制

才是正确的选择。选择错误可能导致匹配失败，或者更糟糕的是，让你误以为没有匹配项。

如何处理复杂的匹配模式：非贪婪匹配与分组捕获？

正则表达式的魅力在于其处理复杂模式的能力，而这其中，非贪婪匹配和分组捕获是两个非常实用的高级技巧。它们能让你更精确地控制匹配行为和提取所需信息。

非贪婪匹配（Non-greedy Matching）

默认情况下，正则表达式的量词（如

登录后复制

{m,n}

登录后复制

）是“贪婪的”，这意味着它们会尽可能多地匹配字符。这在某些情况下可能会导致意想不到的结果。比如，你想匹配HTML标签

<b>...</b>

登录后复制

中的内容，如果用

<b>.*</b>

登录后复制

，它可能会匹配到从第一个

<b>

登录后复制

到最后一个

</b>

登录后复制

之间的所有内容，而不是你想要的单个标签内部。

要让量词变为非贪婪，只需在量词后面加上一个

登录后复制

。

import re

html_text = "<b>这是第一段粗体</b>，然后是<b>第二段粗体</b>。"

# 贪婪匹配：会匹配从第一个<b>到最后一个</b>的所有内容
greedy_match = re.search(r'<b>.*</b>', html_text)
print(f"贪婪匹配: {greedy_match.group(0)}")
# 结果: 贪婪匹配: <b>这是第一段粗体</b>，然后是<b>第二段粗体</b>。

# 非贪婪匹配：只匹配到最近的</b>
non_greedy_match = re.search(r'<b>.*?</b>', html_text)
print(f"非贪婪匹配: {non_greedy_match.group(0)}")
# 结果: 非贪婪匹配: <b>这是第一段粗体</b>

登录后复制

非贪婪匹配在解析XML、HTML或任何具有明确起始和结束标记的结构化文本时尤其重要，它能确保你每次只捕获到最小的、符合预期的片段。

一键职达

AI全自动批量代投简历软件，自动浏览招聘网站从海量职位中用AI匹配职位并完成投递的全自动操作，真正实现'一键职达'的便捷体验。

查看详情

分组捕获（Grouping Capture）

当你不仅想知道是否有匹配，还想提取匹配中的特定部分时，分组捕获就派上用场了。通过使用圆括号

()

登录后复制

，你可以将正则表达式的一部分定义为一个捕获组。每个捕获组都会按其在模式中出现的顺序被编号（从1开始）。

import re

log_entry = "ERROR: 2023-10-27 10:30:15 - 文件 'data.txt' 访问失败。"
# 捕获错误级别、日期、时间、文件名
pattern = r'(ERROR|WARNING|INFO): (\d{4}-\d{2}-\d{2}) (\d{2}:\d{2}:\d{2}) - 文件 \'(.*?)\' 访问失败。'

match = re.search(pattern, log_entry)
if match:
    error_level = match.group(1) # 第一个捕获组
    date = match.group(2)        # 第二个捕获组
    time = match.group(3)        # 第三个捕获组
    filename = match.group(4)    # 第四个捕获组 (非贪婪匹配文件名)

    print(f"错误级别: {error_level}") # 结果: 错误级别: ERROR
    print(f"日期: {date}")           # 结果: 日期: 2023-10-27
    print(f"时间: {time}")           # 结果: 时间: 10:30:15
    print(f"文件名: {filename}")     # 结果: 文件名: data.txt

    # 也可以通过 .groups() 获取所有捕获组的元组
    print(f"所有捕获组: {match.groups()}")
    # 结果: 所有捕获组: ('ERROR', '2023-10-27', '10:30:15', 'data.txt')

登录后复制

分组捕获不仅能帮你提取数据，还可以用于回溯引用（

\1

登录后复制

\2

登录后复制

等），在模式内部引用之前捕获到的内容，这在查找重复字符或结构时非常有用。例如，

r'(\w+)\s+\1'

登录后复制

可以匹配“word word”这样的重复单词。

使用re模块时，有哪些常见的陷阱和性能优化建议？

尽管

re

登录后复制

模块功能强大，但在实际使用中，也存在一些常见的陷阱和值得注意的性能优化点。我个人在处理大量文本数据时，就曾因为这些细节而导致程序效率低下，甚至出现意料之外的匹配结果。

常见陷阱：

忘记使用原始字符串（Raw String
```
r''
```
登录后复制
）: 正则表达式中包含大量的反斜杠
```
\
```
登录后复制
，它们在Python字符串中本身就是转义字符。例如，
```
\n
```
登录后复制
表示换行，
```
\t
```
登录后复制
表示制表符。如果你的正则表达式中也包含
```
\n
```
登录后复制
或
```
\t
```
登录后复制
，Python会先将其解释为特殊字符，而不是正则表达式中的字面量。使用
```
r"..."
```
登录后复制
格式的原始字符串可以避免这种双重转义的困扰，让Python直接将反斜杠传递给
```
re
```
登录后复制
模块处理。这是一个非常基础但又极易被忽视的细节。
```
# 错误示例：\b在Python字符串中被解释为退格符
# print(re.search('\bword\b', 'a word b')) # 可能会报错或行为异常

# 正确示例：使用原始字符串
print(re.search(r'\bword\b', 'a word b').group(0)) # 输出: word
```
登录后复制
贪婪匹配的误解: 前面已经提到了，默认的贪婪匹配行为可能会导致匹配范围超出预期。尤其是在处理HTML/XML等结构化文本时，如果忘记使用非贪婪模式
```
?
```
登录后复制
，很容易匹配到比你想要的大得多的字符串。

点号

登录后复制

的误用: 正则表达式中的点号

登录后复制

匹配除了换行符

\n

登录后复制

之外的任何字符。如果你想匹配包括换行符在内的所有字符，需要结合

re.DOTALL

登录后复制

（或

re.S

登录后复制

）标志。

import re
text_with_newline = "Hello\nWorld"
# 默认情况下，. 不匹配换行符
match_default = re.search(r'Hello.World', text_with_newline)
print(f"默认匹配: {match_default}") # 输出: None

# 使用 re.DOTALL 标志，. 匹配所有字符，包括换行符
match_dotall = re.search(r'Hello.World', text_with_newline, re.DOTALL)
print(f"DOTALL匹配: {match_dotall.group(0)}") # 输出: Hello\nWorld

登录后复制

复杂的正则表达式导致的回溯失控（Catastrophic Backtracking）: 当正则表达式过于复杂，包含多个嵌套的量词，并且输入字符串中存在大量可能导致部分匹配失败的模式时，正则表达式引擎可能会陷入指数级的回溯尝试，导致匹配过程变得极其缓慢，甚至“卡死”。这通常发生在类似
```
^(a+)+b$
```
登录后复制
匹配
```
aaaaaaaaac
```
登录后复制
这样的字符串时。避免这种模式，尽量简化正则表达式，或者使用更精确的量词和原子组（atomic groups，Python的
```
re
```
登录后复制
模块不支持，但可以通过其他方式模拟或优化）。

性能优化建议：

预编译正则表达式（

re.compile()

登录后复制

）: 这是最直接也最有效的优化手段。如果你的程序中会多次使用同一个正则表达式进行匹配操作，那么在第一次使用前将其编译成一个正则表达式对象，后续直接使用这个对象进行操作，可以避免每次都重新解析正则表达式的开销。对于大型应用或处理大量数据的情况，这种优化是必须的。

import re
import time

# 不使用编译
start_time = time.time()
for _ in range(100000):
    re.search(r'\d{3}-\d{4}-\d{4}', "我的电话是 138-1234-5678。")
print(f"不编译耗时: {time.time() - start_time:.4f}s")

# 使用编译
compiled_pattern = re.compile(r'\d{3}-\d{4}-\d{4}')
start_time = time.time()
for _ in range(100000):
    compiled_pattern.search("我的电话是 138-1234-5678。")
print(f"编译后耗时: {time.time() - start_time:.4f}s")
# 通常会看到编译后的耗时明显更短

登录后复制

尽可能精确地匹配: 宽泛的模式，如
```
.*
```
登录后复制
，往往会给正则表达式引擎带来更多的回溯可能性。尽量使用更具体的字符集（如
```
\d
```
登录后复制
代替
```
[0-9]
```
登录后复制
，
```
\w
```
登录后复制
代替
```
[a-zA-Z0-9_]
```
登录后复制
），或者更精确的量词，可以减少不必要的匹配尝试。
利用字符串方法预处理: 在某些简单场景下，如果仅仅是查找固定子串或者以固定前缀/后缀开头，Python的内置字符串方法（如
```
str.find()
```
登录后复制
,
```
str.startswith()
```
登录后复制
,
```
str.endswith()
```
登录后复制
,
```
str.replace()
```
登录后复制
）通常比正则表达式更快。只有当需要模式匹配的灵活性时，才考虑使用
```
re
```
登录后复制
模块。
限制匹配范围: 如果你知道目标模式只会出现在字符串的某个特定部分，可以先用字符串切片等方式缩小搜索范围，再应用正则表达式。
避免不必要的捕获组: 如果你只是想对一部分内容进行分组（例如使用
```
|
```
登录后复制
进行或操作），但不需要捕获它的值，可以使用非捕获组
```
(?:...)
```
登录后复制
。这可以稍微减少
```
re
```
登录后复制
模块在内部处理匹配结果时的开销。
```
# 捕获组
match_cap = re.search(r'(abc|xyz)def', 'abcdef')
print(f"捕获组: {match_cap.groups()}") # 输出: ('abc',)

# 非捕获组
match_non_cap = re.search(r'(?:abc|xyz)def', 'abcdef')
print(f"非捕获组: {match_non_cap.groups()}") # 输出: ()
```
登录后复制