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 匹配任意空白字符，等价于 [\t\n\r\f]。
\S 匹配任意非空字符
\d 匹配任意数字，等价于 [0-9]。
\D 匹配任意非数字
\A 匹配字符串开始
\Z 匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。
\z 匹配字符串结束
\G 匹配最后匹配完成的位置。
\b 匹配一个单词边界，也就是指单词和空格间的位置。例如， ‘er\b’ 可以匹配"never” 中的 ‘er’，但不能匹配 “verb” 中的 ‘er’。
\B 匹配非单词边界。‘er\B’ 能匹配 “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.Matchobject;span=(0,4),match=′tang′>re.search("tang","tang") 以t开头以g结尾 <re.Match object; span=(0, 4), match='tang'> re.search("^tang","tang")以t开头以g结尾<re.Matchobject;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(“g\Z”,“tang”)
<re.Match object; span=(3, 4), match=‘g’>
re.search(“g\Z”,“tan”)
re.search(“\Atg\Z”,“tang”)
re.search(“\Atg\Z”,“tang5665”)
re.search(“\Atg\Z”,“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 jl\ndas\rlkj1lt53364”)
[’ ‘, ‘\n’, ‘\r’]
re.findall(“\s”,“j jl\ndas\rlkj1l\t53364”)
[’ ‘, ‘\n’, ‘\r’, ‘\t’]
re.findall(“\s+”,“j jl\ndas\rlkj1l\t53364”)
[’ ', ‘\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() 匹配字符并替换

re.sub(“\w+”,"++",“hkdsad?#13326@ADAFA”(,count)) 其实还有个count默认是修改全部，你可以自定义次数
'++?#++@++’

re.fullmatch() 全部匹配（不常用，可以忽略）
re.compile() 编译正则表达式，提供match和search

p = re.compile(“\d+”)
p.search(“4654651adasd*/4545/”)
<re.Match object; span=(0, 7), match=‘4654651’>

flags 标志位
re.I 忽略大小写

re.search(“[A-Z]”,“adsadsa”,re.I)
<re.Match object; span=(0, 1), match=‘a’>

re.M 多行模式

re.search(“^0[0-9]w$”,“a01266wokm6”)

re.search(“^0[0-9]+w$”,“a\n01266w\nokm6”,re.M)
<re.Match object; span=(2, 8), match=‘01266w’>

re.S 改变”.”的行为

re.search(“.”,“\n*?”)
<re.Match object; span=(1, 2), match=‘'>
re.search(“.”,"\n?",re.S)
<re.Match object; span=(0, 1), match=’\n’> 可以看到它可以匹配到原来不可以的换行符了

re.X 用来写注释的（基本不用）

python 如何使用正则表达式相关推荐

Python中re(正则表达式)模块函数学习
2019独角兽企业重金招聘Python工程师标准>>> Python正则表达式指南今天学习了Python中有关正则表达式的知识.关于正则表达式的语法,不作过多解释,网上有许多学习的 ...
Python字符串和正则表达式中的反斜杠(‘\‘)问题
在Python普通字符串中在Python中,我们用''来转义某些普通字符,使其成为特殊字符,比如 In [1]: print('abc\ndef') # '\n'具有换行的作用 abc defgIn ...
Python高级语法-正则表达式
正则表达式在字符串匹配中起到巨大的作用. 简介几个数据提取工具对比: re(正则表达式):速度很快,难度高(语法难记),不需要安装(python标准库内置) bs(BeautifulSoup):速度 ...
python里面的正则表达式_Python中的正则表达式
以下内容转自:http://www.cnblogs.com/huxi/archive/2010/07/04/1771073.html 1. 正则表达式基础 1.1. 简单介绍正则表达式并不是Pyth ...
[Python]网络爬虫（七）：Python中的正则表达式教程(转)
接下来准备用糗百做一个爬虫的小例子. 但是在这之前,先详细的整理一下Python中的正则表达式的相关内容. 正则表达式在Python爬虫中的作用就像是老师点名时用的花名册一样,是必不可少的神兵利器. ...
[Python]网络爬虫（七）：Python中的正则表达式教程
接下来准备用糗百做一个爬虫的小例子. 但是在这之前,先详细的整理一下Python中的正则表达式的相关内容. 正则表达式在Python爬虫中的作用就像是老师点名时用的花名册一样,是必不可少的神兵利器. ...
python中的正则表达式是干嘛的_python中正则表达式总结
re.match():从字符串的开始进行匹配 re.search():扫描整个字符串返回第一个匹配 re.findAll():返回所有匹配的字符串 Pattern 对象不能实例化,只能通过compil ...
python里面的正则表达式
python里面的正则表达式与php稍显不同:1.表达式不用/开头和结尾,若是加上/会报错.2.python里面的匹配结果在a.group()中,类似与php preg_match函数里面的$matc ...
python 学习总结----正则表达式
python 学习总结----正则表达式正则表达式应用场景- 特定规律字符串的查找,切割,替换 - 邮箱格式:URl,IP地址等的校验 - 爬虫项目中,特定内容的提取使用原则- 只要使用字符串等函数 ...
【Python笔记】正则表达式
正则表达式行定位符元字符限定符字符类排除字符选择字符转义字符分组在 Python 中使用正则表达式语法行定位符行定位符就是用来描述子串的边界. "^" 表示行 ...

python 如何使用正则表达式

python 如何使用正则表达式相关推荐

最新文章

热门文章