python怎么使用正则表达式匹配内容_python正则表达式使用指南

穿越時空

发布时间：2025-09-14 20:15:01

825人浏览过

来源于php中文网

原创

Python通过re模块实现正则表达式，核心是编写模式字符串并使用search、match、findall、sub等函数进行查找、匹配、提取和替换操作。

python怎么使用正则表达式匹配内容_python正则表达式使用指南

Python使用正则表达式主要通过内置的

re

模块来实现，它提供了一系列函数，让你能够定义复杂的文本匹配模式，并在字符串中查找、替换或提取符合这些模式的内容。核心思想是先写一个描述目标文本结构的“模式字符串”，然后用

re

模块的函数去处理你想要分析的文本。

解决方案

在Python里玩转正则表达式，我的经验是，首先得把

re

模块请进来。这就像你要盖房子，得先有工具箱。

import re

然后，我们就可以开始干活了。最常用的几个工具大概是这样的：

re.search(pattern, string)

: 这个函数会扫描整个字符串，找到第一个匹配

pattern

的位置。如果找到了，它会返回一个

Match

对象；如果没找到，就返回

None

。我个人觉得，这是日常使用频率最高的函数之一，因为很多时候我只需要知道“有没有”或者“第一个是什么”。

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

text = "我的电话是138-0013-8000，紧急联系人电话是13912345678。"
pattern = r"\d{3}-\d{4}-\d{4}" # 匹配手机号格式，r前缀表示这是一个原始字符串，避免反斜杠的转义问题
match = re.search(pattern, text)

if match:
    print(f"找到了第一个电话号码: {match.group(0)}") # group(0)返回整个匹配到的字符串
    # 输出: 找到了第一个电话号码: 138-0013-8000
else:
    print("没找到符合格式的电话号码。")

re.match(pattern, string)

: 和

search

有点像，但它有个严格的规定：只从字符串的开头进行匹配。如果模式不在字符串开头，即使后面有匹配项，

Match

也会返回

None

。这在处理固定格式的字符串开头时特别有用，比如我经常用它来验证文件名的前缀。

text_start = "Hello World!"
text_middle = "Say Hello World!"
pattern_hello = r"Hello"

match_start = re.match(pattern_hello, text_start)
match_middle = re.match(pattern_hello, text_middle)

if match_start:
    print(f"从开头匹配到: {match_start.group(0)}") # 输出: 从开头匹配到: Hello
else:
    print("开头未匹配到。")

if match_middle:
    print(f"从开头匹配到: {match_middle.group(0)}")
else:
    print("开头未匹配到。") # 输出: 开头未匹配到。

re.findall(pattern, string)

: 如果你需要找出字符串中所有不重叠的匹配项，

findall

就是你的不二之选。它会返回一个包含所有匹配字符串的列表。我发现它在从日志文件或网页内容中批量提取信息时特别好用。

text_all_numbers = "商品A价格12.5元，商品B价格99.99元，商品C价格3元。"
pattern_price = r"\d+\.?\d*" # 匹配整数或小数
all_prices = re.findall(pattern_price, text_all_numbers)
print(f"所有价格: {all_prices}") # 输出: 所有价格: ['12.5', '99.99', '3']

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

: 这个函数用来替换字符串中匹配

pattern

的部分。

repl

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

count

参数可以限制替换的次数。我经常用它来清洗数据，比如把多余的空格替换掉，或者把一些敏感信息脱敏。

text_clean = "你好  世界！  这是一个   测试。"
pattern_spaces = r"\s+" # 匹配一个或多个空格
cleaned_text = re.sub(pattern_spaces, " ", text_clean)
print(f"清理后的文本: {cleaned_text}") # 输出: 清理后的文本: 你好 世界！ 这是一个 测试。

理解这几个基本函数，并掌握如何构建模式字符串，你就已经迈出了Python正则表达式的第一步。

Python正则表达式中常用的匹配模式有哪些？

说实话，正则表达式的“模式”才是它真正强大且让人又爱又恨的地方。刚开始学的时候，我常常被那些符号搞得头晕眼花，但一旦掌握了，你会发现它们能解决很多看似复杂的文本处理问题。这里我把我日常最常用的一些模式总结一下：

基本字符匹配:
- ```
.
```
  (点): 匹配除了换行符
```
\n
```
  之外的任意一个字符。这玩意儿简直是万能牌，但用的时候得小心，因为它可能匹配到你不想匹配的东西。
- ```
\d
```
  : 匹配任意一个数字（0-9）。我的密码验证、电话号码提取都离不开它。
- ```
\d
```
  : 匹配任意一个非数字字符。
- ```
\w
```
  : 匹配任意一个字母、数字或下划线（[a-zA-Z0-9_]）。处理变量名、单词时很方便。
- ```
\w
```
  : 匹配任意一个非字母、数字、下划线字符。
- ```
\s
```
  : 匹配任意一个空白字符（空格、制表符、换行符等）。文本清洗时，它和
