- re.compile(pattern, flags=0)
- re.search(pattern, string, flags=0)
- re.match(pattern, string, flags=0)
- re.fullmatch(pattern, string, flags=0)
- re.split(pattern, string, maxsplit=0, flags=0)
- re.findall(pattern, string, flags=0)
- re.finditer(pattern, string, flags=0)
- re.sub(pattern, repl, string, count=0, flags=0)
- re.subn(pattern, repl, string, count=0, flags=0)
- re.escape(string)
- re.purge()
1.re.compile(pattern, flags=0)
把一个表达式字符串转化成为一个RegexObject
pattern:正则表达式字符，如'\d'
flags:匹配模式,可以使用按位或'|'表示同时生效
匹配模式有：
re.A/re.ASCII:仅执行8位的ASCII码字符匹配
re.DEBUG:查看正则表达式的匹配过程
re.I/re.IGNORECASE:忽略大小写
re.L/re.LOCALE:使预定字符类 \w \W \b \B \s \S 取决于当前区域设定
re.M/re.MULTILINE:多行匹配。当指定时，模式字符' ^'匹配字符串的开头以及每个行的开头（紧接每个换行符）； 模式字符'$'匹配字符串的末尾以及每一行的结尾（紧靠每个换行符之前）。默认情况下， '^'只匹配字符串的开始，'$'只匹配字符串的末尾和字符串末尾换行符（如果有的话）之前的位置。
re.S/re.DOTALL:使.匹配包括换行在内的所有字符
re.X/re.VERBOSE:允许在正则表达式规则中加入注释，但默认会去掉所有空格。
re.U(UNICODE): 使预定字符类 \w \W \b \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'\2\1'): 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',"")
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()
清空缓存中的正则表达式
（此图源自网络，不记得原出处，若侵权，请联系，必马上删除）
