Python正则表达式怎么用？文本匹配技巧-Python教程-PHP中文网

python正则表达式通过re模块实现文本匹配与处理，1.常用函数包括re.search()查找首个匹配、re.match()从开头匹配、re.findall()获取所有匹配、re.sub()替换匹配内容、re.compile()预编译模式提升效率；2.核心语法涵盖通配符、量词、字符集、分组、转义等，支持复杂模式构建；3.高级技巧包括贪婪与非贪婪控制、分组捕获与非捕获、匹配标志应用如忽略大小写和多行模式；4.性能优化需预编译正则、避免灾难性回溯；5.常见陷阱涉及原始字符串缺失、match与search混淆、字符集内元字符误解；6.适用场景为模式匹配、结构化数据提取、动态替换等复杂文本处理，而简单操作优先使用字符串方法。

Python正则表达式怎么用？文本匹配技巧

Python的正则表达式，说白了，就是一套用来描述和匹配字符串模式的强大工具。它通过一套特殊的字符序列（也就是“正则模式”）来查找、替换或提取文本中符合特定规则的内容。在Python里，我们主要通过内置的

re

登录后复制

模块来使用它，这玩意儿在处理各种文本数据时简直是利器。

解决方案

要用好Python的正则表达式，核心在于理解

re

登录后复制

模块提供的几个关键函数和基本的正则语法。

首先，你需要导入

re

登录后复制

模块：

import re

登录后复制

。

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

最常用的几个函数：

```
re.search(pattern, string, flags=0)
```
登录后复制
: 这个函数会在整个字符串中查找第一个匹配
```
pattern
```
登录后复制
的位置。如果找到，返回一个匹配对象（Match object），否则返回
```
None
```
登录后复制
。它只会返回第一个匹配结果，如果你想找所有的，就得循环或者用
```
findall
```
登录后复制
。
```
text = "我的电话是138-0000-1234，工作电话是010-87654321。"
# 查找手机号
match = re.search(r'\d{3}-\d{4}-\d{4}', text)
if match:
    print(f"找到手机号: {match.group()}") # 输出：找到手机号: 138-0000-1234
```
登录后复制

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

登录后复制

: 和

search

登录后复制

类似，但

match

登录后复制

只从字符串的开头进行匹配。如果模式不在字符串的起始位置，它就找不到。

text1 = "Hello World"
text2 = "World Hello"
print(re.match(r'Hello', text1)) # <re.Match object; span=(0, 5), match='Hello'>
print(re.match(r'Hello', text2)) # None

登录后复制

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

登录后复制

: 这个函数会找到字符串中所有不重叠的

pattern

登录后复制

匹配，并以列表的形式返回所有匹配的字符串。

