Python re模块用法详解学习py正则表达式看这一篇就够了超详细

引言

python 内置正则表达式模块 re 提供了一个功能强大且高度灵活的工具集，使得正则表达式的使用变得更加高效和直观，本文包含了大部分使用re时会使用的功能，同时提供使用用例

使用指南

导入模块

在 Python 中，使用正则表达式功能前需要先导入 re 模块：

python 复制代码

import re

基本语法

python使用 r"正则表达式" 来将字符串定义为模式串，用以匹配字符串，使用下方语法创建模式串

字符类
锚点
量词与分支
标志
组和引用
零宽断言

字符类

匹配集合中的任意*字符: [abc]

python 复制代码

text = "bar ber bir bor bur"
result = re.findall(r"b[eo]r", text)
print(result) # 输出 ['ber', 'bor']

匹配不在集合中的任意字符：[^abc]

python 复制代码

text = "bar ber bir bor bur"
result = re.findall(r"b[^eo]r", text)
print(result) # 输出 ['bar', 'bir', 'bur']

匹配范围：[a-z] 能够匹配a-z的26字母，除此之外还有0-9，A-Z等

python 复制代码

text = "bar ber bir bor bur"
result = re.findall(r"b[a-z]r", text)
print(result) # 输出 ['bar', 'ber', 'bur']

text = "abcdefghijklmnopqrstuvwxyz"
result = re.findall(r"[e-i]", text)
print(result) # 输出 ['e', 'f', 'g', 'h', 'i']

通配符匹配：.

python 复制代码

result = re.findall(r".", "hi012_-!?") 
print(result) # 输出: ['h', 'i', '0', '1', '2', '_', '-', '!', '?']

匹配字母、数字或下划线: \w

python 复制代码

text = "hi012_-!? foo_bar123" 
result = re.findall(r"\w", text) 
print(result) # 输出: ['h', 'i', '0', '1', '2', 'f', 'o', 'o', 'b', 'a', 'r', '1', '2', '3']

匹配除字母、数字和下划线之外的任意字符: \W

python 复制代码

text = "hi012_-!? foo_bar123" 
result = re.findall(r"\w", text) 
print(result) # 输出: ['-', '-', '!', '?', ' ']

匹配所有数字: \d

python 复制代码

text = "Call 123-456-7890!" 
result = re.findall(r"\D", text) 
print(result) # 输出: ['1', '2', '3', '4', '5', '6', '7', '8', '9', '0']

匹配除数字外的任意字符 \D

python 复制代码

text = "Call 123-456-7890!" 
result = re.findall(r"\D", text) 
print(result) # 输出: ['C', 'a', 'l', 'l', ' ', '-', '-', '!']

匹配所有空白字符: \s

python 复制代码

text = "Hello World!\nThis is a test." 
result = re.findall(r"\s", text) print(result) # 输出: [' ', '\n', ' ', ' ', ' ']

匹配除空白字符以外的任意字符: \S

python 复制代码

text = "Hello World!\n" 
result = re.findall(r"\S", text) 
print(result) # 输出: ['H', 'e', 'l', 'l', 'o', 'W', 'o', 'r', 'l', 'd', '!']

匹配特殊字符：\ 在正则表达式中，反斜杠\是转义字符，因此需要使用双反斜杠\\ 来匹配实际的反斜杠字符，使用\.来表示.，使用\+来表示+，等字符
python 复制代码
```
text = r"This is a path: C:\\Users\\Name\\Documents and \\Settings"
# 匹配所有反斜杠
result = re.findall(r"\\", text)
print(result)  # 输出: ['\\', '\\', '\\', '\\', '\\']
```

锚点

匹配字符串或行的开头: ^

python 复制代码

text = "an answer or a question"  
result = re.findall(r"^\w+", text)
print(result)  # 输出: ['an']

匹配字符串或行的结尾: $

python 复制代码

text = "an answer or a question"
result = re.findall(r"\w+$", text)
print(result)  # 输出: ['question']

匹配单词的开头或结尾: \b

python 复制代码

text = "an answer or a question"
result = re.findall(r"n\b", text)
print(result)  # 输出: ['n', 'n']
# 这里匹配的是位于单词结尾的n 匹配的是an和question

匹配不在单词开头或末尾的位置：\B

python 复制代码

text = "an answer or a question"
result = re.findall(r"n\B", text)
print(result)  # 输出: ['n']
# 这里匹配的是不在单词结尾的n 匹配的是answer

