re模块中常用功能函数

一、加载模块　　

import re

二、编译正则表达式

re.compile(pat, flags = 0) #把一个正则表达式pat编译成正则对象并返回，以便可以用正则对象的match和search等方法。

pat 编译时，正则表达式字符串

flags 编译标志位，用于修改正则表达式的匹配方式，如：是否区分大小写，多行匹配等。常用的flags有：

re.I
re.IGNORECASE让正则表达式忽略大小写，这样一来，[A-Z]也可以匹配小写字母了。此特性和locale无关。
re.L
re.LOCALE
让\w、\W、\b、\B、\s和\S依赖当前的locale。
re.M
re.MULTILINE
影响'^'和'$'的行为，指定了以后，'^'会增加匹配每行的开始（也就是换行符后的位置）；'$'会增加匹配每行的结束（也就是换行符前的位置）。
re.S
re.DOTALL
影响'.'的行为，平时'.'匹配除换行符以外的所有字符，指定了本标志以后，也可以匹配换行符。
re.U
re.UNICODE
让\w、\W、\b、\B、\d、\D、\s和\S依赖Unicode库。
re.X
re.VERBOSE
运用这个标志，你可以写出可读性更好的正则表达式：除了在方括号内的和被反斜杠转义的以外的所有空白字符，都将被忽略，而且每行中，一个正常的井号后的所有字符也被忽略，这样就可以方便地在正则表达式内部写注释了。

a = re.compile(r"""\d +  # the integral part\.    # the decimal point\d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
re.search(pattern, string[, flags])

三、搜索，执行功能函数

1、贪婪与非贪婪搜索

　　*'，'+'和'?'（*?, +?, ??, {m,n}?）都是贪婪的，匹配尽可能多的模式字符串；可以在后面加个问号，将贪婪改为非贪婪，只匹配尽量少的模式字符串。

2、匹配分组：（...）

　　匹配圆括号里的RE匹配的内容，并指定组的开始和结束位置。组里面的内容可以被提取（0代表所有匹配内容，n代表第n个分组匹配内容），也可以采用\number这样的特殊序列，被用于后续的匹配。要匹配字面意义上的'('和')'，可以用反斜杆转义：\(、\)，或是包含在反括号内：[(]、[)]。

3、搜索匹配

3.1 re.match和re.search

　　re.match(pat, string[, flags = 0])

　　如果字符串string的开头和正则表达式pat匹配的话，返回一个相应的MatchObject的实例，否则返回None

　　re.search(pat, string[, flags = 0])

　　在字符串内查找模式匹配（不一定是string开头），只要找到第一个匹配就返回一个相应的MatchObject的实例，否则返回None。

　　注：MatchObject对象有以下方法：

　　1⃣️m.group() 不加参数，返回re整体匹配的字符串；

　　2⃣️m.group(n, m) 返回一个或多个子组。如果参数为一个，就返回一个子串；如果参数有多个，就返回多个子串注册的元组。如果不传任何参数，效果和传入一个0一样，将返回整个匹配。如果某个groupN未匹配到，相应位置会返回None。如果某个groupN是负数或者大于group的总数，则会抛出IndexError异常。

　　3⃣️m.start([group])和m.end([group]) 返回的是被组group匹配到的子串在原字符串中的位置。如果不指定group或group指定为0，则代表整个匹配。如果group未匹配到，则返回 -1。

　　　　对于指定的m和g，m.group(g)和m.string[m.start(g):m.end(g)]等效。
　　　　如果group匹配到空字符串，m.start(group)和m.end(group)将相等。

　　4⃣️m.span([group]) 返回一个元组，包含匹配 (开始,结束) 的位置

　　5⃣️m.groups() 返回一个包含正则表达式中所有小组字符串的元组，从 1 到所含的小组号，通常groups()不需要参数，返回一个元组，元组中的元就是正则表达式中定义的组。

3.2 re.findall(pat, string, flags = 0)

　　遍历匹配，可以获取字符串中所有匹配的字符串，返回一个列表。

import re
tt = "Tina is a good girl, she is cool, clever, and so on..."
rr = re.compile(r'\w*oo\w*')
print(rr.findall(tt))
print(re.findall(r'(\w)*oo(\w)',tt))#()表示子表达式
执行结果如下：
['good', 'cool']
[('g', 'd'), ('c', 'l')]

3.3 re.finditer(pat, string, flags = 0)

　　搜索string，返回一个顺序访问每一个匹配结果（Match对象）的迭代器。找到 RE 匹配的所有子串，并把它们作为一个迭代器返回。

iter = re.finditer(r'\d+','12 drumm44ers drumming, 11 ... 10 ...')
for i in iter:print(i)print(i.group())print(i.span())
执行结果如下：
<_sre.SRE_Match object; span=(0, 2), match='12'>
(0, 2)
<_sre.SRE_Match object; span=(8, 10), match='44'>
(8, 10)
<_sre.SRE_Match object; span=(24, 26), match='11'>
(24, 26)
<_sre.SRE_Match object; span=(31, 33), match='10'>
(31, 33)

3.4 re.split(pat, string[, maxsplit])

　　按照能够匹配的子串将string分割后返回列表。可以使用re.split来分割字符串，如：re.split(r'\s+', text)；将字符串按空格分割成一个单词列表。maxsplit用于指定最大分割次数，不指定将全部分割。

3.5 re.sub(pat, repl, string[, count])

　　将string里，匹配pat的部分，用repl替换掉，最多替换count次（剩余的匹配将不做处理），然后返回替换后的字符串。如果string里没有可以匹配pattern的串，将被原封不动地返回。repl可以是一个字符串，也可以是一个函数。

　　如果repl是个函数，每次pattern被匹配到的时候，都会被调用一次，传入一个匹配到的MatchObject对象，需要返回一个字符串，在匹配到的位置，就填入返回的字符串。

>>> def dashrepl(matchobj):
...     if matchobj.group(0) == '-': return ' '
...     else: return '-'
>>> re.sub('-{1,2}', dashrepl, 'pro----gram-files')
'pro--gram files'

　　re.subn(pattern, repl, string[, count]) 跟上面的sub()函数一样，只是它返回的是一个元组 (新字符串, 匹配到的次数)