python 如何使用正则表达式

133 阅读 0 评论 88 点赞

我是靠谱客的博主任性人生，最近开发中收集的这篇文章主要介绍python 如何使用正则表达式，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

直接上规则
^ 匹配字符串的开头
$ 匹配字符串的末尾。
. 匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。
[…] 用来表示一组字符,单独列出：[amk] 匹配 ‘a’，‘m’或’k’
[^…] 不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。
re* 匹配0个或多个的表达式。
re+ 匹配1个或多个的表达式。
re? 匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式
re{ n} 匹配n个前面表达式。例如，"o{2}“不能匹配"Bob"中的"o”，但是能匹配"food"中的两个o。
re{ n,} 精确匹配n个前面表达式。例如，"o{2,}“不能匹配"Bob"中的"o”，但能匹配"foooood"中的所有o。"o{1,}“等价于"o+”。“o{0,}“则等价于"o*”。
re{ n, m} 匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式
a| b 匹配a或b
(re) 匹配括号内的表达式，也表示一个组
(?imx) 正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域。
(?-imx) 正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。
(?: re) 类似 (…), 但是不表示一个组
(?imx: re) 在括号中使用i, m, 或 x 可选标志
(?-imx: re) 在括号中不使用i, m, 或 x 可选标志
(?#…) 注释.
(?= re) 前向肯定界定符。如果所含正则表达式，以 … 表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边。
(?! re) 前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功。
(?> re) 匹配的独立模式，省去回溯。
w 匹配数字字母下划线
W 匹配非数字字母下划线
s 匹配任意空白字符，等价于 [tnrf]。
S 匹配任意非空字符
d 匹配任意数字，等价于 [0-9]。
D 匹配任意非数字
A 匹配字符串开始
Z 匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。
z 匹配字符串结束
G 匹配最后匹配完成的位置。
b 匹配一个单词边界，也就是指单词和空格间的位置。例如， ‘erb’ 可以匹配"never” 中的 ‘er’，但不能匹配 “verb” 中的 ‘er’。
B 匹配非单词边界。‘erB’ 能匹配 “verb” 中的 ‘er’，但不能匹配 “never” 中的 ‘er’。
n, t, 等。匹配一个换行符。匹配一个制表符, 等
1…9 匹配第n个分组的内容。
10 匹配第n个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式。

group(num=0) 匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。
groups() 返回一个包含所有小组字符串的元组，从 1 到所含的小组号。

re.findall(pattern,string,pos,endpos)
pattern 匹配模式。
string 待匹配的字符串。
pos 可选参数，指定字符串的起始位置，默认为 0。
endpos 可选参数，指定字符串的结束位置，默认为字符串的长度。

re.match(pattern,string,flags = 0)
flags 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。
匹配成功re.match方法返回一个匹配的对象，否则返回None。

re.search(pattern, string, flags=0) 扫描整个字符串并返回第一个成功的匹配，否则返回None。

re.match与re.search的区别
re.match 只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回 None，而 re.search 匹配整个字符串，直到找到一个匹配。

下面举几个例子

“.” 匹配任意字符，除了换行符

import re
re.search(“.”,“tang”)
<re.Match object; span=(0, 1), match=‘t’> 返回第一个匹配到的字符串
re.search(“.”,“tang”).group()
‘t’

“^”以什么开头,”$”以什么结尾

re.search(“^tang $tang") 以t开头以g结尾 <re.Match object; span=(0, 4), match='tang'> re.search("^tang$ ”,“tang1”)
print(re.search(“^tang$”,“tang1”))
None 返回None就算是没匹配到

“*” 匹配*前的字符0或者多次

re.search(“t*”,“tang”)
<re.Match object; span=(0, 1), match=‘t’>
re.search(“t*”,“ttttttttttang”)
<re.Match object; span=(0, 10), match=‘tttttttttt’> 有几个就匹配几个
re.search(“t*”,“ang”)
<re.Match object; span=(0, 0), match=‘’> 从头开始找，没有也不会报错

“+” 匹配前一个字符1次或者多次

re.search(“t+”,“tang”)
<re.Match object; span=(0, 1), match=‘t’>
re.search(“t+”,“tttttttttttttang”)
<re.Match object; span=(0, 13), match=‘ttttttttttttt’>
re.search(“t+”,“atttttng”)
<re.Match object; span=(1, 6), match=‘ttttt’> 这边你看我没在开头写它自己会从中间去找的，区别于*
re.search(“t+”,“ang”)
print(re.search(“t+”,“ang”)) 没有就返回None了
None

“?” 匹配前一个字符1次或者0次（有点上面*和+的综合体）

re.search(“t?”,“tang”)
<re.Match object; span=(0, 1), match=‘t’>
re.search(“t?”,“ttttttttang”)
<re.Match object; span=(0, 1), match=‘t’> 有多个也只是返回1个
re.search(“t?”,“attttttng”)
<re.Match object; span=(0, 0), match=‘’> 也是从头找，没有不返回None
re.search(“t?”,“ang”)
<re.Match object; span=(0, 0), match=‘’>

“{n}” 匹配前一个字符n次

re.search(“t{3}”,“tang”) 返回None
re.search(“t{3}”,“tttang”)
<re.Match object; span=(0, 3), match=‘ttt’>
re.search(“t{1}”,“tang”)
<re.Match object; span=(0, 1), match=‘t’>

“{n,m}” 匹配前一个字符n到m次

re.search(“t{1,3}”,“tttang”)
<re.Match object; span=(0, 3), match=‘ttt’>
re.search(“t{1,3}”,“ang”) 返回None
re.search(“t{1,3}”,“ttttang”)
<re.Match object; span=(0, 3), match=‘ttt’> 高于3次也只会匹配3次
re.search(“t{1,3}”,“ttang”)
<re.Match object; span=(0, 2), match=‘tt’>
re.search(“t{1,3}”,“tang”)
<re.Match object; span=(0, 1), match=‘t’>

“A|B” 匹配A或者B

re.search(“t|123”,“tang1236485556”)
<re.Match object; span=(0, 1), match=‘t’>
re.search(“t|123”,“ang1236485556”)
<re.Match object; span=(3, 6), match=‘123’>
re.search(“t|123”,“ang6485556”) 两个都没有就返回None

“(…)” 分组匹配

re.search(“t{2}xx(*|123)”,“ttxx1230000")
<re.Match object; span=(0, 5), match=‘ttxx*’>
re.search(“t{2}xx(**|123)”,"ttxx1230000”)
<re.Match object; span=(0, 6), match=‘ttxx**’>
re.search(“t{2}xx(**|123)”,“txx**1230000”) ；只要一个匹配不上就不行

“A” 只从字符开头匹配

re.search(“At1”,“t1ang”) 就是re.match(“t1”,”t1ang”)
<re.Match object; span=(0, 2), match=‘t1’>
re.search(“At1”,“tang”)

“Z” 匹配字符结尾

re.search(“gZ”,“tang”)
<re.Match object; span=(3, 4), match=‘g’>
re.search(“gZ”,“tan”)
re.search(“AtgZ”,“tang”)
re.search(“AtgZ”,“tang5665”)
re.search(“AtgZ”,“tg5665”)

“d”or [0-9]匹配数字0-9

re.search(“d”,“abc56126”)
<re.Match object; span=(3, 4), match=‘5’>
re.search(“d{3}”,“abc56126”)
<re.Match object; span=(3, 6), match=‘561’>
re.search(“[0-9]{3}”,“abc56126”)
<re.Match object; span=(3, 6), match=‘561’>
re.search(“[0-9]”,“abc56126”)
<re.Match object; span=(3, 4), match=‘5’>
re.search(“[0-9]”,“abc”)

“D” 匹配非数字

re.search(“D”,“abc45123158”)
<re.Match object; span=(0, 1), match=‘a’>
re.search(“D+”,“abc45123158”)
<re.Match object; span=(0, 3), match=‘abc’>

“w” 匹配[A-Za-z0-9]
“W” 匹配非[A-Za-z0-9]

re.findall(“w”,“jjldaslkj153364")
[‘j’, ‘j’, ‘l’, ‘d’, ‘a’, ‘s’, ‘l’, ‘k’, ‘j’, ‘1’, ‘5’, ‘3’, ‘3’, ‘6’, ‘4’]
re.findall(“w+”,"jjldaslkj153364”)
[‘jjldaslkj’, ‘153364’]
re.findall(“W”,“jjldaslkj153364")
['']
re.findall(”W+","jjldaslkj153364")
['']

“s” 匹配空白字符、t、n、r

re.findall(“s”,“j jlndasrlkj1lt53364”)
[’ ‘, ‘n’, ‘r’]
re.findall(“s”,“j jlndasrlkj1lt53364”)
[’ ‘, ‘n’, ‘r’, ‘t’]
re.findall(“s+”,“j jlndasrlkj1lt53364”)
[’ ', ‘n’, ‘r’, ‘t’]

这里科普一下分组匹配，以匹配身份证为例

a = “310226198001062520”
a
‘310226198001062520’
b = re.search(“(?P[0-9]{3})(?P[0-9]{3})(?P[0-9]{8})”,a)
b.group()
‘31022619800106’
b.groups()
(‘310’, ‘226’, ‘19800106’)
b.groupdict() 这里我们可以看到匹配的数据被以字典的形式存放起来了
{‘province’: ‘310’, ‘city’: ‘226’, ‘birth’: ‘19800106’}

接着讲方法
re.split() 以匹配的字符当做列表分隔符

re.split(“d+”,“ahkj0ahfjsl1kajds2kade”)
[‘ahkj’, ‘ahfjsl’, ‘kajds’, ‘kade’]
re.split(“d”,“ahkj0ahfjsl1kajds2kade”)
[‘ahkj’, ‘ahfjsl’, ‘kajds’, ‘kade’]
re.split(“D”,“ahkj0ahfjsl1kajds2kade”)
[‘’, ‘’, ‘’, ‘’, ‘0’, ‘’, ‘’, ‘’, ‘’, ‘’, ‘1’, ‘’, ‘’, ‘’, ‘’, ‘2’, ‘’, ‘’, ‘’, ‘’]
re.split(“D+”,“ahkj0ahfjsl1kajds2kade”)
[‘’, ‘0’, ‘1’, ‘2’, ‘’]

re.sub() 匹配字符并替换