引言

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

使用指南

导入模块

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

import re

基本语法

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

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

字符类

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

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

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

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

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

   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']
   

4. 通配符匹配：.

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

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

   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']
   

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

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

7. 匹配所有数字: \d

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

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

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

9. 匹配所有空白字符: \s

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

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

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

11. 匹配特殊字符：\ 在正则表达式中，反斜杠\是转义字符，因此需要使用双反斜杠\\ 来匹配实际的反斜杠字符，使用\.来表示.，使用\+来表示+，等字符

    text = r"This is a path: C:\\Users\\Name\\Documents and \\Settings"
    # 匹配所有反斜杠
    result = re.findall(r"\\", text)
    print(result)  # 输出: ['\\', '\\', '\\', '\\', '\\']
    

锚点

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

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

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

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

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

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

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

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

量词与分支

1. 匹配一个或多个：+

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

2. 匹配零个或多个：*

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

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

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

4. 匹配可选: ?

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

5. 分支条件: |

   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函数，若正则表达式中有分组()，则只返回分组中内容
   

标志

1. 忽略大小写：re.I

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

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

   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']
   

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

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

组和引用

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

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

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

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

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

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

   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) # 抛错
   

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

   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 分组，要求结束标签与开始标签名称一致
   

零宽断言

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

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

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

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

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

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

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

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

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

贪婪模式与非贪婪模式

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

贪婪模式

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

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

非贪婪模式

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

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 对象

示例：

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

示例：

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

示例：

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

示例：

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 等

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

示例：

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 等

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

示例：

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 对象

示例：

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 等

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

示例：

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 等

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

示例：

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

re.escape(pattern)

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

• pattern：要进行转义的字符串

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

示例：

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

核心对象

Match对象

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

属性:

• string：原始输入字符串

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

• pos：匹配的起始位置（相对于原字符串的偏移量）

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

• endpos：匹配的结束位置（相对于原字符串的偏移量），结束是指最后一个匹配字符的后一位

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

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

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

• lastindex：返回最后一个捕获组的索引（数字表示）

  match = re.match(r"(\d+)-(\d+)", "123-456")
  print(match.lastindex) # 输出: 2
  

方法：

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

  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])：返回匹配的起始位置，如果指定了组号，返回该组匹配的起始位置

  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])：回匹配的结束位置，如果指定了组号，返回该组匹配的结束位置，结束是指最后一个匹配字符的后一位

  match = re.match(r"(\d+)-(\d+)", "123-456")
  print(match.end(1))  # 输出: 3 (组 1 匹配的结束位置)
  print(match.end()) # 输出：7
  

• span([group])：返回匹配的(start, end)位置元组，表示匹配的起始和结束位置，结束是指最后一个匹配字符的后一位

  match = re.match(r"(\d+)-(\d+)", "123-456")
  print(match.span(2)) # 输出: (4, 7)
  

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

  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 表示引用命名分组或捕获组

  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）

  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：返回模式中捕获组的数量（即括号()的个数），非捕获组 (?:...) 不会计入捕获组数

  pattern = re.compile(r"(a)(b(c))")
  print(pattern.groups) # 输出: 3 (对应: a, b, c)
  

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

  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：返回原始的正则表达式字符串

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

方法：

• search(string[, pos[, endpos]])：在字符串中搜索==第一个==匹配的子字符串，返回一个 Match 对象；如果没有匹配，返回 None
  • 参数：
    • string：要匹配的目标字符串
    • pos：开始搜索的位置，默认为 0
    • endpos：结束搜索的位置，默认为字符串的长度

  pattern = re.compile(r"\d+")
  match = pattern.search("abc123xyz456")
  print(match.group()) # 输出: 123
  

• match(string[, pos[, endpos]])：从字符串的==开头==匹配，如果匹配成功，返回一个 Match 对象，否则返回 None
  • 参数：
    • string：要匹配的目标字符串
    • pos：开始搜索的位置，默认为 0
    • endpos：结束搜索的位置，默认为字符串的长度

  pattern = re.compile(r"\d+")
  match = pattern.match("123abc")
  print(match.group()) # 输出: 123
  

• fullmatch(string[, pos[, endpos]])： 尝试将整个字符串与正则模式==完全匹配==，匹配成功则返回 Match 对象；否则返回 None
  • 参数：
    • string：要匹配的目标字符串
    • pos：开始搜索的位置，默认为 0
    • endpos：结束搜索的位置，默认为字符串的长度

  pattern = re.compile(r"\d+")
  match = pattern.fullmatch("123")
  print(match.group()) # 输出: 123
  

• split(string, maxsplit=0)：使用正则表达式的匹配结果分割字符串，返回一个列表
  • 参数：
    • string：要匹配的目标字符串
    • maxsplit：最大分割次数，默认为 0 表示分割所有可能的位置

  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：结束搜索的位置，默认为字符串的长度

  pattern = re.compile(r"\d+")
  result = pattern.findall("abc123xyz456")
  print(result) # 输出: ['123', '456']
  

• finditer(string[, pos[, endpos]])：类似于 findall()，但返回的是一个==迭代器==，每个元素是一个 match 对象
  • 参数：
    • string：要匹配的目标字符串
    • pos：开始搜索的位置，默认为 0
    • endpos：结束搜索的位置，默认为字符串的长度

  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 表示替换所有匹配项

  pattern = re.compile(r"\d+")
  result = pattern.sub("0", "abc123xyz456")
  print(result)  # 输出: abc0xyz0
  

• subn(repl, string, count=0)：与sub()类似，但返回的是一个元组 (替换后的字符串, 替换次数)
  • 参数：
    • repl：替换的内容，可以是字符串或函数
    • string：目标字符串
    • count：替换次数，默认为 0 表示替换所有匹配项

  pattern = re.compile(r"\d+")
  result = pattern.sub("0", "abc123xyz456")
  print(result)  # 输出: ("abc0xyz0", 2)
  

小结

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

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

码字不易，求赞求收藏！