Python 高级编程之正则表达式（八）

一、概述

**正则表达式（Regular Expression）**是一种文本模式，用于匹配字符串中的模式。它可以用于很多任务，例如文本搜索和替换，数据提取，数据验证等。

• 在 Python 中，可以使用 re 模块来支持正则表达式。正则表达式使用特殊的字符来表示不同的模式，例如 . 匹配任意字符，\d 匹配数字，^ 匹配字符串开头，$ 匹配字符串结尾等。

• 通过使用正则表达式，可以很方便地对字符串进行匹配，搜索和替换等操作。使用正则表达式的时候，需要先编写一个匹配模式，然后使用 re 模块中的函数来执行实际的匹配操作。

总的来说，正则表达式是一种强大且高效的文本处理工具，可以用于解决很多实际问题。

二、正则表达式语法

正则表达式（Regular Expression，简称 regex 或 regexp）是一种用来匹配文本模式的工具，它可以用来搜索、替换和验证文本。正则表达式由一些特殊字符和普通字符组成，这些字符表示了一些模式。

下面是一些常见的正则表达式语法：

1）字符匹配

• 普通字符：表示自身，例如 "a" 表示字符 a。
• 元字符（特殊字符）：表示某种特殊含义，例如 "." 表示匹配任意字符，"\d" 表示匹配数字，"\w" 表示匹配字母、数字、下划线。

示例：

import re

# 匹配 "abc" 字符串
pattern = "abc"
text = "abc"
result = re.match(pattern, text)
print(result) # <re.Match object; span=(0, 3), match='abc'>

# 匹配任意字符
pattern = "."
text = "abc"
result = re.match(pattern, text)
print(result) # <re.Match object; span=(0, 1), match='a'>

# 匹配数字
pattern = "\d"
text = "123"
result = re.match(pattern, text)
print(result) # <re.Match object; span=(0, 1), match='1'>

# 匹配字母、数字、下划线
pattern = "\w"
text = "abc_123"
result = re.match(pattern, text)
print(result) # <re.Match object; span=(0, 1), match='a'>

2）字符集合

• 方括号：表示匹配方括号中任意一个字符，例如 "[abc]" 表示匹配字符 a、b、c 中的任意一个。
• 范围符号：表示匹配某个范围内的字符，例如 "[a-z]" 表示匹配小写字母 a 到 z 中的任意一个。
• 量词："", "+", "?": 表示重复次数，"" 表示重复0次或多次，"+" 表示重复1次或多次，"?" 表示重复0次或1次。
• "{m,n}": 表示重复次数的范围，例如 "{2,4}" 表示重复2到4次。

示例：

import re

# 匹配方括号中任意一个字符
pattern = "[abc]"
text = "a"
result = re.match(pattern, text)
print(result) # <re.Match object; span=(0, 1), match='a'>

# 匹配小写字母 a 到 z 中的任意一个
pattern = "[a-z]"
text = "a"
result = re.match(pattern, text)
print(result) # <re.Match object; span=(0, 1), match='a'>

# 重复0次或多次
pattern = "a*"
text = "aaa"
result = re.match(pattern, text)
print(result) # <re.Match object; span=(0, 3), match='aaa'>

# 重复1次或多次
pattern = "a+"
text = "aaa"
result = re.match(pattern, text)
print(result) # <re.Match object; span=(0, 3), match='aaa'>

# 重复0次或1次
pattern = "a?"
text = "aaa"
result = re.match(pattern, text)
print(result) # <re.Match object; span=(0, 1), match='a'>

# 重复2到4次
pattern = "a{2,4}"
text = "aaaa"
result = re.match(pattern, text)
print(result) # <re.Match object; span=(0, 4), match='aaaa'>

3）定位符

• "^": 表示匹配开头。
• "$": 表示匹配结尾。
• "\b": 表示匹配单词边界。

import re

# 匹配开头
pattern = "^a"
text = "abc"
result = re.match(pattern, text)
print(result) # <re.Match object; span=(0, 1), match='a'>