```
+
```
  组合起来是神器。
- ```
\s
```
  : 匹配任意一个非空白字符。
数量词（Quantifiers）: 这些是用来指定前面那个字符或组要出现多少次的。
- ```
*
```
  : 匹配零次或多次。比如
```
a*
```
  能匹配
```
""
```
  ,
```
a
```
  ,
```
aa
```
  ,
```
aaa
```
  ...
- ```
+
```
  : 匹配一次或多次。
```
a+
```
  能匹配
```
a
```
  ,
```
aa
```
  ,
```
aaa
```
  ...但不能匹配
```
""
```
  。
- ```
?
```
  : 匹配零次或一次。
```
colou?r
```
  可以匹配
```
color
```
  或
```
colour
```
  。
- ```
{n}
```
  : 匹配恰好n次。
```
\d{4}
```
  匹配四位数字。
- ```
{n,}
```
  : 匹配至少n次。
```
\d{3,}
```
  匹配三位或更多位数字。
- ```
{n,m}
```
  : 匹配n到m次。
```
\d{3,5}
```
  匹配三到五位数字。
边界匹配:
- ```
^
```
  : 匹配字符串的开头。
- ```
$
```
  : 匹配字符串的结尾。
- ```
\b
```
  : 匹配单词边界。比如
```
\bcat\b
```
  只会匹配独立的单词"cat"，而不会匹配"category"中的"cat"。这在精确匹配单词时非常有用。
- ```
\b
```
  : 匹配非单词边界。
字符集:
- ```
[abc]
```
  : 匹配方括号中的任意一个字符。比如
```
[aeiou]
```
  匹配任意一个元音字母。
- ```
[a-z]
```
  : 匹配指定范围内的字符。
```
[0-9]
```
  等同于
```
\d
```
  。
- ```
[^abc]
```
  : 匹配不在方括号中的任意一个字符。
```
[^0-9]
```
  等同于
```
\d
```
  。
分组与捕获:
- ```
(pattern)
```
  : 用小括号括起来的部分形成一个捕获组。这不仅能让你把一组模式当作一个整体来应用数量词（比如
```
(ab)+
```
  ），还能让你在
```
Match
```
  对象中单独提取这个组匹配到的内容（通过
```
match.group(1)
```
  、
```
match.group(2)
```
  等）。我个人觉得，分组是正则表达式进阶的必经之路，数据提取全靠它了。
- ```
(?:pattern)
```
  : 非捕获组。它也把模式当作一个整体，但不会捕获匹配到的内容，所以不会占用
```
group()
```
  的索引。当你只想分组而不关心捕获时，用这个可以提升一点点性能，也让代码更清晰。
选择符:
- ```
|
```
  : 或。
```
cat|dog
```
  可以匹配"cat"或"dog"。
转义:
- ```
\
```
  (反斜杠): 如果你的模式中需要匹配正则表达式的特殊字符本身（比如
```
.
```
  ,
```
*
```
  ,
```
?
```
  ,
```
+
```
  ,
```
(
```
  ,
```
)
```
  ,
```
[
```
  ,
```
]
```
  ,
```
{
```
  ,
```
}
```
  ,
```
^
```
  ,
```
$
```
  ,
```
|
```
  ,
```
\
```
  ），你就需要在它们前面加上反斜杠进行转义。比如要匹配一个点号，你得写
```
\.
```
  。

构建这些模式的时候，我通常会先在心里模拟一下，或者直接用一些在线的正则表达式测试工具（比如regex101.com）来验证我的模式是不是真的能匹配到我想要的东西。

Whimsical

Whimsical推出的AI思维导图工具

下载

在Python中处理正则表达式匹配结果时有哪些技巧和注意事项？

匹配到了结果，怎么用好它，这也有不少学问。我这里分享一些我常用的技巧和踩过的一些坑。

Match对象的妙用: 当

re.search()

或

re.match()

找到匹配时，它们返回的是一个

Match

对象。这个对象可不只是告诉你“有”或“没有”那么简单，它包含了匹配的所有细节：

```
match.group(0)
```
: 返回整个匹配到的字符串。这是最常用的。
```
match.group(1)
```
,
```
match.group(2)
```
...: 返回对应捕获组匹配到的字符串。如果你有多个捕获组，它们会按从左到右的顺序编号。
```
match.groups()
```
: 返回一个包含所有捕获组内容的元组。
```
match.start()
```
: 返回匹配开始的索引。
```
match.end()
```
: 返回匹配结束的索引（不包含）。
```
match.span()
```
: 返回一个元组
```
(start, end)
```
。利用这些，你可以精确地知道匹配到的内容是什么，在哪里。

text = "联系电话是: (010)1234-5678"
pattern = r"\((\d{3})\)(\d{4}-\d{4})" # 两个捕获组，一个用于区号，一个用于号码
match = re.search(pattern, text)