量词与分支

匹配一个或多个：+

python 复制代码

text = "bp bep beep beeep"
result = re.findall(r"be+p", text)
print(result) # 输出: ['bep', 'beep', 'beeep']

匹配零个或多个：*

python 复制代码

text = "bp bep beep beeep"
result = re.findall(r"be*p", text)
print(result) # 输出: ['bp', 'bep', 'beep', 'beeep']

匹配指定范围：{n, m}

python 复制代码

text = "bp bep beep beeep"
result = re.findall(r"be{1,2}p", text)
print(result) # 输出: ['bep', 'beep']

匹配可选: ?

python 复制代码

text = "color colour colr"
result = re.findall(r"colou?r", text)
print(result) # 输出: ['color', 'colour']

分支条件: |

python 复制代码

text = "fat cat rat"
result = re.findall(r"cat|rat", text)
print(result) # 输出: ['cat', 'rat']

# 可以与()结合使用
text = "Error 404: Page not found. Error 500: Internal server error." 
pattern = 
result = re.findall(r"Error (404|500)", text) 
# 匹配 "Error 404" 或 "Error 500" 
print(result) # 输出: ['404', '500']
# 使用findall函数，若正则表达式中有分组()，则只返回分组中内容

标志

忽略大小写：re.I

python 复制代码

text = "CaT cat cAt"
result = re.findall(r"cat", text, flags=re.I)
print(result)  # 输出: ['CaT', cat, cAt]

多行模式：re.M 主要针对^ 和 $，添加后可以匹配到每一行的行头和行尾，否则只能匹配到整个字符串的开头和末尾

python 复制代码

multiline_text = "cat\ncat\ncat"

result = re.findall(r"^cat", multiline_text)
print(result) # 输出: ['cat']

result = re.findall(r"^cat", multiline_text, flags=re.M)
print(result)  # 输出: ['cat', 'cat', 'cat']

