Python正则表达式的那些事(二、字符集匹配_重复匹配_ 位置匹配_非贪婪匹配)

预定义匹配字符集

正则表达式中的⼀些表示⽅法，可以同时匹配某个预定义字符集中的任意⼀个 字符。⽐如，表达式\d可以匹配任意⼀个数字。虽然可以匹配其中任意字符， 但是只能是⼀个，不是多个。

表达式	匹配描述
\d	任意一个数字，0-9中的任意一个

#re.match(r'哈利波特\d','哈利波特4').group()
my_match_fun(r'哈利波特\d','哈利波特4')
#######函数my_match_fun开始调用参数列表#######
#---pattern = '哈利波特\d'
#---s       = '哈利波特4'
#匹配成功,结果展示如下:
#group() = 哈利波特4
#span()  = (0, 5)
#######函数my_match_fun调用结束#######
my_match_fun(r'哈利波特\d','哈利波特a')
#######函数my_match_fun开始调用参数列表#######
#---pattern = '哈利波特\d'
#---s       = '哈利波特a'
#匹配失败!
#######函数my_match_fun调用结束#######

表达式	匹配描述
\w	任意一个字母或数字或下划线，即A-Z a-z 0-9 _ 中的任意一个

#re.match(r'哈利波特\w','哈利波特4').group()
my_match_fun(r'哈利波特\w','哈利波特1a23')
#######函数my_match_fun开始调用参数列表#######
#---pattern = '哈利波特\w'
#---s       = '哈利波特1a23'
#匹配成功,结果展示如下:
#group() = 哈利波特1
#span()  = (0, 5)
#######函数my_match_fun调用结束#######

my_match_fun(r'哈利波特\w','哈利波特ab1')
#######函数my_match_fun开始调用参数列表#######
#---pattern = '哈利波特\w'
#---s       = '哈利波特ab1'
#匹配成功,结果展示如下:
#group() = 哈利波特a
#span()  = (0, 5)
#######函数my_match_fun调用结束#######

my_match_fun(r'哈利波特\w','哈利波特与魔法石')
#######函数my_match_fun开始调用参数列表#######
#---pattern = '哈利波特\w'
#---s       = '哈利波特与魔法石'
#匹配成功,结果展示如下:
#group() = 哈利波特与
#span()  = (0, 5)
#######函数my_match_fun调用结束#######

|

表达式	匹配描述
\s	空格、制表符、换页符等空白字符的其中任意一个

#re.match(r'哈利波特\s','哈利波特\t\n').group()
my_match_fun(r'哈利波特\s\s','哈利波特\t\naaa')
#######函数my_match_fun开始调用参数列表#######
#---pattern = '哈利波特\s\s'
#---s       = '哈利波特\t\naaa'
#匹配成功,结果展示如下:
#group() = 哈利波特

my_match_fun(r'哈利波特\s','哈利波特12\r')
#######函数my_match_fun开始调用参数列表#######
#---pattern = '哈利波特\s'
#---s       = '哈利波特12\r'
#匹配失败!
#######函数my_match_fun调用结束#######

表达式	匹配描述
\D	\d的反集，也就是非数字的任意一个字符，等同于[^\d]

#re.match(r'哈利波特\D','哈利波特4').group()
my_match_fun(r'哈利波特\D','哈利波特4')
#######函数my_match_fun开始调用参数列表#######
#---pattern = '哈利波特\D'
#---s       = '哈利波特4'
#匹配失败!
#######函数my_match_fun调用结束#######

my_match_fun(r'哈利波特\D','哈利波特a')
#######函数my_match_fun开始调用参数列表#######
#---pattern = '哈利波特\D'
#---s       = '哈利波特a'
#匹配成功,结果展示如下:
#group() = 哈利波特a
#span()  = (0, 5)
#######函数my_match_fun调用结束#######

表达式	匹配描述
\W	\w的反集，等同于[^\w]

#re.match(r'哈利波特\W','哈利波特4').group()
my_match_fun(r'哈利波特\W','哈利波特%')
#######函数my_match_fun开始调用参数列表#######
#---pattern = '哈利波特\W'
#---s       = '哈利波特%'
#匹配成功,结果展示如下:
#group() = 哈利波特%
#span()  = (0, 5)
#######函数my_match_fun调用结束#######
my_match_fun(r'哈利波特\W','哈利波特ab1')
#######函数my_match_fun开始调用参数列表#######
#---pattern = '哈利波特\W'
#---s       = '哈利波特ab1'
#匹配失败!
#######函数my_match_fun调用结束#######

表达式	匹配描述
\S	\s的反集，等同于[^\s]

#re.match(r'哈利波特\S','哈利波特\t\n').group()
my_match_fun(r'哈利波特\S','哈利波特\t\naaa')
#######函数my_match_fun开始调用参数列表#######
#---pattern = '哈利波特\S'
#---s       = '哈利波特\t\naaa'
#匹配失败!
#######函数my_match_fun调用结束#######

my_match_fun(r'哈利波特\S','哈利波特12\r')
#######函数my_match_fun开始调用参数列表#######
#---pattern = '哈利波特\S'
#---s       = '哈利波特12\r'
#匹配成功,结果展示如下:
#group() = 哈利波特1
#span()  = (0, 5)
#######函数my_match_fun调用结束#######

重复匹配

