当前位置：首页 > 文章列表 > 文章 > python教程 > Python正则表达式使用详解

Python正则表达式使用详解

2025-07-03 08:38:12 0浏览收藏

在文章实战开发的过程中，我们经常会遇到一些这样那样的问题，然后要卡好半天，等问题解决了才发现原来一些细节知识点还是没有掌握好。今天golang学习网就整理分享《Python正则表达式使用全攻略》，聊聊，希望可以帮助到正在努力赚钱的你。

Python中正则表达式主要通过re模块实现，用于字符串的模式匹配与查找替换等操作。1.re.compile()可预编译正则表达式以提高效率；2.re.search()查找第一个匹配项；3.re.match()仅从字符串开头匹配；4.re.findall()返回所有匹配项列表；5.re.finditer()返回匹配迭代器；6.re.sub()用于替换匹配子串；7.re.split()按模式分割字符串。特殊字符如. ^ $ * + ?等用于定义复杂模式，分组用()捕获匹配内容，flags参数控制匹配行为（如忽略大小写、多行模式等），编写高效正则包括预编译、避免过度通配、使用非捕获分组等技巧，应用场景涵盖数据验证、提取、清洗、日志分析、代码生成及网络爬虫。

Python中怎样使用正则表达式？re模块完整指南

正则表达式在Python中，主要通过re模块来实现，用于进行字符串的模式匹配和查找替换等操作。简单来说，就是你给Python一个“规则”，让它帮你找符合这个规则的文本。

解决方案

Python的re模块提供了一系列函数，方便你使用正则表达式。以下是一些常用的函数及其使用方法：

re.compile(pattern, flags=0): 编译正则表达式模式，返回一个正则表达式对象。预编译可以提高效率，特别是当同一个模式需要多次使用时。
```
import re

pattern = re.compile(r'\d+')  # 匹配一个或多个数字
result = pattern.findall('12 drummers drumming, 11 pipers piping, 10 lords a-leaping')
print(result)  # 输出: ['12', '11', '10']
```
这里，r'\d+' 是一个原始字符串，表示一个或多个数字。re.compile() 将这个模式编译成一个正则表达式对象，然后就可以用这个对象进行查找了。
re.search(pattern, string, flags=0): 在字符串中查找匹配正则表达式模式的第一个位置，如果找到匹配，则返回一个Match对象。否则，返回None。
```
import re

result = re.search(r'hello', 'hello world')
if result:
    print(result.group(0))  # 输出: hello
```
result.group(0) 返回匹配的整个字符串。

re.match(pattern, string, flags=0): 尝试从字符串的起始位置匹配正则表达式模式，如果匹配成功，则返回一个Match对象。否则，返回None。注意，re.match() 只从字符串的开头开始匹配。

import re

result = re.match(r'hello', 'hello world')
if result:
    print(result.group(0))  # 输出: hello

result = re.match(r'world', 'hello world')
if result:
    print(result.group(0)) # 这行不会执行，因为'world'不在字符串的开头
else:
    print("No match at the beginning") # 输出: No match at the beginning

re.findall(pattern, string, flags=0): 在字符串中查找所有匹配正则表达式模式的非重叠字符串，并以列表的形式返回。
```
import re

result = re.findall(r'\d+', '12 drummers drumming, 11 pipers piping, 10 lords a-leaping')
print(result)  # 输出: ['12', '11', '10']
```
re.finditer(pattern, string, flags=0): 在字符串中查找所有匹配正则表达式模式的非重叠字符串，并以迭代器的形式返回。迭代器中的每个元素都是一个Match对象。
```
import re

result = re.finditer(r'\d+', '12 drummers drumming, 11 pipers piping, 10 lords a-leaping')
for match in result:
    print(match.group(0)) # 依次输出: 12, 11, 10
```
re.sub(pattern, repl, string, count=0, flags=0): 在字符串中查找匹配正则表达式模式的所有子串，并将其替换为repl。count 指定最多替换的次数，默认为 0，表示替换所有匹配项。
```
import re

new_string = re.sub(r'\d+', 'X', '12 drummers drumming, 11 pipers piping, 10 lords a-leaping')
print(new_string)  # 输出: X drummers drumming, X pipers piping, X lords a-leaping
```
re.split(pattern, string, maxsplit=0, flags=0): 根据正则表达式模式分割字符串，返回一个列表。maxsplit 指定最多分割的次数，默认为 0，表示分割所有匹配项。
```
import re

result = re.split(r',\s*', '12 drummers drumming, 11 pipers piping, 10 lords a-leaping')
print(result)  # 输出: ['12 drummers drumming', '11 pipers piping', '10 lords a-leaping']
```

Python正则表达式中的特殊字符有哪些？

正则表达式之所以强大，很大程度上是因为它可以使用一些特殊字符来表示复杂的模式。这些特殊字符也被称为元字符。下面是一些常见的元字符：

