【Python基础】第18节：正则表达式

1. 正则表达式

正则表达式用于查找符合规则的字符串。正则表达式具备通用性，所以是用处最广泛的字符串匹配语法，无论是Python、Java、PHP，还是数据库语言SQL，它的语法规则是基本通用的。

比如：

'哈哈哈哈哈哈我爱你' → 匹配 '我爱你'

Python中如何使用正则表达式

1. 导入模块

1. import re  # Python标准库

1. 使用方法进行匹配

例如：match()方法

1. result = re.match('正则表达式', '目标字符串')

1. 获得匹配结果

1. print(result.group())  # 获取匹配结果

基本使用示例：

1. # 1.导入模块
2. import re
3. # 2.使用方法进行匹配操作，例如match(从开始位置往后查找匹配)
4. result = re.match(r'.*我爱你', '哈哈哈哈哈哈我爱你')
5. '''其中��
6. r'.*我爱你'：是正则表达式
7. '哈哈哈哈哈哈我爱你'：是要匹配的字符串
8. '''
9. # 3、拿到匹配的结果数据，可以通过group方法获取
10. print(result.group())

1. 匹配规则

匹配单个字符

表格：

1. .匹配任意字符（除换行符 \n）

1. import re
3. # 示例1：匹配任意字符（字母）
4. ret = re.match(".", "A")
5. print(ret.group())  # 输出: A
7. # 示例2：匹配任意字符（数字）
8. ret = re.match(".", "7")
9. print(ret.group())  # 输出: 7
11. # 示例3：匹配任意字符（符号）
12. ret = re.match(".", "$")
13. print(ret.group())  # 输出: $
15. # 示例4：无法匹配换行符
16. ret = re.match(".", "\n")  # 匹配失败
17. print(ret)  # 输出: None

2. []：匹配括号内任意一个字符

1. import re
2. # 示例1：匹配指定字符 [abc]
3. ret = re.match("[abc]", "b")  # 匹配成功
4. print(ret.group())  # 输出: b
6. # 示例2：匹配范围字符 [0-9]
7. ret = re.match("[0-9]", "5")  # 匹配数字
8. print(ret.group())  # 输出: 5
10. # 示例3：匹配混合范围 [a-zA-Z]
11. ret = re.match("[a-zA-Z]", "Z")  # 匹配大写字母
12. print(ret.group())  # 输出: Z
14. # 示例4：匹配失败
15. ret = re.match("[abc]", "d")  # 匹配失败
16. print(ret)  # 输出: None

3. \d：匹配数字（0-9）

1. import re
2. # 示例1：匹配数字
3. ret = re.match("\d", "9")  # 匹配成功
4. print(ret.group())  # 输出: 9
6. # 示例2：匹配失败（非数字）
7. ret = re.match("\d", "a")  # 匹配失败
8. print(ret)  # 输出: None

4. \D：匹配非数字

1. # 示例1：匹配字母
2. ret = re.match("\D", "A")  # 匹配成功
3. print(ret.group())  # 输出: A
5. # 示例2：匹配符号
6. ret = re.match("\D", "$")  # 匹配成功
7. print(ret.group())  # 输出: $
9. # 示例3：匹配失败（数字）
10. ret = re.match("\D", "5")  # 匹配失败
11. print(ret)  # 输出: None

5. \s：匹配空白字符（空格、\t、\n）

1. import re
2. # 示例1：匹配空格
3. ret = re.match("\s", " ")  # 匹配成功
4. print(repr(ret.group()))  # 输出: ' '
6. # 示例2：匹配制表符 `\t`
7. ret = re.match("\s", "\t")  # 匹配成功
8. print(repr(ret.group()))  # 输出: '\t'
10. # 示例3：匹配换行符 `\n`
11. ret = re.match("\s", "\n")  # 匹配成功
12. print(repr(ret.group()))  # 输出: '\n'
14. # 示例4：匹配失败（非空白）
15. ret = re.match("\s", "a")  # 匹配失败
16. print(ret)  # 输出: None