# 匹配结尾
pattern = "c$"
text = "abc"
result = re.search(pattern, text)
print(result) # <re.Match object; span=(2, 3), match='c'>

# 匹配单词边界
pattern = r"\bcat\b"
text = "cat sat on the mat"
result = re.search(pattern, text)
print(result) # <re.Match object; span=(0, 3), match='cat'>

4）分组

• "()", "(?:)": 表示分组，可以对一个子表达式进行分组。
• "|": 表示或关系。

1、定义分组

使用圆括号 () 来定义分组，分组可以嵌套，每个分组都有一个唯一的编号，从左到右按照左括号的顺序编号。

import re
pattern = r"(\d{3})-(\d{4})-(\d{4})"
result = re.search(pattern, "Tel: 010-1234-5678")
print(result.group(0))  # 010-1234-5678
print(result.group(1))  # 010
print(result.group(2))  # 1234
print(result.group(3))  # 5678

2、引用分组

可以在正则表达式中使用 \n 引用第 n 个分组，其中 n 是分组的编号。

import re
pattern = r"(\w+) \1"
result = re.search(pattern, "hello hello world")
print(result.group(0))  # hello hello
print(result.group(1))  # hello

3、命名分组

除了使用编号引用分组，还可以使用 (?Ppattern) 语法给分组命名。

import re
pattern = r"(?P<first>\w+) (?P<last>\w+)"
result = re.search(pattern, "John Smith")
print(result.group(0))  # John Smith
print(result.group("first"))  # John
print(result.group("last"))  # Smith

以上仅是正则表达式语法的一部分，实际上正则表达式还包括很多高级的语法，比如反向引用、零宽度断言等。上面讲使用到了Python 的re模式，接下来细讲这个模块。

三、Python 的 re 模块

Python标准库中的re模块是用于正则表达式操作的模块，提供了正则表达式的编译、匹配、查找、替换等功能。下面是re模块的一些常用方法：

1）re.match() 方法

re.match() 函数从字符串的起始位置开始匹配正则表达式，如果匹配成功，就返回一个匹配对象。如果匹配不成功，就返回 None。

re.match() 的语法格式如下：

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

参数：

• pattern 是正则表达式
• string 是要匹配的字符串
• flags 是可选参数，用于指定匹配模式。

正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位 OR(|) 它们来指定。如 re.I | re.M 被设置成 I 和 M 标志：

修饰符	描述
re.I	使匹配对大小写不敏感
re.M	多行匹配，影响 ^ 和 $
re.L	做本地化识别（locale-aware）匹配
re.S	使 . 匹配包括换行在内的所有字符
re.U	根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B
re.X	该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。

下面是一个简单的例子：

import re

pattern = r"hello"
string = "hello world"

match_obj = re.match(pattern, string)

if match_obj:
    print("匹配成功")
else:
    print("匹配失败")

在这个例子中，正则表达式 pattern 是 "hello"，要匹配的字符串是 "hello world"。由于正则表达式和字符串的开头都是 "hello"，所以匹配成功。

re.match() 返回的是一个匹配对象。如果匹配成功，可以使用匹配对象的方法和属性来获取匹配结果，如 group() 方法可以返回匹配的字符串，start() 和 end() 方法可以返回匹配的起始位置和结束位置，等等。如果匹配不成功，调用这些方法和属性会出现异常。

• start() 返回匹配开始的位置
• end() 返回匹配结束的位置
• span() 返回一个元组包含匹配 (开始,结束) 的位置

下面是一个获取匹配结果的例子：

import re

pattern = r"hello"
string = "hello world"

match_obj = re.match(pattern, string)

if match_obj:
    print("匹配成功")
    print(match_obj.group())     # hello
    print(match_obj.start())     # 0
    print(match_obj.end())       # 5
    print(match_obj.span())      # (0, 5)
else:
    print("匹配失败")

2）re.search() 方法

re.search() 方法在字符串中搜索正则表达式的第一个匹配项，并返回一个匹配对象。如果没有找到匹配项，就返回 None。

re.search() 的语法格式如下：

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

其中，pattern 是正则表达式，string 是要匹配的字符串，flags 是可选参数，用于指定匹配模式。匹配模式在上面有具体讲解。