添加注释：re.X 可以使用"""和#为自己写的正则表达式添加注释

python 复制代码

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
# 这两者的效果相等

组和引用

如果在findall中使用分组，只会返回匹配成功后分组内的内容

使用括号分组：() 用于将正则表达式的一部分组合在一起，方便后续应用量词或提取数据

python 复制代码

text = "hahaha hah haha" 
# 匹配重复的 "ha" 
result = re.findall(r"(ha)+", text) 
# 匹配到 hahaha ha haha
print(result) # 输出: ['ha', 'ha', 'ha']

引用表达式的分组: \1, \2, ... \1 引用第一个分组，\2 引用第二个分组，依此类推

python 复制代码

text = "hah haa dad" 
# 匹配模式是 "某字符 + a + 相同字符" 
result = re.findall(r"(\w)a\1", text)
# 匹配到 haa dad
print(result) # 输出: ['h', 'd']

创建无法引用的分组: (?: ) (?: ) 表示一个非捕获分组，不会存储匹配内容

python 复制代码

text = "hahaha hah haha" 
# 匹配 "ha" 多次，但不捕获分组内容
result = re.findall(r"(?:ha)+", text) 
print(result) # 输出: ['hahaha', 'ha', 'haha']
# 使用正常分组的结果：['ha', 'ha', 'ha']

text = "hah haa dad"
re.findall(r"(?:\w)a\1", text) # 抛错

分组命名：(?P<name>...)

python 复制代码

text = "apple=apple banana=orange grape=grape"
result = re.findall(r"(?P<word>\w+)=(?P=word)", text)
print(result) # 输出：['apple', 'grape']
# (?P<word>\w+) 定义了一个名为 word 的分组，匹配一个单词
# (?P=word) 引用了分组 word 的内容，要求后面的部分与前面的单词一致

# 验证HTML标签的正确配对
pattern = r"<(?P<tag>\w+)>.*?</(?P=tag)>"
text = "<div>content</div> <p>text</p> <div>another</p>"
result = re.findall(pattern, text)
print(result) # 输出：[('div',), ('p',)]
# (?P<tag>\w+) 定义了一个名为 tag 的分组，用来匹配 HTML 标签名称
# </(?P=tag)> 引用了 tag 分组，要求结束标签与开始标签名称一致

零宽断言

零宽断言匹配的是位置，而不是字符

正向前瞻: (?=...) 匹配满足某条件的前一个字符或位置。

python 复制代码

text = "1st 2nd 3pc"
# 匹配数字后面跟着 "nd" 的情况
result = re.findall(r"\d(?=nd)", text)
print(result)  # 输出: ['2']

负向前瞻: (?!...) 匹配不满足某条件的前一个字符或位置

python 复制代码

text = "1st 2nd 3pc"
# 匹配数字后面不是 "nd" 的情况
result = re.findall(r"\d(?!nd)", text)
print(result)  # 输出: ['1', '3']

正向后瞻: (?<=...) 匹配满足某条件的后一个字符或位置

python 复制代码

text = "#1 $2 %3"
# 匹配 "前面是 %" 的数字
result = re.findall(r"(?<=%)\d", text)
print(result)  # 输出: ['3']

负向后瞻: (?<!...) 匹配不满足某条件的后一个字符或位置

python 复制代码

text = "#1 $2 %3"
# 匹配 "前面不是 %" 的数字
result = re.findall(r"(?<!%)\d", text)
print(result)  # 输出: ['1', '2']

贪婪模式与非贪婪模式

python默认就是贪婪模式，在量词后添加?可以变成非贪婪模式

贪婪模式

* 、+会尽量多地匹配字符，直到无法再匹配为止

python 复制代码

text = "<h1>Title</h1><p>Paragraph</p>"
# 贪婪模式：匹配整个 HTML 标签内容
result = re.search(r'<.*>', text)
print(result.group())  # 输出: <h1>Title</h1><p>Paragraph</p>

非贪婪模式

*?、+?会尽量少地匹配字符，通常在满足匹配条件时就停止

python 复制代码

text = "<h1>Title</h1><p>Paragraph</p>"
# 非贪婪模式：只匹配第一个 HTML 标签内容
result = re.search(r'<.*?>', text)
print(result.group())  # 输出: <h1>

核心函数

re.compile(pattern, flags=0)

作用：将正则表达式模式串编译成一个正则表达式对象，后续可以多次使用，提高匹配效率参数：

pattern：字符串类型，正则表达式模式串
flags（可选）：匹配模式，通常是 re.M，re.I 等

返回：返回一个 Pattern 对象

示例：

python 复制代码

pattern = re.compile(r"\d{3}-\d{2}-\d{4}")
result = pattern.match("123-45-6789")
print(result.group())  # 输出: 123-45-6789

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

作用：扫描整个字符串，查找第一个匹配正则表达式的子串，返回一个匹配对象 match，如果没有找到匹配，返回 None 参数：

pattern ：字符串类型，正则表达式模式串
string：要进行匹配的目标字符串
flags（可选）：匹配模式，通常是 re.M，re.I 等

返回：返回一个 Match 对象，或者如果没有找到匹配，返回 None

示例：

python 复制代码

result = re.search(r"\d{3}-\d{2}-\d{4}", "My number is 123-45-6789")
if result:
    print(result.group())  # 输出: 123-45-6789

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

作用：尝试从字符串的开头开始匹配，如果开头的部分匹配正则表达式，则返回一个匹配对象。如果匹配失败，则返回 None 参数：

pattern：字符串类型，正则表达式模式串
string：要进行匹配的目标字符串
flags（可选）：匹配模式，通常是 re.M，re.I 等

返回：返回一个 Match 对象，或者如果没有匹配，返回 None

示例：

python 复制代码

result = re.match(r"\d{3}-\d{2}-\d{4}", "123-45-6789")
if result:
    print(result.group())  # 输出: 123-45-6789

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

作用：如果整个字符串完全匹配正则表达式，则返回匹配对象。如果只有部分匹配，则返回 None 参数：

pattern：字符串类型，正则表达式模式串
string：要进行匹配的目标字符串
flags（可选）：匹配模式，通常是 re.M，re.I 等

返回：返回一个 Match 对象，或者如果没有匹配，返回 None

示例：

python 复制代码

result = re.fullmatch(r"\d{3}-\d{2}-\d{4}", "123-45-6789")
if result:
    print(result.group())  # 输出: 123-45-6789

result = re.fullmatch(r"\d{3}-\d{2}-\d{4}", "123-45-678910")
print(result)  # 输出: None

re.split(pattern, string, maxsplit=0, flags=0)

作用：根据正则表达式匹配的分隔符分割字符串，返回一个列表参数：

pattern：字符串类型，正则表达式模式串
string：要进行匹配的目标字符串
maxsplit（可选）：最大分割次数。如果指定了 maxsplit，则只进行 maxsplit 次分割
flags（可选）：匹配模式，通常是 re.M，re.I 等

返回：返回一个列表，包含分割后的子串

示例：

python 复制代码

result = re.split(r"\s+", "This is a test string")
print(result)  # 输出: ['This', 'is', 'a', 'test', 'string']

result = re.split(r'\W+', 'Words, words, words.', maxsplit=1)
print(result) #输出：['Words', 'words, words.']

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

作用：返回所有匹配项的列表，每个匹配项是一个字符串，如果有捕获组，则返回捕获组内容参数：

pattern：字符串类型，正则表达式模式串
string：要进行匹配的目标字符串
flags（可选）：匹配模式，通常是 re.M，re.I 等

返回：返回一个列表，包含所有匹配的子串

示例：

python 复制代码

result = re.findall(r"\d+", "123 abc 456 def 789")
print(result)  # 输出: ['123', '456', '789']

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

作用：类似于 findall()，但返回的是一个迭代器，每个元素是一个 match 对象，可以获取匹配的具体信息（如位置）参数：

pattern：字符串类型，正则表达式模式串
string：要进行匹配的目标字符串
flags（可选）：匹配模式，通常是 re.M，re.I 等

返回：返回一个迭代器，迭代每个匹配的 Match 对象

示例：

python 复制代码

text = "abc123def456ghi789"
matches = re.finditer(r"\d+", text)

for match in matches:
    print(f"Matched: {match.group()}, Start: {match.start()}, End: {match.end()}")
    # 输出：
    # Matched: 123, Start: 3, End: 6
	# Matched: 456, Start: 9, End: 12
	# Matched: 789, Start: 15, End: 18

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

作用：用指定的替换字符串替换正则表达式匹配的所有部分，返回替换后的字符串参数：

pattern：字符串类型，正则表达式模式串
repl：用于替换的字符串
string：要进行匹配的目标字符串
count（可选）：替换的最大次数，默认替换所有匹配项
flags（可选）：匹配模式，通常是 re.M，re.I 等

返回：返回替换后的字符串

示例：

python 复制代码

result = re.sub(r"\d+", "X", "123 abc 456 def 789")
print(result)  # 输出: X abc X def X

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

作用：与sub()类似，但返回的是一个元组 (替换后的字符串, 替换次数) 参数：

pattern：字符串类型，正则表达式模式串
repl：用于替换的字符串
string：要进行匹配的目标字符串
count（可选）：替换的最大次数，默认替换所有匹配项
flags（可选）：匹配模式，通常是 re.M，re.I 等

返回：返回一个元组，包含替换后的字符串和替换的次数

示例：

python 复制代码

result = re.subn(r"\d+", "X", "123 abc 456 def 789")
print(result)  # 输出: ('X abc X def X', 3)

re.escape(pattern)

作用：对字符串中的特殊字符进行转义，使它们能够作为普通字符使用，返回转义后的字符串参数：

pattern：要进行转义的字符串

返回：返回转义后的字符串

示例：

python 复制代码

result = re.escape("Hello. How are you?")
print(result)  # 输出: Hello\. How are you\?

核心对象

Match对象

Match 对象通常由 re.match(), re.search(), re.finditer()等函数返回

属性:

string ：原始输入字符串

python 复制代码

match = re.match(r"(\d+)-(\d+)", "123-456-234")
print(match.group()) # 输出：123-456
print(match.string) # 输出：123-456-234

pos ：匹配的起始位置（相对于原字符串的偏移量）
python 复制代码
```
match = re.match(r"(\d+)-(\d+)", "123-456-234")
print(match.pos) # 输出：0
```
endpos ：匹配的结束位置（相对于原字符串的偏移量），结束是指最后一个匹配字符的后一位
python 复制代码
```
match = re.match(r"(\d+)-(\d+)", "123-456-234")
print(match.endpos) # 输出：11
```

lastgroup ：返回最后一个捕获组的名称（如果有命名组）

python 复制代码

match = re.match(r"(?P<first>\d+)-(?P<second>\d+)", "123-456")
# 命名第一个分组为first，第二个分组为second
print(match.lastgroup) # 输出: second

lastindex ：返回最后一个捕获组的索引（数字表示）
python 复制代码
```
match = re.match(r"(\d+)-(\d+)", "123-456")
print(match.lastindex) # 输出: 2
```

方法：

group([group1, ...]) ：返回匹配的子字符串或多个子字符串，如果没有指定参数，返回整个匹配内容，如果指定了参数，返回指定组的内容

python 复制代码

match = re.match(r"(\d+)-(\d+)", "123-456")  
# 不使用分组也能输出
print(match.group()) # 输出: '123-456'
# 使用分组后才能输出，否则会报错
print(match.group(1)) # 输出: '123'
print(match.group(2)) # 输出: '456'

start([group]) ：返回匹配的起始位置，如果指定了组号，返回该组匹配的起始位置

python 复制代码

match = re.match(r"(\d+)-(\d+)", "abc-123-456")
print(match.start(1)) # 输出: 0 (组 1 匹配的开始位置)

match = re.search(r"(\d+)-(\d+)", "abc-123-456")
print(match.start(1)) # 输出：4

end([group]) ：回匹配的结束位置，如果指定了组号，返回该组匹配的结束位置，结束是指最后一个匹配字符的后一位
python 复制代码
```
match = re.match(r"(\d+)-(\d+)", "123-456")
print(match.end(1))  # 输出: 3 (组 1 匹配的结束位置)
print(match.end()) # 输出：7
```
span([group]) ：返回匹配的(start, end)位置元组，表示匹配的起始和结束位置，结束是指最后一个匹配字符的后一位
python 复制代码
```
match = re.match(r"(\d+)-(\d+)", "123-456")
print(match.span(2)) # 输出: (4, 7)
```

groupdict(default=None) ：返回一个字典，其中键为命名的分组名，值为分组匹配到的内容，如果某个命名分组没有匹配内容，则返回 default 参数的值

python 复制代码

text = "2024-12-23"
pattern = r"(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})"
print(match.groupdict()) # 输出：{'year': '2024', 'month': '12', 'day': '23'}

pattern = r"(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})-?(?P<time>\d{2}:\d{2})?"
match = re.match(pattern, text)
print(match.groupdict(default="N/A")) # 输出: {'year': '2024', 'month': '12', 'day': '23', 'time': 'N/A'}

expand(template) ：使用指定的模板格式化匹配结果，模板中的 \g<name> 或 \number 表示引用命名分组或捕获组

python 复制代码

pattern = r"(?P<area_code>\d{3})-(?P<number>\d{7})"
text = "123-4567890"

# 引用命名分组
match = re.match(pattern, text)
print(match.expand(r"(\g<area_code>) \g<number>"))  # 输出: (123) 4567890

# 引用分组编号
match = re.match(r"(\d{3})-(\d{7})", text)
print(match.expand(r"(\1) \2"))  # 输出: (123) 4567890

Pattern对象

Pattern 对象是通过 re.compile() 编译正则表达式后得到的对象，它代表了一个正则表达式的预编译版本，可以重复使用，以提高性能

属性:

flags ：返回用于编译正则表达式时所用的标志（flags）

python 复制代码

pattern = re.compile(r"(?i)hello", re.M)
print(pattern.flags) # 输出: 42
print(pattern.flags & re.MULTILINE) # 输出：re.MULTILINE
print(pattern.flags & re.S) # 输出：re.NOFLAG

groups ：返回模式中捕获组的数量（即括号()的个数），非捕获组 (?:...) 不会计入捕获组数
python 复制代码
```
pattern = re.compile(r"(a)(b(c))")
print(pattern.groups) # 输出: 3 (对应: a, b, c)
```

groupindex ：返回一个字典，映射命名分组的名称到对应的分组编号，如果没有使用命名分组，则返回空字典

python 复制代码

pattern = re.compile(r"(?P<first>a)(?P<second>b)")
print(pattern.groupindex) # 输出: {'first': 1, 'second': 2}

pattern = re.compile(r"(a)(b)")
print(pattern.groupindex) # 输出: {}

pattern ：返回原始的正则表达式字符串

python 复制代码

pattern = re.compile(r"hello\d+")
print(pattern.pattern) # 输出: hello\d+

方法：

search(string[, pos[, endpos]]) ：在字符串中搜索==第一个==匹配的子字符串，返回一个 Match 对象；如果没有匹配，返回 None
- 参数：
  - string：要匹配的目标字符串
  - pos：开始搜索的位置，默认为 0
  - endpos：结束搜索的位置，默认为字符串的长度
python 复制代码
```
pattern = re.compile(r"\d+")
match = pattern.search("abc123xyz456")
print(match.group()) # 输出: 123
```
match(string[, pos[, endpos]]) ：从字符串的==开头==匹配，如果匹配成功，返回一个 Match 对象，否则返回 None
- 参数：
  - string：要匹配的目标字符串
  - pos：开始搜索的位置，默认为 0
  - endpos：结束搜索的位置，默认为字符串的长度
python 复制代码
```
pattern = re.compile(r"\d+")
match = pattern.match("123abc")
print(match.group()) # 输出: 123
```
fullmatch(string[, pos[, endpos]]) ：尝试将整个字符串与正则模式==完全匹配==，匹配成功则返回 Match 对象；否则返回 None
- 参数：
  - string：要匹配的目标字符串
  - pos：开始搜索的位置，默认为 0
  - endpos：结束搜索的位置，默认为字符串的长度
python 复制代码
```
pattern = re.compile(r"\d+")
match = pattern.fullmatch("123")
print(match.group()) # 输出: 123
```
split(string, maxsplit=0) ：使用正则表达式的匹配结果分割字符串，返回一个列表
- 参数：
  - string：要匹配的目标字符串
  - maxsplit：最大分割次数，默认为 0 表示分割所有可能的位置
py 复制代码
```
pattern = re.compile(r"\s+")
result = pattern.split("a b  c   d")
print(result) # 输出: ['a', 'b', 'c', 'd']
```
findall(string[, pos[, endpos]]) ：返回所有匹配项的列表，每个匹配项是一个字符串；如果有捕获组，则返回捕获组内容
- 参数：
  - string：要匹配的目标字符串
  - pos：开始搜索的位置，默认为 0
  - endpos：结束搜索的位置，默认为字符串的长度
py 复制代码
```
pattern = re.compile(r"\d+")
result = pattern.findall("abc123xyz456")
print(result) # 输出: ['123', '456']
```
finditer(string[, pos[, endpos]]) ：类似于 findall()，但返回的是一个==迭代器==，每个元素是一个 match 对象
- 参数：
  - string：要匹配的目标字符串
  - pos：开始搜索的位置，默认为 0
  - endpos：结束搜索的位置，默认为字符串的长度
py 复制代码
```
pattern = re.compile(r"\d+")
for match in pattern.finditer("abc123xyz456"):
	print(match.group())
    # 输出:
	# 123
	# 456
```
sub(repl, string, count=0) ：用指定的替换字符串替换正则表达式匹配的所有部分，返回替换后的字符串
- 参数：
  - repl：替换的内容，可以是字符串或函数
  - string：目标字符串
  - count：替换次数，默认为 0 表示替换所有匹配项
py 复制代码
```
pattern = re.compile(r"\d+")
result = pattern.sub("0", "abc123xyz456")
print(result)  # 输出: abc0xyz0
```
subn(repl, string, count=0) ：与sub()类似，但返回的是一个元组 (替换后的字符串, 替换次数)
- 参数：
  - repl：替换的内容，可以是字符串或函数
  - string：目标字符串
  - count：替换次数，默认为 0 表示替换所有匹配项
py 复制代码
```
pattern = re.compile(r"\d+")
result = pattern.sub("0", "abc123xyz456")
print(result)  # 输出: ("abc0xyz0", 2)
```

小结

本指南从基础到进阶，详细介绍了 re 模块的核心功能，并通过丰富的示例帮助您掌握其应用技巧，希望本文能够为深入学习正则表达式的读者提供启发，同时也为初学者实践打下坚实的基础

最后，学习regex推荐一个网站：RegexLearn，零基础学习正则表达式，特别适合短时间系统学习正则表达式

码字不易，求赞求收藏！

Python re模块 用法详解 学习py正则表达式看这一篇就够了 超详细

引言

使用指南

导入模块

基本语法

字符类

锚点

量词与分支

标志

组和引用

零宽断言

贪婪模式与非贪婪模式

贪婪模式

非贪婪模式

核心函数

re.compile(pattern, flags=0)

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

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

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

re.split(pattern, string, maxsplit=0, flags=0)

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

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

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

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

re.escape(pattern)

核心对象

Match对象

Pattern对象

小结

Python re模块用法详解学习py正则表达式看这一篇就够了超详细