前⾯的表达式，⽆论是只能匹配⼀种字符的表达式，还是可以匹配多种字符其中任意⼀个的表达式，都只能匹配⼀次。但是有时候我们需要对某个字段进⾏ 重复匹配，例如⼿机号码13666666666，⼀般的新⼿可能会写成\d\d\d\d\d\d\d\d\d\d\d（注意，这不是⼀个恰当的表达式），不但写着费 劲，看着也累，还不⼀定准确恰当。 这种情况可以使⽤表达式再加上修饰匹配次数的特殊符号{}，不但重复书写表达 式就可以重复匹配。例如[abcd][abcd]可以写成[abcd]{2}

表达式	匹配描述
{n}	表达式重复n次，比如\d{2}等价于\d\d

表达式	匹配描述
{m,n}	表达式至少重复m次，最多重复n次，比如ab{1,3}可以匹配ab或abb或abbb

表达式	匹配描述
{m,}	表达式至少重复m次，比如ab{1,3}可以匹配ab或abb或abbb或abbbbb

表达式	匹配描述
？	匹配表达式0次或者1次，相当于{0,1}，比如a[cd]? 可以匹配a,ac,ad

表达式	匹配描述
+	表达式至少出现1次，相当于{1,},比如a+b可以匹配ab,aab,aaab ,abbb

表达式	匹配描述
*	表达式出现0次到任意次，相当于{0,}，比如$*b可以匹配*b,****b,*****b\

位置匹配

有时候，我们对匹配出现的位置有要求，⽐如开头、结尾、单词之间等等

表达式	匹配描述
^	在字符串开始的地方匹配，符号本身不匹配任何字符

print(re.match('^ab','abc'))
#<re.Match object; span=(0, 2), match='ab'>

print(re.match('^ab','1abc'))
#None

表达式	匹配描述
$	在字符串结束的地方匹配，符号本身不匹配任何字符

print(re.match('.*b$','122b'))
#<re.Match object; span=(0, 4), match='122b'>
print(re.match('.*b$','22b1'))
#None

表达式	匹配描述
\b	匹配一个单词边界，也就是单词和空格之间的位置，符号本身不匹配任何字符

#模板后的是\W才会做截断,阶段保留模板后的\W(^\w的边界)
a = re.split(r'123\b','==123!! abc123. 123. 123a1231123A123=1123?')
print(a)
#['==', '!! abc', '. ', '. 123a1231123A', '=1', '?']

#模板后的是\W才会做截断,阶段保留模板同时干掉后面的\W(^\w的边界)
a = re.split(r'123\W','==123!! abc123. 123. 123a1231123A123=1123?')
print(a)
#['==', '! abc', ' ', ' 123a1231123A', '1', '']

表达式	匹配描述
\B	匹配非单词边界，即左右两边都是\w范围或者左右两边都是不\w范围时的字符缝隙，符号本身不匹配任何字符

#模板后的是\w才会做截断,阶段保留模板后的\w(字母与字母数字的边界)
a = re.split(r'123\B','==123!! abc123. 123. 123a1231123A123=1123?')
print(a)
# ['==123!! abc123. 123. ', 'a', '1', 'A123=1123?']

#模板后的是\w才会做截断,阶段保留模板同时干掉后面的\w(字母与字母数字的边界)
a = re.split(r'123\w','==123!! abc123. 123. 123a1231123A123=1123?')
print(a)
#['==123!! abc123. 123. ', '', '', '123=1123?']

贪婪与⾮贪婪模式

在重复匹配时，正则表达式默认总是尽可能多的匹配，这被称为贪婪模式。例 如，针对⽂本dxxxdxxxd，表达式(d)(\w+)(d)中的\w+将匹配第⼀个d和Y后⼀ 个d之间的所有字符xxxdxxx。可见，\w+在匹配的时候，总是尽可能多的匹配 符合它规则的字符。同理，带有?、*和{m,n}的重复匹配表达式都是尽可能地多匹配。

print(re.match(r'<div>.*</div>','<div>abc</div><div>bcd</div>').group())
# <div>abc</div><div>bcd</div> 贪婪匹配  不匹配到头不停止

print(re.match(r'<div>.*?</div>','<div>abc</div><div>bcd</div>').group())
# <div>abc</div><div>bcd</div> 非贪婪匹配 匹配到了就停止

print(re.findall(r'<div>.*</div>','<div>abc</div><div>bcd</div>'))
#['<div>abc</div><div>bcd</div>']

print(re.findall(r'<div>.*?</div>','<div>abc</div><div>bcd</div>'))
#['<div>abc</div>', '<div>bcd</div>']

表达式	匹配功能描述
^[0-9]*$	数字
^\d{n}$	n位的数字
^\d{n,}$	至少n位的数字
^(0|[1-9][0-9]*)$	0或非0开头的数字
^[0-9]+(.[0-9]{2})?$	有两位小数的正实数
^-[1-9]\d*$	非0的负整数
^\d+(\.\d+)?$	非负浮点数
^(-?\d+)(\.\d+)?$	浮点数

在这里插入代码片

特殊场景的表达式

表达式	匹配功能描述
^\w+([-+.]\w+)@\w+([-.]\w+)*\.\w+([-.]\w+)$	Email地址
^(13\d|14[5|7]|15\d18\d)\d{8}$	手机号