下面是一个简单的例子：

import re

pattern = r"hello"
string = "world hello"

match_obj = re.search(pattern, string)

if match_obj:
    print("匹配成功")
else:
    print("匹配失败")

在这个例子中，正则表达式 pattern 是 "hello"，要匹配的字符串是 "world hello"。由于字符串中包含 "hello"，所以匹配成功。

3）re.match() 与 re.search() 的区别

Python re 模块中的 re.match() 和 re.search() 方法都用于在字符串中查找匹配的模式。但是它们之间有一些区别。

• re.match() 方法从字符串的起始位置开始匹配，如果起始位置不匹配，则返回 None。因此，re.match() 只能匹配到字符串的开头。
• re.search() 方法在字符串中查找匹配的模式，可以匹配到字符串中任意位置的模式。

另外，两个方法返回的匹配对象也有一些区别：

• re.match() 方法返回第一个匹配的对象，如果没有匹配到任何内容，则返回 None。
• re.search() 方法返回第一个匹配的对象，如果没有匹配到任何内容，则返回 None。

如果要匹配整个字符串，通常建议使用 re.match() 方法；如果要匹配字符串中的一部分，或者不确定匹配的位置，通常建议使用 re.search() 方法。

下面是一个例子，展示了两个方法之间的区别：

import re

pattern = r"hello"
string = "world hello"

# 使用 re.match() 方法
match_obj = re.match(pattern, string)
if match_obj:
    print("re.match() 匹配成功")
    print(match_obj.group())   # 输出 "None"

# 使用 re.search() 方法
match_obj = re.search(pattern, string)
if match_obj:
    print("re.search() 匹配成功")
    print(match_obj.group())   # 输出 "hello"

在这个例子中，正则表达式 pattern 是 "hello"，要匹配的字符串是 "world hello"。由于字符串的开头不是 "hello"，所以 re.match() 方法无法匹配，返回 None；而 re.search() 方法可以在字符串中找到 "hello"，匹配成功。

4）re.findall() 方法

re.findall() 方法用于在字符串中查找正则表达式匹配的所有子串，并返回一个列表。如果没有匹配项，返回一个空列表。

re.findall() 方法的语法格式如下：

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

其中，pattern 是正则表达式，string 是要匹配的字符串，flags 是可选参数，用于指定匹配模式。匹配模式在上面有具体讲解。

下面是一个简单的例子：

import re

pattern = r"\d+"
string = "2 apples, 5 bananas, 1 orange"

result = re.findall(pattern, string)

print(result)   # ['2', '5', '1']

在这个例子中，正则表达式 pattern 是 "\d+"，要匹配的字符串是 "2 apples, 5 bananas, 1 orange"。"\d+" 表示匹配一个或多个数字，所以返回的结果是一个包含所有数字的列表。

【注意】re.findall() 方法返回的是一个字符串列表，其中的每个字符串都是一个匹配的子串。如果正则表达式包含分组，返回的列表将包含所有分组匹配的字符串。

5）re.finditer() 方法

re.finditer() 方法与 re.findall() 方法类似，都可以在字符串中使用正则表达式进行匹配，但它返回的不是一个列表，而是一个迭代器，可以通过迭代器逐个访问匹配结果。

re.finditer() 方法的语法格式如下：

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

其中，pattern 是正则表达式，string 是要匹配的字符串，flags 是可选参数，用于指定匹配模式。

下面是一个简单的例子：

import re

pattern = r"\d+"
string = "2 apples, 5 bananas, 1 orange"

result = re.finditer(pattern, string)

for match in result:
    print(match.group())

在这个例子中，正则表达式 pattern 是 "\d+"，要匹配的字符串是 "2 apples, 5 bananas, 1 orange"。使用 re.finditer() 方法进行匹配，返回的结果是一个迭代器，可以通过 for 循环逐个访问匹配结果。每个匹配结果都是一个 Match 对象，可以使用 match.group() 方法获取匹配的内容。