6. \S：匹配非空白字符

1. import re
2. # 示例1：匹配字母
3. ret = re.match("\S", "A")  # 匹配成功
4. print(ret.group())  # 输出: A
6. # 示例2：匹配数字
7. ret = re.match("\S", "5")  # 匹配成功
8. print(ret.group())  # 输出: 5
10. # 示例3：匹配失败（空白符）
11. ret = re.match("\S", "\t")  # 匹配失败
12. print(ret)  # 输出: None

7. \w：匹配单词字符（字母、数字、下划线、汉字）

1. import re
2. '''7. \w：匹配单词字符（字母、数字、下划线、汉字）'''
3. # 示例1：匹配字母
4. ret = re.match("\w", "a")  # 匹配成功
5. print(ret.group())  # 输出: a
7. # 示例2：匹配数字
8. ret = re.match("\w", "7")  # 匹配成功
9. print(ret.group())  # 输出: 7
11. # 示例3：匹配下划线
12. ret = re.match("\w", "_")  # 匹配成功
13. print(ret.group())  # 输出: _
15. # 示例4：匹配汉字
16. ret = re.match("\w", "周")  # 匹配成功
17. print(ret.group())  # 输出: 周

8. \W：匹配非单词字符（符号、空格等）

1. import re
2. # 示例1：匹配符号
3. ret = re.match("\W", "$")  # 匹配成功
4. print(ret.group())  # 输出: $
6. # 示例2：匹配空格
7. ret = re.match("\W", " ")  # 匹配成功
8. print(repr(ret.group()))  # 输出: ' '
10. # 示例3：匹配失败（单词字符）
11. ret = re.match("\W", "a")  # 匹配失败
12. print(ret)  # 输出: None

匹配多个字符

1. *：匹配前一个字符 0次或多次（贪婪模式）

1. import re
3. # 示例1：匹配小写字母0次或多次（允许大写后无小写）
4. ret = re.match("[A-Z][a-z]*", "M")  # 匹配成功（0次小写）
5. print(ret.group())  # 输出: M
7. # 示例2：匹配多个小写字母
8. ret = re.match("[A-Z][a-z]*", "MdueD6Ddas")  # 匹配到第一个非小写字母前
9. print(ret.group())  # 输出: Mdue
11. # 示例3：匹配数字0次或多次
12. ret = re.match("\d*", "abc")  # 匹配空字符串（0次数字）
13. print(ret.group())  # 输出: （空字符串，无报错）

2. +：匹配前一个字符 1次或多次（至少一次）

1. # 示例1：匹配小写字母至少一次
2. ret = re.match("[A-Z][a-z]+", "Hello")  # 匹配成功
3. print(ret.group())  # 输出: Hello
5. # 示例2：匹配失败（小写字母不足一次）
6. ret = re.match("[A-Z][a-z]+", "H")  # 匹配失败
7. print(ret)  # 输出: None
9. # 示例3：匹配连续数字
10. ret = re.match("\d+", "138abc")  # 匹配到第一个非数字前
11. print(ret.group())  # 输出: 138

3. ?：匹配前一个字符 0次或1次（可选匹配）

1. # 示例1：匹配可选字符（http或https）
2. ret = re.match("https?", "http")  # 匹配成功（0次s）
3. print(ret.group())  # 输出: http
5. ret = re.match("https?", "https")  # 匹配成功（1次s）
6. print(ret.group())  # 输出: https
8. # 示例2：匹配可选数字
9. ret = re.match("周周\d?", "周周")  # 匹配成功（0次数字）
10. print(ret.group())  # 输出: 周周
12. ret = re.match("周周\d?", "周周5")  # 匹配成功（1次数字）
13. print(ret.group())  # 输出: 周周5

4. {m}：精确匹配前一个字符 m次

