本文首发于公众号：Hunter后端
原文链接：
Python笔记五之正则表达式
这一篇笔记介绍在 Python 里使用正则表达式。
正则表达式，Regular Expression，可用于在一个目标字符串里对于指定模式的字符进行查找、替换、分割等操作。
比如，判断某个字符串里是否都是数字，或者是否包含指定字符串，又或者更直接的例子是判断电话号码或者邮箱是否合法等。
这一篇笔记里，我们将先介绍一个正则表达式的函数，并以此来引入正则表达式的各种模式，并辅以各个例子进行介绍。
u1s1，正则表达式，我学了三四遍，学一遍忘一遍，忘一遍学一遍，只要隔一阵子不用就会忘，所以这一篇笔记力求将正则表达式的所有模式和用法都记录下来，用作之后的查找笔记。
以下笔记使用 Python 版本是 3.8。
以下是本篇笔记目录：
- re.findall
- 表达式语法
- 匹配字符串类型
- \b-匹配空字符串，但只在单词开始或结尾
- \B-匹配空字符串，不能在开头或结尾
- \d-匹配十进制数字
- \D-匹配非十进制字符
- \s-匹配空白字符
- \S-匹配非空白字符
- \w-匹配字符
- \W-匹配非单词字符
- 匹配字符串出现位置
- \A-只匹配字符串开始
- \Z-只匹配字符串结尾
- ^-匹配字符串开头
- $-匹配字符串结尾
- 匹配字符串数量
- *-匹配重复 0 到 n 次
- +-匹配重复 1 到 n 次
- ?-匹配重复 0 到 1 次
- {}-指定匹配重复次数
a. {m}-只匹配重复 m 次
b. {m,n}-匹配重复 m 到 n 次
- 匹配字符串集合
- 字符可以单独列出
- 可以表示字符范围
- 特殊字符在集合里只会匹配其原始字符含义
- 字符类 \s 或 \w 可以在集合里使用
- 取反操作可以使用 ^
- 其他匹配类型
- |-表达式的或操作
- ()-匹配括号内的任意正则表达式
- 常用正则方法
- re.search
- re.match
- re.split
- re.findall
- re.finditer
- re.sub
- re.subn
- re.compile
- 其他参数
- re.I
- re.M
- re.Match 匹配对象
- Match.group()
Match.__getitem__(g)
- Match.groups()
- Match.re
- Match.string
- Match.start() 和 Match.end()
- Match.span()
1、re.findall
使用正则表达式，首先要引入模块：
import re
这里从
re.findall
开始介绍，findall 方法表示的是找到目标字符串里符合指定模式的全部数据。
比如我们有一个字符串
abcdefg
，想要从其中找到
de
，就可以如下操作：
str_1 = "abcdefg"
target_str = "de"
print(re.findall(target_str, str_1))
返回的就是一个列表，列表元素是我们的目标字符串
de
：
['de']
我们的 target_str 就是一个匹配模式，这里是一个纯字符串，我们可以将其替换成其他的模式字符串。
接下来我们将分类介绍正则表达式语法。
2、表达式语法
正则表达式有很多种，比如表示匹配数量的
+
，
*
，
?
，还有表示匹配字符串内容的
\s
，
\w
等。
下面将从这些类别分别开始介绍：匹配字符串类型、匹配字符串出现位置、匹配字符串数量、匹配字符串集合等
1. 匹配字符串类型
1) \b-匹配空字符串，但只在单词开始或结尾
\b 可以匹配空字符串，但是只在字符串开始或者结尾的位置，这里的空字符串涵盖了标签符号，比如
, . ，。？
等，也包括换行制表符
\n \t
等，也包含 ''，可以理解为字符串的边界部分。
所以
\b
的作用其实就可用于匹配特定字符串的前缀或者后缀，这里的前缀和后缀并不仅仅是指整个字符串的前缀和后缀，也包括字符串内部被分割的前缀和后缀。
比如对于下面这个字符串：
i have a apple
我们想找到是否有
ha
开头的单词，可以如此操作：
str_1 = "i have a apple"
target_pattern = r"\bha"
print(re.findall(target_pattern, str_1))
字符串如果是以下几种情况，也可以匹配上：
str_1 = "i ,have a apple"
str_1 = "i \thave a apple"
str_1 = "i ha"
我们还可以使用 \b 来匹配特定的单词，在英文中，单词的出现是前后都有空格或者标点符号的，那么我们就可以前后都加上 \b 来限定匹配是否出现过此单词：
str_1 = "i have an apple"
str_1 = "i have an apple, "
str_1 = "i have an apple how are you"
target_pattern = r"\bapple\b"
print(re.findall(target_pattern, str_1))
2) \B-匹配空字符串，不能在开头或结尾
\B 是 \b 的取非操作，含义是匹配空字符串，但是不能出现在开头或者结尾，也就是说 \B 所在的位置必须有 1 至多个非空字符串来替代：
str_1 = "i have an apple"
target_pattern = r"app\B"
print(re.findall(target_pattern, str_1))
3) \d-匹配十进制数字
\d 用来匹配十进制数字，也就是 0-9 这些，比如下面的操作：
str_1 = "asdas98123asa978d"
target_pattern = r"\d"
print(re.findall(target_pattern, str_1))
# ['9', '8', '1', '2', '3', '9', '7', '8']
可以看到返回的结果是分隔开的数字，如果想要他们在一起返回，我们可以使用
\d+
来操作，
+
表示的匹配 1 到 n 次，这个后面再介绍。
4) \D-匹配非十进制字符
\D 表示的是 \d 相反的操作，非十进制字符，可以使用上面的示例进行测试。
5) \s-匹配空白字符
\s 匹配的空白字符不包括标点符号，常见的有换行符，制表符，回车符等转义字符，
\n \t \r \f
等
str_1 = "asdas9812\v3a\rs,.\ta9\n78\fd"
target_pattern = r"\s"
print(re.findall(target_pattern, str_1))
6) \S-匹配非空白字符
\S 是 \s 取非操作，除了上面的换行符、制表符等字符外，包括标点符号皆可被匹配上
7) \w-匹配字符
\w 不匹配换行符、制表符等转义字符，不匹配中英文常见标点符号，比如
, . ; "
等，但是可以匹配中英文字符、数字和下划线，比如下面的示例：
str_1 = "asd—— _a你‘'好，s9。8？12\v3a\rs,.\ta9\n78\fd"
target_pattern = r"\w"
print(re.findall(target_pattern, str_1))
# ['a', 's', 'd', '_', 'a', '你', '好', 's', '9', '8', '1', '2', '3', 'a', 's', 'a', '9', '7', '8', 'd']
8) \W-匹配非单词字符
\W 是 \w 的取反操作。
2. 匹配字符串出现位置
前面介绍的匹配字符串的类型，这里介绍匹配出现的位置，比如开头或者结尾。
1) \A-只匹配字符串开始
\A 只匹配字符串的开始，也就是我们所说的字符串前缀：
str_1 = "asd—— _a你‘'好，\ns9。8？12\v3a\rs,.\ta9\n78\fd"
target_pattern = r"\Aasd"
print(re.findall(target_pattern, str_1))
与字符串的 startswith() 函数在匹配功能上是一样的。
2) \Z-只匹配字符串结尾
\Z 只匹配字符串结尾部分，也就是所说的字符串后缀：
str_1 = "asd—— _a你‘'好，\ns9。8？12\v3a\rs,.\ta9\n78d"
target_pattern = r"d\Z"
print(re.findall(target_pattern, str_1))
3) ^-匹配字符串开头
^ 也是只匹配字符串的开头，但是与 \A 不同的是，使用 re.M 模式下，也可以匹配换行符后的开头，比如下面的示例，就可以返回两个结果：
str_1 = "asd—— _\na你‘'好，\ns9。8？12\v3a\rs,.\ta9\n78d"
target_pattern = r"^a"
print(re.findall(target_pattern, str_1, re.M))
# ['a', 'a']
如果去掉 re.M，则会退化成 \A 的功能
4) $-匹配字符串结尾
$ 也是只匹配字符串的结尾，但是在 re.M 模式下，也可以匹配换行符后新一行的结尾，比如下面的示例，可以返回两个结果：
str_1 = "asd—— _\na你‘'好，\ns9。8？12\v3a\rs,.\ta9d\n78d"
target_pattern = r"d$"
print(re.findall(target_pattern, str_1, re.M))
同理，如果去掉 re.M，则会退化成 \Z 的功能。
3. 匹配字符串数量
除了匹配指定模式的内容，字符位置，我们还可以匹配指定模式的数量，比如想只要满足一个即可返回，或者尽可能多的将满足的字符返回等。
接下来一一介绍如何匹配字符串数量。
1) *-匹配重复 0 到 n 次
*
表示匹配的数量可以重复从 0 到 n 次，这个 n 为任意次，尽量多的匹配字符串。
比如我们想匹配
a
以及
a
后面可以加上任意个
b
字符，比如希望
a
，
ab
，
abb
，
abbbb
等都可以被匹配上。
那么就可以使用下面的操作：
str_1 = "axxxxabbxxxxabbbb"
target_pattern = r"ab*"
print(re.findall(target_pattern, str_1))
# ['a', 'abb', 'abbbb']
2) +-匹配重复 1 到 n 次
+
表示匹配的数量可以重复从 1 到 n 次，提前条件是匹配模式必须出现一个。
还是上面的例子，我们希望可以匹配上
ab
，
abbb
，以及无限多个
b
，但是不可匹配
a
，可以如下操作：
str_1 = "axxxxabbxxxxabbbb"
target_pattern = r"ab+"
print(re.findall(target_pattern, str_1))
# ['abb', 'abbbb']
3) ?-匹配重复 0 到 1 次
?
表示匹配的数量只能出现 0 到 1 次。
比如对于一个字符串，我们想匹配
apple
这个单词，但是我们也想使
apple
的复数形式
apples
也能被匹配上，所以我们这里的
s
希望它出现的次数是 0 到 1 次
str_1 = "i have an apple, he has two apples, she has three apples"
target_pattern = r"apples?"
print(re.findall(target_pattern, str_1))
# ['apple', 'apples', 'apples']
4) {}-指定匹配重复次数
使用花括号可以指定重复的次数，可以是一个固定的值，也可以是一个范围，下面分别介绍一下。
a. {m}-只匹配重复 m 次
{m}
表示匹配重复次数为 m，比如我们想要匹配
abbb
，也就是
a
字符后重复出现三个
b
，可以如下操作：
str_1 = "abbxxxxabbbbaxxxabbb"
target_pattern = r"ab{3}"
print(re.findall(target_pattern, str_1))
b. {m,n}-匹配重复 m 到 n 次
{m,n}
表示匹配重复次数为 m 到 n 次，比如我们想要
a
后面跟着 3，4，5个
b
都可以接受，可以如下操作：
str_1 = "abbbxxxxabbbbbbaxxxabbbb"
target_pattern = r"ab{3,5}"
print(re.findall(target_pattern, str_1))
# ['abbb', 'abbbbb', 'abbbb']
4. 匹配字符串集合
我们可以使用中括号
[]
来限定字符串或者匹配模式的集合，也就是说我们可以将我们想要匹配的字符串或者类型都加到
[]
里，满足条件的都可以被匹配返回。
1) 字符可以单独列出
如果我们想匹配某些单个字符，可以单独列出来操作，比如 a, t, w, q，可以使用 [atwq]，以下是示例：
str_1 = "asdqweasdaterq"
target_pattern = r"[atwq]"
print(re.findall(target_pattern, str_1))
# ['a', 'q', 'w', 'a', 'a', 't', 'q']
2) 可以表示字符范围
我们可以使用
-
来表示字符的范围进行匹配，比如
a-z
，或者数字类型的
0-9
，比如下面的操作：
str_1 = "asdqweasdaterq"
target_pattern = r"[a-j]"
print(re.findall(target_pattern, str_1))
# ['a', 'd', 'e', 'a', 'd', 'a', 'e']
str_1 = "asd136q78w9ea95sd6ater"
target_pattern = r"[4-9]"
print(re.findall(target_pattern, str_1))
# ['6', '7', '8', '9', '9', '5', '6']
注意：
在这里的连接符
-
是表示范围的，如果只是想匹配
-
字符，需要使用
\
进行转义，或者将
-
放在首位或者末位：
str_1 = "asd136q-78w-9e-a95sd6zater"
target_pattern = r"[a\-z]"
print(re.findall(target_pattern, str_1))
# ['a', '-', '-', '-', 'a', 'z', 'a']
上面的这个操作表示的是希望匹配上
-
a
和
z
三个字符。
3) 特殊字符在集合里只会匹配其原始字符含义
特殊字符，比如前面表示数量的
*
+
等字符在中括号里就匹配的是对应的星号和加号：
str_1 = "asdas*adas+asds(das)dasd"
target_pattern = r"[*+()]"
print(re.findall(target_pattern, str_1))
# ['*', '+', '(', ')']
4) 字符类 \s 或 \w 可以在集合里使用
比如下面的操作，可以 \W 和 0-9 之间的字符：
str_1 = "asdas*adas+asds(90123das)dasd"
target_pattern = r"[\W0-9]"
print(re.findall(target_pattern, str_1))
# ['*', '+', '(', '9', '0', '1', '2', '3', ')']
5) 取反操作可以使用 ^
如果要取反，意思是集合里的匹配模式都不匹配，比如我们想匹配字符串里的非数字，可以如下操作：
str_1 = "asdas*adas+asds(90123das)dasd"
target_pattern = r"[^\d]"
print(re.findall(target_pattern, str_1))
# ['a', 's', 'd', 'a', 's', '*', 'a', 'd', 'a', 's', 'a', 's', 'd', 's', '(', 'd', 'a', 's', ')', 'd', 'a', 's', 'd']
5. 其他匹配类型
1) |-表达式的或操作
比如我们有两个表达式 A 和 B，只要有一个符合条件即可，即匹配模式的或操作：
re.findall(r"\d+|[a-z]+", "asdas234asd2341")
# ['asdas', '234', 'asd', '2341']
2) ()-匹配括号内的任意正则表达式
小括号表示分组，可以将匹配模式分组放到多个小括号内进行匹配，匹配后的结果也会以元组的形式分组返回。
比如我们想匹配
英文字母+数字
的形式，并且以括号的形式将其分隔开，那么返回的匹配结果也会以元组的形式将其返回：
str_1 = "asdas9872"
target_pattern = r"([a-z]+)(\d+)"
result = re.findall(target_pattern, str_1)print(result)
# [('asdas', '9872')]
如果是匹配上了多个结果，那么多个结果会以列表的形式返回，元素也是匹配的结果以元组的形式返回：
str_1 = "asdas9872asdasklqw8267"
target_pattern = r"([a-z]+)(\d+)"
result = re.findall(target_pattern, str_1)print(result)
# [('asdas', '9872'), ('asdasklqw', '8267')]
3、常用正则方法
前面介绍了 re.findall() 方法，返回的是一个列表，元素是所有匹配上的结果，接下来介绍一些其他常用的正则方法。
1. re.search
re.search() 方法的作用是扫描整个目标字符串，找到匹配上的第一个位置，然后返回一个匹配对象，如果没有满足要求的数据，则返回 None。
这里要注意三点，一点是扫描整个字符串，直到找到匹配的对象，另一点是找到一个符合条件的字符串以后就停止扫描，即便后面还有符合条件的，三是返回一个匹配对象，关于匹配对象下面再介绍。
比如下面的示例是匹配 英文字母+数字：
str_1 = "..()-+/?asdas9872asdasklqw8267"
target_pattern = r"[a-z]+\d+"
result = re.search(target_pattern, str_1)
# <re.Match object; span=(8, 17), match='asdas9872'>
可以看到这里，其实有多个符合匹配模式的数据，如果这里使用 re.findall() 会返回多个值，但这里返回的只是字符串里第一个符合条件的数据。
至于如何获取返回的这个 re.Match 对象详情数据，见第四节
re.Match 匹配对象
，建议先阅读该章节再往后读。
2. re.match
re.match() 方法也是用于匹配指定模式，效果上与 re.search() 无异，唯一不同的一点是 match() 方法只能从字符串的头部开始匹配，返回的也是一个 re.Match 对象。
比如下面的操作，第一种形式匹配不到数据，返回 None，第二种就可以返回 re.Match 对象：
str_1 = "..()-+/?asdas9872asdasklqw8267"
target_pattern = r"[a-z]+\d+"
result = re.match(target_pattern, str_1)
# None
str_1 = "asdas9872asdasklqw8267"
target_pattern = r"[a-z]+\d+"
result = re.match(target_pattern, str_1)
# <re.Match object; span=(0, 9), match='asdas9872'>
3. re.split
根据匹配模式将指定字符串进行分割，在效果上相当于 string.split() 的增强版。
因为 string.split() 不能使用正则对象来对字符串进行切割，而 re.split() 可以实现。
比如我们想要根据 1,2,3 对指定字符串进行切割，就可以用到
|
这个操作：
re.split(r"1|2|3", "as2da1s3asdsa")
# ['as', 'da', 's', 'asdsa']
我们也可以使用其他正则对象，比如我们想要根据字符串中的标点符号，空格等对字符串进行切割：
re.split(r"\W+", "i have an apple, you have two apples!")
# ['i', 'have', 'an', 'apple', 'you', 'have', 'two', 'apples', '']
re.split() 还可以接受 maxsplit 参数，表示最多切割的次数：
re.split(r"\W+", "i have an apple, you have two apples!", maxsplit=2)
# ['i', 'have', 'an apple, you have two apples!']
4. re.findall
re.findall() 前面有过介绍，根据匹配模式获取所有的匹配字符，结果以列表形式返回，元素为匹配的字符串：
re.findall(r"\d+", "asd12asxda45asd456sd23")
# ['12', '45', '456', '23']
5. re.finditer
re.finditer() 函数与 re.findall() 函数效果类似，都是找到目标字符串里全部满足条件的字符串，但是不同的是 finditer() 返回的一个迭代器，迭代器保存的是匹配对象，也就是 re.Match 对象：
for item in re.finditer(r"\d+", "asd12asxda45asd456sd23"):
print(item)
# <re.Match object; span=(3, 5), match='12'>
# <re.Match object; span=(10, 12), match='45'>
# <re.Match object; span=(15, 18), match='456'>
# <re.Match object; span=(20, 22), match='23'>
6. re.sub
替换函数，将字符串里的指定模式替换成目标字符串，然后返回：
re.sub(r"\d+", "***", "asd12asxda45asd456sd23")
# 'asd***asxda***asd***sd***'
7. re.subn
re.subn() 与 re.sub() 函数作用一致，都是替换目标字符串，但是返回的是一个元组，分别是替换后的字符串和替换的次数：
re.subn(r"\d+", "***", "asd12asxda45asd456sd23")
# ('asd***asxda***asd***sd***', 4)
8. re.compile
re.compile() 函数将正则表达式编译为一个正则表达式对象，然后可以调用前面介绍过的这些正则函数，比如 re.search()，re.match()，re.findall() 等。
pattern = re.compile(r"\d+")
pattern.match("3432asdas334asd34asd")
# <re.Match object; span=(0, 4), match='3432'>
re.complie() 这个函数的操作可以用于永福匹配模式，使程序更加高效。
9. 其他参数
接下来介绍一下正则模块在匹配情况下的一些其他参数。
1) re.I
忽略大小写。
对于目标字符串，如果存在字母大小写的情况，我们可以对原始字符串统一进行大写或者小写的操作，然后进行匹配，以忽略大小写的影响，也可以使用 re.I 参数：
re.search(r"[a-z]+", "123SDAFSDsa234ASDd34".lower())
# <re.Match object; span=(3, 11), match='sdafsdsa'>
re.search(r"[a-z]+", "123SDAFSDsa234ASDd34", re.I)
# <re.Match object; span=(3, 11), match='SDAFSDsa'>
2) re.M
多行匹配模式。
前面介绍
^
和
$
这两个符号的匹配的时候介绍过，如果加上 re.M 参数，表示的是可以匹配字符串内部有换行符的开头和结尾的数据：
str_1 = "asd—— _\na你‘'好，\ns9。8？12\v3a\rs,.\ta9\n78d"
target_pattern = r"^a"
print(re.findall(target_pattern, str_1, re.M))
# ['a', 'a']
4、re.Match 匹配对象
对于一些函数，比如前面介绍的 re.search()，返回的就是一个 re.Match 对象，还是以上面的示例为例，如何获取 re.Match 中的数据呢，下面开始介绍。
1. Match.group()
group() 函数直接调用，或者添加参数 0，返回的是匹配的字符串数据：
print(result.group())
# asdas9872
print(result.group(0))
# asdas9872
而如果我们匹配的模式使用了小括号
()
进行了分组，那么则可以对 group() 函数添加其他 index 表示匹配的分组的结果，比如下面的操作：
str_1 = "..()-+/?asdas9872asdasklqw8267"
target_pattern = r"([a-z]+)(\d+)"
result1 = re.search(target_pattern, str_1)
print(result1.group(0))
# asdas9872
print(result1.group(1))
# asdas
print(result1.group(2))
# 9872
2.
Match.__getitem__(g)
re.Match 对象实现了
getitem
这个魔术方法，所以我们可以通过索引的方式对来访问匹配的结果，其效果和 group(index) 是一致的：
print(result1[0])
print(result1.group(0))
print(result1[2])
print(result1.group(2))
3. Match.groups()
groups() 函数返回的是进行了分组匹配的结果，以元组的形式返回。
比如这里分组的 result1 对象：
print(result1.groups())
# ('asdas', '9872')
而 result 这个 Match 对象匹配模式里并没有使用小括号进行分组，所以返回的结果是空元组：
print(result.groups())
# ()
4. Match.re
返回的是生成这个 Match 对象的正则对象，也就是我们输入的 target_pattern：
print(result.re)
# re.compile('[a-z]+\\d+')
5. Match.string
返回的是传递到生成这个 Match 对象的原始字符串：
print(result.string)
# ..()-+/?asdas9872asdasklqw8267
6. Match.start() 和 Match.end()
这两个函数表示的是匹配上的字符串的开始位置和结束位置：
print(result.start(), result.end())
# 8 17
我们对原始字符串进行起始位置的截取就是 Match.group() 的结果：
print(str_1[result.start(): result.end()])
# asdas9872
print(result.group())
# asdas9872
而如果我们前面对匹配模式进行了分组的操作，也就是使用了小括号，比如返回的 result1，我们可以想 start() 和 end() 函数添加索引参数分别表示这两个分组结果开始和结束的下标位置：
print(result1.groups())
# ('asdas', '9872')
print(str_1[result1.start(1): result1.end(1)])
# asdas
print(str_1[result1.start(2): result1.end(2)])
# 9872
7. Match.span()
返回的是匹配结果的开始和结束位置，以元组的形式返回，其实就是一次性返回 Match.start() 和 Match.end() 的结果。
span() 函数也可以接受分组的参数返回分组的起始位置。
如果想获取更多相关文章，可扫码关注阅读：