re.finditer() 方法与 re.findall() 方法的区别在于，re.findall() 方法返回一个包含所有匹配结果的列表，而 re.finditer() 方法返回一个迭代器，可以逐个访问匹配结果，这在处理大量数据时可以节省内存。

6）re.sub() 方法

re.sub() 方法用于在字符串中查找正则表达式匹配的子串，并将其替换为指定的字符串。re.sub() 方法返回替换后的字符串。

re.sub() 方法的语法格式如下：

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

其中，pattern 是正则表达式，repl 是替换字符串，string 是要进行替换的字符串，count 是可选参数，用于指定最多替换的次数，flags 是可选参数，用于指定匹配模式。

下面是一个简单的例子：

import re

pattern = r"\s+"
string = "hello  world"

result = re.sub(pattern, "-", string)

print(result)   # 'hello-world'

在这个例子中，正则表达式 pattern 是 "\s+"，要匹配的字符串是 "hello world"，"\s+" 表示匹配一个或多个空格。repl 参数是 "-"，表示将匹配到的空格替换为 "-"，结果返回的是 "hello-world"。

【注意】re.sub() 方法并不会改变原始的字符串，而是返回一个新的字符串。如果想要在原始字符串中进行替换，可以将结果赋值给原始字符串变量。

7）re.compile() 方法

re.compile() 方法用于将正则表达式编译为一个模式对象，该模式对象可以用于匹配字符串。

re.compile() 方法的语法格式如下：

re.compile(pattern, flags=0)

其中，pattern 是要编译的正则表达式，flags 是可选参数，用于指定匹配模式。

编译后的模式对象可以调用 match()、search()、findall() 和 sub() 等方法进行匹配和替换操作。使用 re.compile() 方法编译正则表达式可以提高多次使用同一模式的效率。

下面是一个简单的例子：

import re

pattern = r"\d+"
string = "2 apples, 5 bananas, 1 orange"

regex = re.compile(pattern)
result = regex.findall(string)

print(result)   # ['2', '5', '1']

在这个例子中，正则表达式 pattern 是 "\d+"，要匹配的字符串是 "2 apples, 5 bananas, 1 orange"。使用 re.compile() 方法将正则表达式编译为一个模式对象 regex，然后调用 regex.findall() 方法进行匹配，返回的结果是一个包含所有数字的列表。

【注意】如果要使用编译后的正则表达式进行匹配，必须调用相应的模式对象的方法。如果直接在 re 模块中使用正则表达式，Python 会自动将其编译为一个模式对象。

8）re.split() 方法

re.split() 方法用于在字符串中使用正则表达式进行分割，并返回一个列表。

re.split() 方法的语法格式如下：

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

其中，pattern 是正则表达式，string 是要分割的字符串，maxsplit 是可选参数，用于指定最大分割次数，flags 是可选参数，用于指定匹配模式。

下面是一个简单的例子：

import re

pattern = r"\s+"
string = "hello  world"

result = re.split(pattern, string)

print(result)   # ['hello', 'world']

在这个例子中，正则表达式 pattern 是 "\s+"，要分割的字符串是 "hello world"，"\s+" 表示匹配一个或多个空格。re.split() 方法将字符串按照正则表达式进行分割，并返回一个列表，列表中的每个元素都是分割后的子串。

【注意】re.split() 方法不会在分割后的字符串中保留分割符，如果想要保留分割符，可以使用分组语法，例如：

import re

pattern = r"(\s+)"
string = "hello  world"

result = re.split(pattern, string)

print(result)   # ['hello', '  ', 'world']

在这个例子中，正则表达式 pattern 是 "(\s+)"，使用圆括号将 "\s+" 包含起来，表示将空格作为分组进行匹配，re.split() 方法会保留分组匹配的内容。返回的结果是一个列表，列表中的元素是分割后的子串和分组匹配的内容。

---

Python 的正则表达式常用的语法和方法就先讲解到这里了，更关键还是需要多使用加深印象的。有任何疑问的小伙伴欢迎给我留言哦，后续会持续更新相关技术文章，也可关注我的公众号【大数据与云原生技术分享】进行深入技术交流~