python正则表达式re.match,python re模块详解
摘要：
Re模块包括操作正则表达式的函数，这些函数在一些工作中是需要的。现在，将解释如何使用它们。
使用说明：
首先，re模块下的功能：
功能
形容
编译(模式)
创建架构对象
搜索(模式，字符串)
在字符串中寻找模式
匹配(模式，字符串)
匹配字符串开头的模式。
拆分(模式、字符串)
根据模式拆分字符串
findall(模式，字符串)
以列表形式返回匹配项。
sub(pat，repl，string)
Pat匹配想换成repl。
转义(字符串)
特殊字符转义
1、编译：
进口re
pat=重新编译( A )
m=pat.search(CBA )
打印m
_ sre.sre _ matchobject在0x9d690c8 #匹配，并返回MatchObject(True)
m=pat.search(CBD )
打印m
None #不匹配，返回None(False)
#以上等同于
重新搜索( A ， CBA )
_sre。0xb72cd170处的SRE _匹配对象
#建议使用第一种方法：将正则表达式转换为模式对象，以实现更高效的匹配，因为其他函数会在内部进行转换。
2、搜索：
m=搜索( asd ， ASDasd )
打印m
0xb72cd6e8 #处的_ sre.sre _ matchobject匹配，并返回MatchObject(True)
m=搜索( asd ， ASDASD )
打印m
None #不匹配，返回None(False)。描述：在给定的字符串中查找与正则表达式匹配的第一个子字符串，如果有很多，则只返回第一个匹配项。
3、搭配：
m=重新匹配( a ， Aasd )
打印m
None #不匹配，返回None(False)
m=重新匹配( a ， aASD )
打印m
0xb72cd6e8 #处的_ sre.sre _ matchobject匹配，并返回MatchObject(True)
您可以使用第一种方法：编译
pat=重新编译( a )
printpat.match(Aasd )
没有人
printpat.match(aASD )
_ sre . sre _ match object at0x b 72 CD 6 e 8描述：匹配给定字符串开头的正则表达式。
以上函数返回都可以在if条件语句中判断：
如果pat.search(asd ):
.打印“确定”
.
好的#找到回报
如果重新搜索( a ， ASD ):
.打印“确定”
.# 4未找到，分割：
重新拆分(，， a，s，d，asd )
[a ， s ， d ， asd] #返回一个列表
pat=重新编译(，)
pat.split(a、s、d、asd )
[a ， s ， d ， asd] #返回一个列表
关于。split ([，]， A，S，D，ASD) #正则匹配：[，]，后面解释
[a ， s ， d ， asd]
Re.split ([，]， A，S，D，ASD ，maxsplit=2) # maxsplit最大次数
[a ， s ， d，asd]
Pat=re.pile ([，]) #正则匹配：[，]，后面会解释。
Pat.split (a，s，d，ASD ，maxsplit=2) # maxsplit最大分割数
[a ， s ， d，asd]说明：根据模式的匹配项拆分字符串的方法类似于字符串的拆分方法，但字符串的拆分只能使用定长分隔符，而re.split允许任意长度和任意个数的分隔符。
5、findall:
re.findall(a ， ASDaDFGAa )
[a ， a] #以列表形式返回匹配的字符串。
pat=重新编译( a )
pat.findall(ASDaDFGAa )
[a ， a] #以列表形式返回匹配的字符串。
Pat=re.pile ([A-Z]) #常规匹配：[A-Z]后面是描述。
pat.findall(ASDcDFGAa )
[ASD ， DFGA] #找到匹配的字符串。
pat=re.compile([A-Z])
Pat.findall(ASDcDFGAa) #正则匹配：[A-Z]后面是描述。
[A ， S ， D ， D ， F ， G ， A] #查找匹配的字符串
Pat=re.compile([A-Za-z]) #常规匹配：[A-Za-z]匹配所有单词，后跟指令。
pat.findall(ASDcDFGAa )
[A ， S ， D ， C ， D ， F ， G ， A ， A]说明：以列表形式返回给定模式的匹配项。返回所有匹配的字符串。
6，子：
re( A ， A ， abcasd) #查找A并用A替换它。
AbcAsd
pat=重新编译( a )
pat sub( A ， abcasd )
AbcAsd
#按组更新和替换：
Pat=re.pile (r www \。(.*) \ .{3}) #正则表达式
pat.match(www.dxy.com )。组(1)
dxy
Pat.sub (r \ 1 ， hello，www.dxy.com) #通过正则匹配找到符合规则的“www.dxy.com”，得到group 1字符串替换整个匹配字符串。dxy-www.dxy.com
你好，dxy
pat=re . pile(r (\ w)(\ w )#正则表达式
你好，世界！你好赫兹！
pat.findall(hello world！你好赫兹！)
[(你好,世界),(你好， hz)]
pat sub(r \ 2 \ 1 ，s) #通过正则得到组1(你好),组2(世界),再通过潜水艇去替换。即组一替换组2,组2替换组1,调换位置。
世界你好！"你好!"说明：使用给定的内容替换掉找到的字符串啊-啊
导演(m)
[__class__ ， __copy__ ， __deepcopy__ ， __delattr__ ， __doc__ ， _ _ getattribute _ _ ， __hash__ ， __init__ ， __new__ ， __reduce__ ， __reduce_ex__ ， __repr__ ， __setattr__ ， __sizeof__ ，，， __str__
re.escape(www.dxy.cn )
www\\ .dxy\\ .cn #转义说明：对字符串里面的特殊字符串进行转义。
上面的函数中，只有匹配、搜索有组方法，其他的函数没有。
二，函数的方法：
导演(m)
[
__class__ ， __copy__ ， __deepcopy__ ， __delattr__ ， __doc__ ， __format__ ， __getattribute__ ， __hash__ ， __init__ ， __new__ ，
__reduce__ ， __reduce_ex__ ， __repr__ ， __setattr__ ， __sizeof__ ， __str__ ， __subclasshook__ ，
end ， endpos ， expand ， group ， group ， lastgroup ， lastindex ， pos ， re ， regs ， span ， start ， string
]这里介绍几个：
方法
描述
组
获取子模式（组)的匹配项
开始
给定组匹配项的开始位置
目标
给定组匹配项的结束位置
跨度
给定组匹配项的开始结束位置
pat=re.compile(rwww\ .(.*)\.(.*)) #用()表示一个组，2个组
m=pat.match(www.dxy.com )
m.group() #默认为0,表示匹配整个字符串
www.dxy.com的
m.group(1) #返回给定组一匹配的子字符串
dxy
m组(2)
com
m.start(2) #组2开始的索引
8
万端(2) #组2结束的索引
11
斯潘(2) #组2开始、结束的索引
(8, 11)
m1=pat.search(www.dxy.com )
m1.group()
www.dxy.com的
m1。组(1)
dxy
m1。组(2)
com
m1.start(2)
8三，正则表达式：
1,元字符：
字符
描述。
除换行符外的任意字符
\
转义字符
[.]
字符集合
\d
数字：[0-9]
\D
非数字[^0-9]
\s
空白字符[\t\r\n\f，空格]
\S
非空白字符[^\s]
\w
单词字符[A-Za-z0-9]
\W
非单词字符[^\w]
使用：
# .：通配符
pat=re.compile( . )
pat.match(abc )
_sre .0xb72b6170处的SRE _匹配对象
pat.match(abc ).群组()
一个 #匹配到了首个字符
pat.search(abc ).群组()
一个
pat.match(\n ).group() #换行符匹配出错
回溯（最近一次呼叫):
模块中文件性病的第一行
属性错误：“NoneType”对象没有属性"组"
# : 转义符
pat=re.compile(\ ).)
pat.search(abc.efg ).group() #匹配到。
.
pat.findall(abc.efg) #不用组，返回列表
[.]
# [.] : 集合，匹配里面的任意一个元素
pat=re.compile([abc])
pat.match(axbycz ).群组()
一个
pat.search(axbycz ).群组()
一个
pat.findall(axbycz )
[a ， b ， c]
# \d :数字
pat=re.compile(\d )
pat.search(ax1by2cz3 ).group() #匹配到第一个数字：1,返回
1
pat.match(ax1by2cz3 ).group() #匹配不到（首个不是)返回没有，报错，匹配匹配字符串头
回溯（最近一次呼叫):
模块中文件性病的第一行
属性错误：“NoneType”对象没有属性"组"
pat.findall(ax1by2cz3) #匹配所有的数字，列表返回
[1, 2, 3]
# \D :非数字
pat=re.compile(\D )
pat.match(ax1by2cz3 ).群组()
一个
pat.search(ax1by2cz3 ).群组()
一个
pat.findall(ax1by2cz3 )
[a ， x ， b ， y ， c ， z]
# \s :空白字符：\t 、\r 、\n、空格
pat=re.compile(\s )
pat.findall(\rax1 \nby2 \tcz3 )
[\r ， ， \n ， ， \t]
pat.search(\rax1 \nby2 \tcz3 ).群组()
\r
pat.match(\rax1 \nby2 \tcz3 ).群组()
\r
# \S :非空白字符
pat=re.compile(\S )
pat.search(\rax1 \nby2 \tcz3 ).群组()
一个
pat.findall(\rax1 \nby2 \tcz3 )
[a ， x ， 1 ， b ， y ， 2 ， c ， z ， 3]
# \w :单词字符，数字和字母：[A-Za-z0-9]
pat=re.compile(\w )
pat.search(1a2b3c )。群组()
1
pat.findall(1a2b3c )
[1 ， a ， 2 ， b ， 3 ， c]
pat.match(1a2b3c )。群组()
1
# \W :除数字和字母以外的非文字字符
pat=re.compile(\W )
Pat.findall(1a2 I b3c )
[\xe6 ， \x88 ， \x91]
Pat.search(1a2 I b3c )。群组()
\xe62，量词：会出现贪婪模式。
数量词
形容
*
匹配前一个字符0次或更多次。
匹配前一个字符一次或多次。
？
匹配前一个字符0次或1次
{m}
匹配前一个字符m次
{m，n}
匹配前一个字符m到n次。
量词？
非贪婪模式
使用：
# *: 0次或多次
pat=re.compile([abc]* )
pat.match(abcabcdefabc )。群组()
Abcabc #2次
pat.search(abcabcdefabc )。群组()
Abcabc #2次
pat.findall(abcabcdefabc )
[abcabc ，，，， abc ，] #2次和1次，因为有0次，所以匹配
# :一次或多次
pat=re.compile([abc])
pat.match(abcdefabcabc )。群组()
abc
pat.search(abcdefabcabc )。群组()
abc
pat.findall(abcdefabcabc )
[abc ， abcabc]
# ?:0次或1次，匹配，搜索将不会显示无，而是
pat=re.compile([abc]？)
Pat.match(defabc )。group() #0次
pat.match(abcdefabc )。群组()
一个
Pat.search(defabc )。group() #0次
Pat.findall(defabc) #0次和1次
[，， ， a ， b ， c ， ]
#“{ m }”:匹配字符串出现m次。
Pat=re.pile ([op] {2}) # o或p出现两次。
Pat.search (abcoapp )。group () #匹配第一次出现的字符串，O出现在p之前。
“呜”
Pat.findall (abcoopapp) #匹配所有出现的字符串，并以列表形式返回它们。
[oo ， pp]
# {m，n} :匹配字符串出现m到n次。
Pat=re.pile ([op] {2，4}) # o或p出现2或4次。
pat . match( ppbabcooapp )。Group () #匹配开头
“购买力平价”
pat . search( ppbabcooapp )。Group () #第一次匹配。
“购买力平价”
Pat.findall(pppabcooapp) #匹配所有
[ppp ， oo ， pp]
# 量词？:非贪婪模式：只匹配最少的(尽量少)；默认贪婪模式：匹配最多的模式(尽可能多)
Pat=re.pile ([ABC]) #贪婪模式
pat . match( abcdef ABC ABC )。group () #尽可能多的匹配：abc
abc
pat . match( bbabcdefabc )。群组()
bbabc
pat . search( dbbabcdefababc )。群组()
bbabc
pat.findall(abcdefabcabc )
[abc ， abcabc]
pat=re.compile([abc]？)#非贪婪模式：
pat . match( abcdef ABC ABC BC )。group () #尽可能少的匹配：A，B，c。
一个
pat . search( dbbabcdefababc )。群组()
b
pat.findall(abcdefabcabc )
[A ， B ， C ， A ， B ， C] 3，边界
边界词
形容
^
匹配字符串的开头和行的开头。
$
匹配字符串结尾和行结尾
\A
匹配字符串开始
\Z
匹配字符串结尾
\b
\w和\W之间的匹配
使用：
# :匹配字符串的开头或行的开头。
Pat=re.pile ([abc]) #以abc开头。
pat.search(defabc )。群组()
Pat.match(defabc )。找不到组()#。
pat.findall(defabc )
[]
pat.search(adefabc )。群组()
一个
Pat.match(adefabc )。group() #以A、B、c中的任意一个开头。
一个
帕特芬达尔( adefabc )
[a]
Pat=re.pile ([ABC]) #以A、B和c中任意一个的一次或多次开始，Greed:匹配多个。
pat.findall(cbadefab )
[cba]
帕特=re.compile(r^[abc]？”)#以A、B、C中任意一个的一次或多次开始，不贪心：匹配一个
pat.findall(cbadefab )
[c]
# $ :匹配字符串的结尾或行的结尾。
pat=re.compile([abc]$ )
专利匹配( adefabc )。group () # match匹配字符串的开头，因此在查找$时，它总是返回None。
Pat.search(adefAbc )。group() #以A、B、c中的任意一个结尾。
c
帕特芬达尔( adefAbc )
[c]
pat=re.compile([abc] $ )
Pat.search(adefAbc )。group() #以A、B、c中任意一个的一次或多次结束贪婪：匹配多个。
公元前
帕特芬达尔( adefAbc )
[公元前]
# \A :匹配字符串的开头
pat=re.compile(\A[abc])
pat.findall(cbadefab )
[cba]
pat.search(cbadefab )。群组()
cba
# \Z :匹配字符串的结尾
pat=re.compile([abc] \Z )
pat.search(cbadefab )。群组()
ab
pat.findall(cbadefab )
[ab]4、分组：这里有个例子：
分组方法
形容
任何表达式都可以匹配到左边或右边。如果成功，它将向右跳过匹配。
如果不包含在()中，则匹配整个正则表达式。
（.)
匹配，从左到右，每遇到一个(1号，分组后可以加量词。
(?p名称.)
除了分组序号之外，还要指定一个别名名称。
\数字
具有参考编号的分组所匹配的字符串。
(?p=姓名)
别名为的数据包所引用的字符串匹配。
使用：
# (.)’:在模式中使用()表示分组(匿名分组)，适合提取目标字符串的某些部分。
pat=re . pile(r (A)\ w(c))# \ w:word characters[A-Za-z0-9]
pat.match(abcdef )。群组()
abc
Pat=re.compile((a)b(c)) #分成2组，匿名分组。
Pat.match(abcdef )。group() #默认情况下返回匹配的字符串。
abc
Pat.match(abcdef )。group(1) #取组1，适用于搜索。
一个
Pat.match(abcdef )。group(2) #取group 2，适用于搜索。
c
Pat.match(abcdef )。groups() #接受所有的组，并将它们作为元组返回。
( a ， c) pat=re.compile(rwww\(.*)\.{3})
pat.match(www.dxy.com )。组(1)
dxy
# (?p名称.):在模式中使用()表示分组(命名分组)，适用于提取目标字符串的某些部分。
pat=re.compile(r (？P a) \ w (c)) #分为2组：命名组和匿名组。
Pat.search(abcdef )。groups() #接受所有的组，并将它们作为元组返回。
(甲，丙)
Pat.search(abcdef )。group(1) #取group 1，适用于match。
一个
Pat.search(abcdef )。group(2) #取group 2，适用于match。
c
Pat.search(abcdef )。group() #默认情况下返回匹配的字符串。
abc
专利搜索( abcdef )。groupdict () #命名分组可以返回一个字典【专有】，匿名分组则不能。
{K: a}
# (?P=name):引用命名分组(别名)匹配：
pat=re.compile(r (？P K a)\w(c)(？P=K)) #(？P=K)参考数据包1的值，即a。
Pat.search(abcdef )。group() #无法匹配，因为完整的 a\wca ，模式的第4位是a。
回溯(最近一次呼叫):
模块中文件 stdin 的第1行
attribute error:“NoneType”对象没有属性“group”
Pat.search(abcadef )。group() #匹配，模式的第4位与group 1相同，其值为c。
abca
pat.search(abcadef )。组()
(甲，丙)
pat.search(abcadef )。组(1)
一个
pat.search(abcadef )。第二组
c
# \ number :参考分组编号匹配：
pat=re.compile(r (？P K a)\w(c)(？p=K)\ 2’)# \ 2指的是包2的值，是c。
Pat.findall(Aabcadef) #无法匹配，因为完整的 a\wcac ，模式的第5位是c。
[]
Pat.findall(Aabcacdef) #匹配，模式的第5位与group 2相同，其值为c。
[(a ， c)]
pat.search(Aabcacdef )。组()
(甲，丙)
pat.search(Aabcacdef )。群组()
abcac
pat.search(Aabcacdef )。组(1)
一个
pat.search(Aabcacdef )。第二组
C5，特殊结构
方法
形容
(?)
（.)未分组的版本，习惯用或后跟量词。
(?iLmsux)
iLmsux的每个字符代表一个匹配模式，只能用在正则表达式的开头，可以选择多个。
(?#.)
#后面的内容将作为评论。
(?=.)
之后，字符串内容需要一个匹配表达式才能匹配成功。
(?)
之后，字符串与表达式不匹配。
(?=.)
前面的字符串需要一个匹配的表达式才能成功。
(?)
前面的字符串需要一个不匹配的表达式才能成功。
(?(id/name)是否)
如果id/name组匹配字符串，则需要匹配yes，否则可以省略。
使用：
# (?)’:()有吗？指示此()不是分组。
pat=re.compile(ra(？bc))
帕特芬达尔( abc )
[abc]
Pat.match(abc )。groups() #无法显示分组
()
# (?=.):匹配.表达式和返回。匹配后，总是匹配后。
pat=re.compile(r\w(？=\d)) #匹配表达式\d，返回数字的第一个数字，\w: word字符[A-Za-z0-9]
pat.findall(abc1 def1 xyz1 )
[c ， f ， z]
pat . find all( zhoujy 2013 06 28 Hangzhou )#匹配数字的第一个数字，列表返回
[y ， 2 ， 0 ， 1 ， 3 ， 0 ， 6 ， 2]
pat=re.compile(r\w(？=\d))
Pat.findall(abc1，def1，xyz1) #匹配最后一个数字的第一个字符串，列表返回
[abc ， def ， xyz]
pat.findall(abc21，def31，xyz41 )
[abc2 ， def3 ， xyz4]
pat . find all( zhoujy 2013 06 28杭州)
[周jy2013062]
pat=re.compile(r[A-Za-z](？=\d)) #[A-Za-z]，匹配字母，可以用其他常规方法。
pat . find all( zhoujy 20130628 Hangzhou 123 )#匹配后面有数字的字符串，列表返回
[zhoujy ，杭州]
pat.findall(abc21，def31，xyz41 )
[abc ， def ， xyz]
# (?)”与.表达式，并返回。之后匹配。
pat=re.compile(r[A-Za-z](？\d)) #[A-Za-z]，匹配字母，可以使用其他常规方法
pat . find all( Zhou jy 20130628 Hangzhou 123，12，binjiang310) #匹配后面没有数字的字符串，列表返回
[周，杭，宾剑]
pat.findall(abc21，def31，xyz41 )
[ab ， de ， xy]
# (?=.):匹配.表达式和返回。配合前面，永远配合前面。
pat=re.compile(r (？=\d)[A-Za-z] ) #匹配以数字开头的字母
pat.findall(abc21，def31，xyz41 )
[]
专利findall(1abc21，2def31，3xyz41 )
[abc ， def ， xyz]
pat . find all( zhoujy 20130628 Hangzhou 123，12，binjiang310 )
[杭州]
# (?)“”:不匹配.表达式，并返回。配合前面，永远配合前面。
pat=re.compile(r (？\d)[A-Za-z] ) #匹配前面没有数字的字母
pat.findall(abc21，def31，xyz41 )
[abc ， def ， xyz]
pat . find all( zhoujy 20130628 Hangzhou 123，12，binjiang310 )
[周，周昂，滨江]
#(?(id/name) yes no):该组是否匹配，匹配将被返回。
pat=re.compile(ra(\d)？公元前(？(1)\d)) #no省略，完整的是a\dbc\d==a2bc3，共5位。第二个数字是可选数字，第五个数字是数字。
Pat.findall(abc9) #返回组1，但第2位(组1)不返回，即
[]
Pat.findall(a8bc9) #完整模式，返回组1
[8]
pat.match(a8bc9 )。群组()
a8bc9
pat.match(a8bc9 )。组(1)
8
Pat.findall(a8bc) #第5位不存在，所以没有匹配。
[]
#(?ILmsux):这里是I参数：区分大小写的匹配。
pat=re.compile(rabc )
帕特芬达尔( abc )
[abc]
帕特芬达尔( ABC )
[]
pat=re.compile(r (？i)abc) #(？I)不区分大小写
帕特芬达尔( ABC )
[ABC]
帕特芬达尔( abc )
[abc]
帕特芬达尔( aBc )
[aBc]
帕特芬达尔( aBC )
[aBC]
Pat=re。堆(r ABC ，re。我)# re。建议将I作为参数。
帕特芬达尔( aBC )
[aBC]
帕特芬达尔( abc )
[abc]
帕特芬达尔( ABC )
[ABC]摘要：
正则表达式的功能很强大，上面写的只是一点点的知识。有关更多信息，请参见：
以上结束！
~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~在所有的事物中，我希望自己是最美的~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
转载请联系作者获得授权，否则将追究法律责任。
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。