1. # 示例1：精确匹配11位手机号
2. ret = re.match("\d{11}", "13847758302")  # 匹配成功
3. print(ret.group())  # 输出: 13847758302
5. # 示例2：匹配失败（不足m次）
6. ret = re.match("\d{3}", "12")  # 匹配失败
7. print(ret)  # 输出: None

5.{m,n}：匹配前一个字符 m到n次（贪婪模式）

1. # 示例1：匹配6~10位数字
2. ret = re.match("\d{6,10}", "1384775830245678")  # 匹配前10位
3. print(ret.group())  # 输出: 1384775830
5. # 示例2：匹配失败（不足m次）
6. ret = re.match("\d{6,10}", "13567")  # 匹配失败（仅5位）
7. print(ret)  # 输出: None

匹配开头结尾

1. ^：匹配字符串开头

强制匹配从字符串的第一个字符开始。

1. import re
3. # 示例：匹配以大写字母开头的字符串
4. text = "Hello"
5. pattern = "^[A-Z]"        # 从开头匹配大写字母
6. ret = re.match(pattern, text)
7. print(ret.group())        # 输出: H
9. # 匹配失败示例
10. text = "hello"
11. ret = re.match(pattern, text)
12. print(ret)                # 输出: None

2. $：匹配字符串结尾

\d$ 匹配结尾数字：

1. # 示例：匹配以数字结尾的字符串
2. text = "user123"
3. pattern = ".*\d$"         # 开头任意内容 + 结尾数字
4. ret = re.match(pattern, text)
5. print(ret.group())        # 输出: user123
7. # 匹配失败示例
8. text = "user123a"
9. ret = re.match(pattern, text)
10. print(ret)                # 输出: None

3. ^ 和 $ 联合使用：精确匹配整个字符串

确保字符串完全符合指定模式。

1. # 示例1：校验手机号（必须为11位纯数字）
2. ret = re.match("^\d{11}$", "13847758302")  # 匹配成功
3. print(ret.group())  # 输出: 13847758302
5. # 示例2：校验邮箱格式（简单示例）
6. email_regex = "^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$"
7. ret = re.match(email_regex, "user@example.com")  # 匹配成功
8. print(ret.group())  # 输出: user@example.com
10. # 示例3：匹配失败（字符串包含多余字符）
11. ret = re.match("^abc$", "abc123")  # 结尾不是abc
12. print(ret)  # 输出: None

4. 转义字符：匹配字面意义的 ^ 或 $

使用 \ 转义符号本身。（这里用的方法是search()，后面有对该方法的使用详解。）

1. # 示例1：匹配以 $ 开头的字符串
2. ret = re.search("^\$", "$100")  # 匹配成功
3. print(ret.group())  # 输出: $
5. # 示例2：匹配包含 ^ 的字符串
6. ret = re.search("\^", "a^b")  # 匹配成功
7. print(ret.group())  # 输出: ^

匹配分组

1. |：匹配左右任意一个表达式

用于逻辑“或”操作，通常在分组内定义多个候选模式。

1. import re
3. # 示例：匹配纯小写、纯大写或纯数字的字符串（完全匹配）
4. lyst = ['abc', 'ABC', '123', 'abc123', 'ABC123', '哈哈哈哈哈哈']
6. for text in lyst:
7.     # 正则说明：匹配纯小写 | 纯大写 | 纯数字（必须从开头到结尾）
8.     pattern = r"^([a-z]+|[A-Z]+|\d+)$"
9.     match = re.match(pattern, text)
10.     if match:
11.         print(f"'{text}' 匹配成功 → 分组内容: {match.group(1)}")
12.     else:
13.         print(f"'{text}' 匹配失败")
15. # 输出：
16. # 'abc' 匹配成功 → 分组内容: abc
17. # 'ABC' 匹配成功 → 分组内容: ABC
18. # '123' 匹配成功 → 分组内容: 123
19. # 'abc123' 匹配失败
20. # 'ABC123' 匹配失败
21. # '哈哈哈哈哈哈' 匹配失败