text = "电子邮件地址有：test@example.com 和 info@domain.org。"
emails = re.findall(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b', text)
print(f"找到的邮箱: {emails}")
# 输出：找到的邮箱: ['test@example.com', 'info@domain.org']

登录后复制

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

登录后复制

: 替换字符串中所有匹配

pattern

登录后复制

的部分为

repl

登录后复制

。

count

登录后复制

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

text = "我喜欢苹果，也喜欢香蕉，还喜欢苹果。"
new_text = re.sub(r'苹果', '橘子', text)
print(f"替换后: {new_text}") # 输出：替换后: 我喜欢橘子，也喜欢香蕉，还喜欢橘子。

登录后复制

re.compile(pattern, flags=0)

登录后复制

: 当你需要多次使用同一个正则表达式模式时，用

re.compile()

登录后复制

预编译它会更高效。它返回一个正则表达式对象，然后你可以在这个对象上调用

search

登录后复制

、

findall

登录后复制

等方法。

phone_pattern = re.compile(r'\d{3}-\d{4}-\d{4}')
text1 = "我的电话是138-0000-1234。"
text2 = "联系方式是139-1111-2222。"
print(phone_pattern.search(text1).group())
print(phone_pattern.search(text2).group())

登录后复制

一些常用的正则语法元素：

.
登录后复制
: 匹配除换行符以外的任意字符。
*``**: 匹配前一个字符零次或多次。
+
登录后复制
: 匹配前一个字符一次或多次。
?
登录后复制
: 匹配前一个字符零次或一次（也用于非贪婪匹配）。
[]
登录后复制
: 字符集，匹配方括号内的任意一个字符。例如
```
[abc]
```
登录后复制
匹配 'a', 'b', 或 'c'。
```
[0-9]
```
登录后复制
匹配任意数字。
()
登录后复制
: 分组，可以用来捕获匹配的内容，或者对多个字符应用量词。
|
登录后复制
: 或，匹配左右两边的任意一个模式。例如
```
cat|dog
```
登录后复制
匹配 'cat' 或 'dog'。
^
登录后复制
: 匹配字符串的开始。
$
登录后复制
: 匹配字符串的结束。
\
登录后复制
: 转义字符，用于匹配特殊字符本身，例如
```
\.
```
登录后复制
匹配点号。
\d
登录后复制
: 匹配任意数字（等同于
```
[0-9]
```
登录后复制
）。
\w
登录后复制
: 匹配字母、数字或下划线（等同于
```
[A-Za-z0-9_]
```
登录后复制
）。
\s
登录后复制
: 匹配任意空白字符（空格、制表符、换行符等）。
\b
登录后复制
: 匹配单词边界。

记住，在Python中使用正则表达式时，最好使用原始字符串（raw string），即在字符串前加

登录后复制

，例如

r'\d+'

登录后复制

。这样可以避免反斜杠被Python解释器误认为是转义字符，导致不必要的麻烦。

Python正则表达式在处理文本数据时有哪些高级应用技巧？

说实话，高级技巧这东西，很多时候就是把基础元素玩出花来。我个人觉得，真正能提升你正则功力的，除了熟练运用基本语法，就是理解一些更微妙的概念和功能了。

一个很有用的概念是贪婪与非贪婪匹配。默认情况下，量词（如

登录后复制

{m,n}

登录后复制

）都是“贪婪”的，它们会尽可能多地匹配字符。但有时候我们希望它尽可能少地匹配，这时就可以在量词后面加上一个问号

登录后复制

，使其变为“非贪婪”模式。

比如，你想从

<p>这是一个段落</p><p>这是另一个段落</p>

登录后复制

中只提取第一个

<p>...</p>

登录后复制

。如果用

r'<p>.*</p>'

登录后复制

，它会匹配到

这是一个段落</p><p>这是另一个段落</p>

登录后复制

，因为

.*

登录后复制

会一直匹配到最后一个

</p>

登录后复制

。但如果用

r'<p>.*?</p>'

登录后复制

，

.*?

登录后复制

就会非贪婪地匹配到第一个

</p>

登录后复制

处，这样就能正确地提取出

这是一个段落</p>

登录后复制

。这个小小的

登录后复制

真是解决了不少头疼的问题。

另一个我觉得挺实用的是分组与捕获。用括号

()

登录后复制

创建的分组，不仅可以对一部分模式应用量词，还能捕获匹配到的内容。你可以通过匹配对象的

group(index)

登录后复制

方法来获取这些捕获到的子字符串。比如，从日期字符串 "2023-10-26" 中分别提取年、月、日：

date_str = "2023-10-26"
match = re.search(r'(\d{4})-(\d{2})-(\d{2})', date_str)
if match:
    year = match.group(1) # 2023
    month = match.group(2) # 10
    day = match.group(3) # 26
    print(f"年: {year}, 月: {month}, 日: {day}")

登录后复制

有时候你只想分组，但不想捕获内容，可以使用非捕获分组

(?:...)

登录后复制

。这在构建复杂模式时很有用，可以避免创建不必要的捕获组，提升一点点性能，主要是让你的匹配对象更干净。

还有就是正则表达式的标志（Flags）。

re

登录后复制

模块提供了一些标志，可以改变匹配的行为。比如：

```
re.IGNORECASE
```
登录后复制
或
```
re.I
```
登录后复制
: 忽略大小写。
```
re.MULTILINE
```
登录后复制
或
```
re.M
```
登录后复制
: 让
```
^
```
登录后复制
和
```
$
```
登录后复制
不仅匹配字符串的开始/结束，还匹配每一行的开始/结束（在多行模式下）。
```
re.DOTALL
```
登录后复制
或
```
re.S
```
登录后复制
: 让
```
.
```
登录后复制
匹配包括换行符在内的所有字符。这在处理跨越多行的文本块时特别有用。

text_multiline = "第一行\n第二行"
# 默认情况下，. 不匹配换行符
print(re.search(r'.+', text_multiline).group()) # 第一行
# 使用 re.DOTALL，. 匹配换行符
print(re.search(r'.+', text_multiline, re.DOTALL).group()) # 第一行\n第二行

登录后复制

这些高级应用，其实就是对基本概念的灵活组合和对细节的把握。我发现很多人一开始会觉得这些概念有点绕，但一旦理解了，文本处理能力会提升一大截，能解决很多以前觉得无从下手的问题。

一键职达

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

查看详情

Python正则表达式性能优化与常见陷阱有哪些？

谈到性能和陷阱，这真是个老生常谈但又不得不提的话题。我记得有一次，一个简单的正则就让程序卡死了好几秒，后来才发现是贪婪匹配惹的祸。

性能优化方面：

一个很重要的点是预编译正则表达式。如果你需要在一个程序中多次使用同一个正则表达式模式，强烈建议使用

re.compile()

登录后复制

。

# 不推荐，每次调用都会重新编译
for _ in range(10000):
    re.search(r'\d+', 'abc123def')

# 推荐，只编译一次
compiled_pattern = re.compile(r'\d+')
for _ in range(10000):
    compiled_pattern.search('abc123def')

登录后复制

虽然对于简单的模式和少量操作，差异不明显，但在处理大量文本或复杂模式时，性能提升是显而易见的。

另一个需要注意的，是避免“灾难性回溯”（Catastrophic Backtracking）。这通常发生在模式中包含嵌套的量词，并且这些量词可以匹配空字符串或者重叠匹配时。比如

(a+)+

登录后复制

或者

(a|aa)+

登录后复制

这样的模式。当输入字符串不匹配时，正则表达式引擎会尝试所有可能的匹配路径，导致指数级的回溯，从而使程序变得非常慢，甚至看起来像死机了一样。解决办法通常是：

使用非贪婪匹配 (
```
*?
```
登录后复制
,
```
+?
```
登录后复制
)。
优化模式，使其更精确，减少不必要的重复匹配。
避免过度嵌套的重复组。
如果可能，考虑使用更简单的字符串方法或者分步匹配。

常见陷阱：

忘记使用原始字符串（Raw Strings）：前面提过，
```
r''
```
登录后复制
可以避免反斜杠的转义问题。如果你写
```
'\n'
```
登录后复制
，Python会把它解释成换行符，而不是匹配字母 'n' 的字面量。写成
```
r'\n'
```
登录后复制
才是匹配反斜杠和字母 'n'。这个小细节经常让人犯错。
```
re.match()
```
登录后复制
与
re.search()
登录后复制
的混淆：我见过不少人，明明想在整个字符串中查找，却误用了
```
re.match()
```
登录后复制
，结果发现总是返回
```
None
```
登录后复制
。记住，
```
match
```
登录后复制
只看开头，
```
search
```
登录后复制
才是全局扫描。
贪婪与非贪婪的误解：这绝对是初学者最常踩的坑。我上面已经详细解释了，这里就不再赘述了。但记住，当你发现匹配结果比你预期的长时，多半就是贪婪匹配在作祟。
字符集
```
[]
```
登录后复制
内的特殊字符：在
```
[]
```
登录后复制
内部，很多元字符（如
```
.
```
登录后复制
,
```
*
```
登录后复制
,
```
+
```
登录后复制
,
```
?
```
登录后复制
,
```
|
```
登录后复制
,
```
(
```
登录后复制
,
```
)
```
登录后复制
,
```
{
```
登录后复制
,
```
^
```
登录后复制
,
```
$
```
登录后复制
）会失去它们的特殊含义，被当作普通字符处理。但
```
\
```
登录后复制
和
```
]
```
登录后复制
仍然需要转义（除非
```
]
```
登录后复制
是第一个字符）。例如，要匹配
```
[foo]
```
登录后复制
，你得写
```
r'\[foo\]'
```
登录后复制
。而
```
[.
```
登录后复制
匹配的是字面量点号。
编码问题：当处理非ASCII字符（比如中文）时，确保你的字符串和正则表达式模式的编码是一致的。Python 3 默认处理Unicode字符串，通常问题不大，但如果你从文件读取数据，或者涉及到不同编码的系统交互，就得注意了。

总的来说，写正则就像写代码，需要测试和调试。当结果不符预期时，不要急着改代码，先仔细检查你的正则表达式，甚至可以利用在线的正则测试工具来逐步调试。

Python中什么时候该用正则表达式，什么时候用普通的字符串方法？

这是一个非常实用的问题，我个人在实际工作中也经常面临这样的选择。我的经验是，如果一个任务能用简单的字符串方法解决，就尽量不用正则。 正则虽然强大，但它的可读性确实比普通字符串方法差一些，而且写起来也更容易出错。

什么时候应该用普通的字符串方法？

简单的查找和替换：如果你只是想查找一个固定的子字符串是否存在，或者用一个固定的字符串替换另一个固定的字符串，那么
```
in
```
登录后复制
运算符、
```
str.find()
```
登录后复制
,
```
str.index()
```
登录后复制
,
```
str.replace()
```
登录后复制
这些方法就足够了，而且它们通常更快。
```
text = "Hello World"
if "World" in text: # 简单的查找
    print("Found World")
new_text = text.replace("World", "Python") # 简单的替换
```
登录后复制
判断字符串开头或结尾：
```
str.startswith()
```
登录后复制
和
```
str.endswith()
```
登录后复制
比用
```
^
```
登录后复制
和
```
$
```
登录后复制
的正则表达式更直观、更高效。
```
filename = "report.txt"
if filename.endswith(".txt"):
    print("这是一个文本文件")
```
登录后复制
简单的分割字符串：如果你的分隔符是固定的，
```
str.split()
```
登录后复制
是首选。
```
data = "apple,banana,orange"
fruits = data.split(',')
```
登录后复制
大小写转换、去除空白等：
```
str.lower()
```
登录后复制
,
```
str.upper()
```
登录后复制
,
```
str.strip()
```
登录后复制
等方法功能单一且高效。

什么时候应该用正则表达式？

模式匹配：当你需要查找的不是一个固定的字符串，而是一种“模式”时，正则表达式是不可替代的。比如查找所有符合邮箱格式的字符串、所有电话号码、所有日期格式等。
```
# 查找所有形如 "YYYY-MM-DD" 的日期
text = "项目启动日期是2023-10-26，截止日期是2024-01-15。"
dates = re.findall(r'\d{4}-\d{2}-\d{2}', text)
```
登录后复制
复杂的字符串验证：验证用户输入是否符合特定格式（如密码强度、URL格式、身份证号等），正则表达式能提供简洁而强大的表达能力。
基于模式的替换：当你需要替换的内容不是固定的，而是根据匹配到的模式来动态生成时，
```
re.sub()
```
登录后复制
结合分组捕获非常强大。
```
# 将 "姓 名" 格式改为 "名 姓"
name = "张 三"
new_name = re.sub(r'(\S+)\s+(\S+)', r'\2 \1', name) # \1 \2 引用捕获组
print(new_name) # 三 张
```
登录后复制
从非结构化文本中提取结构化数据：比如从日志文件、网页HTML、配置文件中提取特定信息。这通常是正则表达式大显身手的地方。