python 正则表达式 RE模块汇总记录

1. re.compile(pattern, flags=0)
2. re.search(pattern, string, flags=0)
3. re.match(pattern, string, flags=0)
4. re.fullmatch(pattern, string, flags=0)
5. re.split(pattern, string, maxsplit=0, flags=0)
6. re.findall(pattern, string, flags=0)
7. re.finditer(pattern, string, flags=0)
8. re.sub(pattern, repl, string, count=0, flags=0)
9. re.subn(pattern, repl, string, count=0, flags=0)
10. re.escape(string)
11. re.purge()

1.re.compile(pattern, flags=0) 

　　把一个表达式字符串转化成为一个RegexObject

　　pattern:正则表达式字符，如'd'

　　flags:匹配模式,可以使用按位或'|'表示同时生效

　　匹配模式有：

1. re.A/re.ASCII:仅执行8位的ASCII码字符匹配

2. re.DEBUG:查看正则表达式的匹配过程

3. re.I/re.IGNORECASE:忽略大小写

4. re.L/re.LOCALE:使预定字符类 w W  B s S 取决于当前区域设定

5. re.M/re.MULTILINE:多行匹配。当指定时，模式字符' ^'匹配字符串的开头以及每个行的开头（紧接每个换行符）； 模式字符'$'匹配字符串的末尾以及每一行的结尾（紧靠每个换行符之前）。默认情况下， '^'只匹配字符串的开始，'$'只匹配字符串的末尾和字符串末尾换行符（如果有的话）之前的位置。

6. re.S/re.DOTALL:使.匹配包括换行在内的所有字符

7. re.X/re.VERBOSE:允许在正则表达式规则中加入注释，但默认会去掉所有空格。

8. re.U(UNICODE): 使预定字符类 w W  B s S d D 取决于unicode定义的字符属性

   例子：

a = re.compile(r"""d +  # the integral part
                    .    # the decimal point
                    d *  # some fractional digits""", re.X)
4 b = re.compile(r"d+.d*")

      以上a等价于b

import re
s="123abc45AB"
reg=re.compile('a',re.I)
reg.findall(s)

　　输出：

　　['a','A']

 2.re.search(pattern, string, flags=0)

　　pattern:正则表达式模式字符串，如'd'

　　string:要匹配的字符串

　　flags:匹配模式,可以使用按位或'|'表示同时生效

　　将字符串的所有字符尝试与正则表达式匹配，如果匹配成功，返回matchobject，否则返回None.若有多个匹配成功，只返回第一个匹配结果。matchobject有多个属性和方法。

import re
m= re.search(r'(d+)w(d+)', 'ab12c34d56')
print("m.string:", m.string)
print("m.re:", m.re)
print("m.pos:", m.pos)
print("m.endpos:", m.endpos)
print("m.lastindex:", m.lastindex)
print("m.lastgroup:", m.lastgroup)
print("m.group(1,2):", m.group(1, 2))
print("m.groups():", m.groups())
print("m.groupdict():", m.groupdict())
print("m.start(2):", m.start(2))
print("m.end(2):", m.end(2))
print("m.span(2):", m.span(2))
print("m.expand(r'\2\1'):", m.expand(r'2 1'))
#
#m.string: ab12c34d56
#m.re: re.compile('(\d+)\w(\d+)')
#m.pos: 0                   #代表RE开始搜索字符串的位置。
#m.endpos: 10               #代表RE搜索字符串的结束位置。
#m.lastindex: 2             #最后一次匹配到的组的数字序号，如果没有匹配到，将得到None
#m.lastgroup: None          #最后一次匹配到的组的名字，如果没有匹配到或者最后的组没有名字，将得到None。 
#m.group(1,2): ('12', '34') #返回一个或多个子组,如果不传任何参数，效果和传入一个0一样，将返回整个匹配。
#m.groups(): ('12', '34')  #返回一个由所有匹配到的子串组成的元组。
#m.groupdict(): {} 　　　　#返回一个包含所有命名组的名字和子串的字典
#m.start(2): 5       #返回被组group匹配到的子串在原字符串中的开始位置。如果不指定group或group指定为0，则代表整个匹配。如果group未匹配到，则返回 -1。
#m.end(2): 7         #返回被组group匹配到的子串在原字符串中的后一个位置
#m.span(2): (5, 7)   #返回一个元组： (m.start(group), m.end(group))
#m.expand(r'21'): 34 12