2. (ab) 与 \num

(ab)：创建捕获分组。将括号内内容作为一个分组，后续可通过索引提取。

\num：引用分组。通过 \1、\2 等格式引用前面分组的匹配结果（索引从 1 开始）。

1. # 示例：匹配重复的分组内容（如 "abcabc"）
2. text = "abcabc"
3. pattern = r"^([a-z]{3})\1$"  # \1 引用第一个分组（匹配 "abc" 重复一次）
4. match = re.match(pattern, text)
5. print(match.group())  # 输出: abcabc
7. # 示例：匹配重复的标签结构（如 "<html>content</html>"）
8. text = "<html>content</html>"
9. pattern = r"^<(\w+)>.*</\1>$"  # \1 引用分组1（标签名）
10. match = re.match(pattern, text)
11. print(match.group())  # 输出: <html>content</html>

3. (?P<name>) 与 (?P=name)

(?P<name>)：命名分组。为分组指定别名，通过名称提取内容（提高可读性）。

(?P=name)：引用命名分组。通过别名引用之前的分组匹配结果。

1. # 示例1：匹配 HTML 标签结构（确保标签名一致）
2. text = "<html><h1>www.baidu.com</h1></html>"
3. pattern = r"^<(?P<tag_html>html)><(?P<tag_h1>h1)>.*</(?P=tag_h1)></(?P=tag_html)>$"
4. match = re.match(pattern, text)
5. if match:
6.     print("匹配成功:", match.group())
7.     print("HTML标签名:", match.group("tag_html"))  # 输出: html
8.     print("H1标签名:", match.group("tag_h1"))     # 输出: h1
9. else:
10.     print("匹配失败")
12. # 示例2：匹配重复的字母+数字组合（如 "abc123abc123"）
13. text = "abcdef0123456789abcdef0123456789"
14. pattern = r"^(?P<letters>[a-z]+)(?P<numbers>\d+)(?P=letters)(?P=numbers)$"
15. match = re.match(pattern, text)
16. if match:
17.     print("匹配成功:", match.group())
18.     print("字母部分:", match.group("letters"))  # 输出: abcdef
19.     print("数字部分:", match.group("numbers"))  # 输出: 0123456789
20. else:
21.     print("匹配失败")

1. re模块的其它匹配用法。

上面的正则匹配规则中，多数用到的都是match方法，其实re模块中还要很多其它的方法。下面举几个常用的用法一一讲解。

1. re.match(pattern, string)

1. 功能：从字符串开头匹配正则表达式，若开头不匹配则返回 None。
2. 参数说明：
   • pattern：正则表达式（字符串或预编译对象）。
   • string：要匹配的目标字符串。
3. 返回值：Match 对象（匹配成功）或 None。
4. 示例：

1. import re
3. # 示例：匹配以大写字母开头的单词
4. text = "Hello World"
5. match = re.match(r"^[A-Z]\w+", text)
6. if match:
7.     print(match.group())
8. else:
9.     print('不匹配')

2. re.search(pattern, string)

1. 功能：扫描整个字符串，返回第一个匹配项。
2. 参数说明：
   • pattern：正则表达式。
   • string：目标字符串。
3. 返回值：Match 对象或 None。
4. 示例：

1. # 示例：查找字符串中的第一个数字
2. match_obj = re.search("\d+", "周周已经30岁了，蓓蓓才10岁")
3. if match_obj:
4.     # 获取匹配结果数据
5.     print(match_obj.group())
6. else:
7.     print("匹配失败")

3. re.findall(pattern, string)

1. 功能：返回所有非重叠匹配项的列表。
2. 参数说明：
   • pattern：正则表达式。
   • string：目标字符串。
3. 返回值：
   • 无分组时：字符串列表（如 ['a', 'b']）。
   • 有分组时：元组列表（如 [('2023', '10'), ('2024', '01')]）。
4. 示例：