if match:
    print(f"完整匹配: {match.group(0)}") # 输出: (010)1234-5678
    print(f"区号: {match.group(1)}")   # 输出: 010
    print(f"号码: {match.group(2)}")   # 输出: 1234-5678
    print(f"所有分组: {match.groups()}") # 输出: ('010', '1234-5678')
    print(f"匹配位置: {match.span()}")  # 输出: (7, 22)

贪婪与非贪婪匹配: 这是个经典陷阱！默认情况下，正则表达式的数量词（
```
*
```
,
```
+
```
,
```
?
```
,
```
{n,m}
```
）都是“贪婪”的，它们会尽可能多地匹配字符。但有时候，你可能只想要最短的匹配。这时，你可以在数量词后面加上一个
```
?
```
，让它变成“非贪婪”模式。
```
html_text = "标题1
内容
标题2"
greedy_pattern = r".*" # 贪婪模式
non_greedy_pattern = r".*?" # 非贪婪模式

greedy_match = re.search(greedy_pattern, html_text)
if greedy_match:
    print(f"贪婪匹配: {greedy_match.group(0)}") # 输出: 标题1
内容
标题2

non_greedy_match = re.search(non_greedy_pattern, html_text)
if non_greedy_match:
    print(f"非贪婪匹配: {non_greedy_match.group(0)}") # 输出: 标题1
```
你看，一个
```
?
```
的区别，结果大相径庭。我刚开始用的时候就经常被这个坑到，以为
```
.*
```
就能匹配一个标签，结果把整个HTML都吞了。
编译正则表达式: 如果你需要在程序中多次使用同一个正则表达式模式，那么使用
```
re.compile()
```
来编译它是一个非常好的习惯。它会把模式编译成一个
```
RegexObject
```
对象，这样在后续使用时就不用每次都重新编译了，能提升一点性能。对于短脚本可能不明显，但对于处理大量文本或在循环中频繁使用正则的场景，编译带来的好处是实实在在的。
```
phone_pattern = re.compile(r"(\d{3})-(\d{4})-(\d{4})")
text_list = ["电话: 139-1234-5678", "座机: 010-8765-4321"]

for text in text_list:
    match = phone_pattern.search(text)
    if match:
        print(f"找到号码: {match.group(0)}")
```
匹配标志（Flags）:
```
re
```
模块提供了一些标志，可以改变正则表达式的匹配行为。这些标志可以作为函数的第三个参数传入，或者在编译时传入。
- ```
re.IGNORECASE
```
  (或
```
re.I
```
  ): 忽略大小写。
- ```
re.DOTALL
```
  (或
```
re.S
```
  ): 让
```
.
```
  （点号）也能匹配换行符
```
\n
```
  。默认情况下
```
.
```
  是不匹配换行符的。
- ```
re.MULTILINE
```
  (或
```
re.M
```
  ): 改变
```
^
```
  和
```
$
```
  的行为。在多行模式下，
```
^
```
  不仅匹配字符串开头，还匹配每一行的开头；
```
$
```
  不仅匹配字符串结尾，还匹配每一行的结尾。
```
multi_line_text = "First line\nSecond line"
pattern_dotall = r"First.*line"
match_dotall = re.search(pattern_dotall, multi_line_text, re.DOTALL)
if match_dotall:
    print(f"DOTALL匹配: '{match_dotall.group(0)}'") # 输出: 'First line\nSecond line'
```

处理无匹配情况: 永远要记得，

re.search()

和

re.match()

在没有找到匹配时会返回

None

。所以，在使用

Match

对象之前，务必进行非空判断，否则直接访问

match.group()

会抛出

AttributeError

。这是我个人写代码时最常犯的低级错误之一，因为有时候我太自信我的模式了，哈哈。

no_match_text = "没有数字"
pattern_digit = r"\d+"
match_obj = re.search(pattern_digit, no_match_text)

if match_obj: # 良好的编程习惯
    print(f"找到了: {match_obj.group(0)}")
else:
    print("什么也没找到。")

掌握这些技巧，能让你在处理匹配结果时更加得心应手，避免一些不必要的错误。

Python正则表达式在实际开发中能解决哪些具体问题？

正则表达式在实际开发中简直是文本处理的瑞士军刀，用途非常广泛。我个人在很多场景下都依赖它，从最简单的文本清理到复杂的数据提取。

数据验证: 这是我用得最多的场景之一。
- 邮箱地址验证: 虽然完全符合RFC标准的邮箱正则非常复杂，但一个简单的模式（比如
```
r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$"
```
  ）就能过滤掉大部分不合法的输入。
- 手机号码验证: 针对不同国家的手机号格式，编写相应的正则进行验证。比如中国大陆的11位手机号（
```
r"^1[3-9]\d{9}$"
```
  ）。
- URL验证: 确保用户输入的链接格式正确。
- 密码强度检查: 检查密码是否包含大小写字母、数字、特殊字符，以及是否达到最小长度。