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"bcatb"
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 标志：

下面是一个简单的例子：

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

最后

以上就是平淡小刺猬为你收集整理的Python 高级编程之正则表达式（八）的全部内容，希望文章能够帮你解决Python 高级编程之正则表达式（八）所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。