1. match_obj = re.findall("\d+", "周周已经30岁了，蓓蓓才10岁")
2. if match_obj:
3.     # 获取匹配结果数据
4.     print(match_obj)
5. else:
6.     print("匹配失败")

分组对匹配结果的影响：

1. # ------------ 示例1：无分组时匹配所有字母和数字组合 ------------
2. a = "abc123_abc456"
3. b = re.findall(r"[a-z]+\d*", a)
4. print(b)  # 输出: ['abc123', 'abc456']
6. # ------------ 示例2：分组时仅提取分组内容 ------------
7. a = "abc123_abc456_789"
8. b = re.findall(r"[a-z]+(\d*)", a)  # 强调只提取括号内的 \d*
9. print(b)  # 输出: ['123', '456', '']（注意最后一个匹配的 \d* 为空）
11. # ------------ 示例3：多分组时提取元组列表 ------------
12. a = "abc123abc456哈哈哈哈哈哈abc789abc901"
13. b = re.findall(r"[a-z]+(\d*)[a-z]+(\d*)", a)
14. print(b)  # 输出: [('123', '456'), ('789', '901')]

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

1. 功能：替换所有匹配项（或前 count 个）。
2. 参数说明：
   • pattern：正则表达式。
   • repl：替换内容（字符串或函数）。
   • string：目标字符串。
   • count：最大替换次数（默认 0 表示全部替换）。
3. 返回值：替换后的新字符串。
4. 示例：

1. match_obj = re.sub("\d+", '18', "周周已经30岁了，蓓蓓才10岁", count=0)
2. if match_obj:
3.     # 获取匹配结果数据
4.     print(match_obj)
5. else:
6.     print("匹配失败")

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

1. 功能：按正则表达式分割字符串。
2. 参数说明：
   • pattern：正则表达式。
   • string：目标字符串。
   • maxsplit：最大分割次数（默认 0 表示全部分割）。
3. 返回值：分割后的字符串列表。
4. 示例：

1. # ------------ 示例1：使用正则表达式分割复杂分隔符 ------------
2. text = '香蕉,苹果、菠萝，栗子。猕猴桃'
3. pattern = r'[,，、。]'  # 匹配逗号、中文逗号、顿号、句号
4. result = re.split(pattern, text)
5. print(result)  # 输出: ['香蕉', '苹果', '菠萝', '栗子', '猕猴桃']
7. # ------------ 示例2：限制分割次数 ------------
8. text = '香蕉、苹果、菠萝，栗子。猕猴桃'
9. result = re.split(r'[,，、。]', text, maxsplit=2)
10. print(result)  # 输出: ['香蕉', '苹果', '菠萝，栗子。猕猴桃']

高级技巧【拓展】

1. flags参数：

正则表达式的 flags 参数用于控制匹配模式，所有方法均支持此参数（如 re.match(), re.search(), re.findall(), re.sub(), re.split() 等）。以下是常用修饰符：

使用示例：

1. # 示例1：忽略大小写匹配（re.IGNORECASE）
2. text = "Apple Banana"
3. matches = re.findall(r"apple", text, flags=re.IGNORECASE)
4. print(matches)  # 输出: ['Apple']
6. # 示例2：多行模式（re.MULTILINE）
7. text = "Line1\nLine2"
8. matches = re.findall(r"^Line\d", text, flags=re.MULTILINE)
9. print(matches)  # 输出: ['Line1', 'Line2']
11. # 示例3：组合多个修饰符（re.I | re.S）
12. text = "Start\nEnd"
13. match = re.search(r"start.*end", text, flags=re.I | re.S)
14. print(match.group())  # 输出: Start\nEnd

2. 预编译正则表达式

什么是预编译正则表达式？

1. 定义：通过 re.compile() 将正则表达式字符串转换为 Pattern 对象，后续可直接调用该对象的方法（如 match(), search()）。
2. 核心作用：提升性能（避免重复解析正则表达式），并简化代码复用。