3.re.match(pattern, string, flags=0)

 　　参数同re.search

　　在字符串开头匹配，其他re.search一致。不同的是如果匹配的字符不在字符串开头，re.search可以寻到，re.match不可以。

4.re.fullmatch(pattern, string, flags=0)

　　如果模式完全匹配字符串，则返回一个matchobject,不匹配则返回None

import re
m1=re.fullmatch(r'd',"3")
print('m1.group():', m1.group())
print('m1.groups():', m1)
#
#m1.group(): 3
#m1.groups(): <_sre.SRE_Match object; span=(0, 1), match='3'>

m1=re.fullmatch(r'd',"3d")
print('m1.groups():', m1)
#
#m1.groups(): None

5.re.split(pattern, string, maxsplit=0, flags=0)

　　maxsplit：分割次数

　　其他参数同上

　　通过正则表达式将字符串分割，匹配到符合的字符就把字符串分割一次，maxsplit没有赋值，找到几个匹配项就分割几次，若maxsplit赋值小于匹配项个数，则分割maxsplit次。返回一个list。

import re
print("re.split('d','ab12c4d56d'):",re.split('d','ab12c4d56d'))
print("re.split('d','ab12c4d56d'):",re.split('d','ab12c4d56d',3))
print("re.split('d','ab12c4d56d'):",re.split('d','ab12c4d56d',2))
#
#re.split('d','ab12c4d56d'): ['ab', '', 'c', 'd', '', 'd']
#re.split('d','ab12c4d56d'): ['ab', '', 'c', 'd56d']      
#re.split('d','ab12c4d56d'): ['ab', '', 'c4d56d']  

6.re.findall(pattern, string, flags=0)

7.re.finditer(pattern, string, flags=0)

　　查找整个字符串，返回所有的匹配项。参数与re.search一致。

　　re.search和re.match只会返回一个匹配项，而re.findall和re.finditer返回所有匹配项。

　　re.findall返回一个列表，包含所有匹配项。

　　re.finditer返回一个迭代器。

import re
m1= re.findall(r'd+', 'ab12c12d56e7')
print("m1:", m1)

m2= re.finditer(r'd+', 'ab12c12d56e7')
print("m2:", m2)

#
#m1: ['12', '12', '56', '7']
#m2: <callable_iterator object at 0x000000000112EE80>

 

8.re.sub(pattern, repl, string, count=0, flags=0)

9.re.subn(pattern, repl, string, count=0, flags=0)

　　pattern:表示需要匹配的正则表达式模式字符，匹配到的字符将会被替换

　　repl：表示替换的字符串，可以是字符串，也可以是函数

　　string:要被处理的字符串

　　count:替换次数

　　把string中所有符合pattern的字符串，替换成repl，count如赋值小于匹配项个数，则把前count个匹配项替换掉，其他字符不变。

　　re.sub返回完成替换之后的字符串。

　　re.subn返回元组，（完成替换之后的字符串，替换次数）。

　　(特殊情况：如果匹配不到，则返回原字符串）

　　

import re
s1=re.sub(r'd','w','qqq12q3',1)
print("s1:", s1)
s2=re.subn(r'd','w','qqq12q3',1)
print("s2:", s2)
#
#s1: qqqw2q3
#s2: ('qqqw2q3', 1)

s1=re.sub(r'd','w','qqq12q3')
print("s1:", s1)
s2=re.subn(r'd','w','qqq12q3')
print("s2:", s2)
#
#s1: qqqwwqw
#s2: ('qqqwwqw', 3)
#---------sub利用函数替换----------
s3=re.sub('d',lambda m:'-'+m.group(0)+'-','sd1w2ed3e4') #在数字前后加上'-'

print('s3=',s3)
#
#s3='sd-1-w-2-ed-3-e-4-'

 10.re.escape(string)

　　　对string字符串中的除了字母数字以外所有字符进行转义，都加上反斜杆。

import re
s=re.escape('a1.*@')
print("s:", s)
#
#s: a1.*@

11.re.purge()

 　　清空缓存中的正则表达式

（此图源自网络，不记得原出处，若侵权，请联系，必马上删除）