. (点号): 匹配除了换行符以外的任意单个字符。
^ (脱字符): 匹配字符串的开头。
$ (美元符): 匹配字符串的结尾。
* (星号): 匹配前一个字符 0 次或多次。
+ (加号): 匹配前一个字符 1 次或多次。
? (问号): 匹配前一个字符 0 次或 1 次。
{m,n}: 匹配前一个字符至少 m 次，但不超过 n 次。
[] (字符集): 匹配方括号中的任意一个字符。例如，[abc] 匹配 'a'、'b' 或 'c'。
[^...] (否定字符集): 匹配不在方括号中的任意一个字符。例如，[^abc] 匹配除了 'a'、'b' 和 'c' 以外的任意字符。
\ (反斜杠): 用于转义特殊字符，使其失去特殊含义。例如，\. 匹配点号本身，而不是任意字符。
| (竖线): 表示“或”，匹配竖线两侧的任意一个模式。
() (分组): 用于将多个字符组合成一个单元，可以对分组应用量词，也可以捕获分组匹配的文本。

如何在Python正则表达式中使用分组和捕获？

分组和捕获是正则表达式中非常强大的功能，它们允许你将模式的一部分组合在一起，并单独提取匹配的内容。

分组: 使用圆括号 () 可以将正则表达式的一部分组合成一个分组。
捕获: 默认情况下，每个分组都会被捕获。你可以使用 Match 对象的 group() 方法来访问捕获的分组。group(0) 返回整个匹配的字符串，group(1) 返回第一个分组匹配的字符串，group(2) 返回第二个分组匹配的字符串，以此类推。

import re

pattern = re.compile(r'(\w+) (\w+)') # 匹配两个单词，并分别分组
string = 'Isaac Newton, scientist'
match = pattern.search(string)

if match:
    print("Full match:", match.group(0)) # 输出: Isaac Newton
    print("First name:", match.group(1)) # 输出: Isaac
    print("Last name:", match.group(2))  # 输出: Newton

如果你不想捕获某个分组，可以使用 (?:...)。这被称为非捕获分组。

import re

pattern = re.compile(r'(?:\w+) (\w+)') # 只捕获第二个单词
string = 'Isaac Newton, scientist'
match = pattern.search(string)

if match:
    print("Full match:", match.group(0)) # 输出: Isaac Newton
    print("Last name:", match.group(1))  # 输出: Newton
    # print("First name:", match.group(2))  # 报错，因为只有1个捕获组

Python正则表达式的flags参数有什么作用？

re 模块中的许多函数都接受一个 flags 参数，用于修改正则表达式的匹配行为。以下是一些常用的 flags：

re.IGNORECASE 或 re.I: 忽略大小写。
re.MULTILINE 或 re.M: 多行模式。在这种模式下，^ 和 $ 匹配字符串的开头和结尾，以及每一行的开头和结尾。
re.DOTALL 或 re.S: 点号匹配所有字符，包括换行符。
re.VERBOSE 或 re.X: 允许在正则表达式中使用空白字符和注释，以提高可读性。

import re

# 忽略大小写
pattern = re.compile(r'hello', re.IGNORECASE)
result = pattern.search('Hello World')
if result:
    print(result.group(0)) # 输出: Hello

# 多行模式
pattern = re.compile(r'^world', re.MULTILINE)
result = pattern.search('hello\nworld')
if result:
    print(result.group(0)) # 输出: world

# 点号匹配所有字符
pattern = re.compile(r'hello.*world', re.DOTALL)
result = pattern.search('hello\nworld')
if result:
    print(result.group(0)) # 输出: hello\nworld

# 允许使用空白字符和注释
pattern = re.compile(r"""
    hello   # 匹配 hello
    \s+     # 匹配一个或多个空白字符
    world   # 匹配 world
""", re.VERBOSE)
result = pattern.search('hello   world')
if result:
    print(result.group(0)) # 输出: hello   world

如何编写高效的Python正则表达式？

编写高效的正则表达式对于处理大量文本数据至关重要。以下是一些提高正则表达式效率的技巧：

预编译正则表达式: 使用 re.compile() 预编译正则表达式，特别是当同一个模式需要多次使用时。
使用原始字符串: 使用原始字符串 r'...' 来定义正则表达式，可以避免反斜杠转义的问题，并提高可读性。
避免过度使用通配符: 尽量使用具体的字符或字符集，而不是过度依赖通配符，例如 .。
使用非捕获分组: 如果不需要捕获分组，可以使用 (?:...) 来避免不必要的捕获。
从字符串开头匹配: 如果可能，使用 re.match() 从字符串的开头开始匹配，而不是使用 re.search() 在整个字符串中搜索。
限制回溯: 避免编写可能导致大量回溯的正则表达式。例如，避免嵌套的量词，如 (a+)*。
使用字符集: 使用字符集 [...] 来匹配一组字符，而不是使用多个 | 运算符。例如，使用 [abc] 匹配 'a'、'b' 或 'c'，而不是使用 a|b|c。
利用锚点: 使用锚点 ^ 和 $ 来限制匹配的位置，可以提高效率。