基本使用方法示例：

步骤：

1. 1. 使用 re.compile() 编译正则表达式，生成 Pattern 对象。
   2. 调用 pattern 对象的方法（如 match(), search()），参数与原 re 模块方法一致。
2. # 示例：在循环中重复匹配
3. import re
5. # 1.预编译正则表达式
6. pattern = re.compile(r"\d+")
8. data_list = ["user123", "item456", "price789"]    # 需要匹配的字符串
9. for text in data_list:
10.    # 2.调用预编译对象pattern的方法
11.     match = pattern.search(text)
12.     print(match.group())  # 输出: 123, 456, 789

多方法复用示例：

就是同一正则表达式需用于 match、search、findall 等多种操作时。

1. pattern = re.compile(r"\b\w+\b")  # 预编译
2. text = "hello world"
3. # 复用同一个 Pattern 对象
4. print(pattern.match(text).group())   # 输出: hello
5. print(pattern.findall(text))         # 输出: ['hello', 'world']

1. 贪婪和非贪婪匹配

1. 贪婪匹配

1. 定义：默认模式，匹配时尽可能多地吞并字符，直到无法满足后续条件为止。
2. 语法：使用 *, +, ?, {n,m} 等量词时，默认是贪婪的。
3. 示例：

1. import re
2. s = "A phone number 130-9411-2846"
3. r = re.match(r"(.+)(\d+-\d+-\d+)", s)
4. print(r.group(1))  # 输出: A phone number 13
5. print(r.group(2))  # 输出: 0-9411-2846（不符合预期！）

• • 问题原因：.+ 贪婪吞并尽可能多字符，直到最后一个 \d 才停止。

2. 非贪婪匹配

1. 定义：匹配时尽可能少地吞并字符，一旦满足条件立即结束。
2. 语法：在量词后添加 ?，如 *?, +?, ??。
3. 示例：

1. s = "A phone number 130-9411-2846"
2. r = re.match(r"(.+?)(\d+-\d+-\d+)", s)
3. print(r.group(1))  # 输出: A phone number
4. print(r.group(2))  # 输出: 130-9411-2846（正确分割！）

• • 解决原因：.+? 非贪婪匹配到第一个 \d 前即停止。

3. 对比总结

1. 原生字符串 r 的作用

之前的正则中，需要用反斜杠 \ 对一些特殊字符进行转译，但是如果我们就是需要去匹配反斜杠呢？此时可以用到r写在正则的匹配规则之前，做到将正则的规则字符串看作原生的字符，即为不需要再去转译的字符。

1. 反斜杠 \ 的转义冲突：

正则表达式中需用 \d、\w 等语法，而 Python 字符串本身用 \ 表示转义，导致需写多个 \。

1. 示例：

1. # 目标：匹配字符串 "d:\a\b\c"
2. m = "d:\\a\\b\\c"  # Python 字符串需转义为 "d:\\a\\b\\c"
4. # 未用原生字符串写法
5. ret = re.match("d:\\\\a", m)  # 需写4个反斜杠！
6. print(ret.group())  # 输出: d:\a（实际匹配到 "d:\\a"）
8. # 使用原生字符串写法
9. ret = re.match(r"d:\\a", m)  # 只需写2个反斜杠
10. print(ret.group())  # 输出: d:\a（匹配到 "d:\\a"）

2.  原生字符串 r 的作用

1. 功能：取消 Python 字符串的转义，使 \ 直接表示字面意义。
2. 语法：在字符串前加 r，如 r"\d+"。
3. 对比示例：

1. print("\\")    # 输出: \
2. print(r"\\")   # 输出: \\

1. # 示例：非贪婪匹配 + 原生字符串
2. text = "Price: $100.99, Tax: $20.5"
3. pattern = re.compile(r"\$(.+?)\b")  # 匹配金额（非贪婪）
4. matches = pattern.findall(text)
5. print(matches)  # 输出: ['100.99', '20.5']