正则表达式(2) re模块：核心函数和方法

1.re.compile()函数

描述：使用任何可选的标记来编译正则表达式的模式，然后返回一个正则表达式对象。
在模式匹配发生前，正则表达式模式必须编译成正则表达式对象。由于正则表达式在执行过程中将进行多次比较操作，因此强烈建议预编译。re.compile()能够提供此功能。
虽然推荐预编译，但是它不是必须的。如果需要编译，就使用编译过的方法；如果不需要编译，就使用函数。不管使用函数还是方法，它们的名字都是相同的，如search()、match()。
当使用re.compile()函数进行编译后，re.search(pattern,string)的调用方法就转换成pattern.search(string)的调用方法了。

2.re模块函数和正则表达式对象的方法

函数/方法	描述
match(pattern, string, flags=0)	尝试使用带有可选的标记的正则表达式的模式来匹配字符串。如果匹配成功，就返回匹配对象；否则就返回None
search(pattern, string, flags=0)	使用可选标记搜索字符串中第一次出现的正则表达式模式。如果匹配成功，就返回匹配对象；否则就返回None
findall(pattern, string[, flags])	查找字符串中所有(非重复)出现的正则表达式模式，并返回一个匹配列表
finditer(pattern, string[, flags])	与findall()函数相同，但返回的不是一个列表，而是一个迭代器。对于每一次匹配，迭代器都返回一个匹配对象
split(pattern, string, ,max=0)	根据正则表达式的模式分隔符，split函数将字符串分割为列表，然后返回成功匹配的列表，分割最多操作max次(默认分割所有匹配成功的位置)

2.1. 使用match()方法匹配字符串

match()函数试图从字符串的起始部分对模式进行匹配。如果匹配成功，就返回一个匹配对象；如果匹配失败，就返回None，匹配对象的group()方法能够用于显示那个成功的匹配。

2.2. 使用search()在一个字符串中查找模式

search()会用它的字符串参数，在任意位置对给定正则表达式模式搜索第一次出现的匹配情况。如果搜索成功，就返回一个匹配对象；否则，返回None。

2.3. 使用findall()和finditer()查找每一次出现的位置

对于一个成功的匹配，每个子组匹配是由findall()返回的列表中的单一元素；对于多个成功的匹配，每个子组匹配是返回的元组中的单一元素，而且每个元组(每个元组都对应一个成功的匹配)是结果列表中的元素。
示例代码如下：

# 单个匹配
>>> s = 'This and that.'
>>> re.findall(r'(th\w+)',s,re.I)
['This', 'that']
>>> it = re.finditer(r'(th\w+)',s,re.I)
>>> g = it.__next__()
>>> g.groups()
('This',)
>>> g.group(1)
'This'
>>> g = it.__next__()
>>> g.groups()
('that',)
>>> g.group(1)
'that'
>>> [g.group(1) for g in re.finditer(r'(th\w+)',s,re.I)]
['This', 'that']

# 多个匹配
>>> s = 'This and that.'
>>> re.findall(r'(th\w+) and (th\w+)',s,re.I)
[('This', 'that')]
>>> re.finditer(r'(th\w+) and (th\w+)',s,re.I).__next__().groups()
('This', 'that')
>>> re.finditer(r'(th\w+) and (th\w+)',s,re.I).__next__().group(1)
'This'
>>> re.finditer(r'(th\w+) and (th\w+)',s,re.I).__next__().group(2)
'that'
>>> [g.groups() for g in re.finditer(r'(th\w+) and (th\w+)',s,re.I)]
[('This', 'that')]

2.4. 在限定模式上使用split()分隔字符串

如果给定分隔符不是使用特殊符号来匹配多重模式的正则表达式，那么re.split()与str.split()的工作方式相同，如下所示：

>>> import re
>>> re.split(':','str1:str2:str3')
['str1', 'str2', 'str3']

当情况更复杂时，示例代码如下：

>>> import re
>>> DATA = (
... 'Mountain View, CA 94040',
... 'Sunnyvale, CA',
... 'Los Altos, 94023',
... 'Cupertino 95014',
... 'Palo Alto CA',
... )
>>> for datum in DATA:
...     print(re.split(', |(?= (?:\d{5}|[A-Z]{2})) ',datum))
...
['Mountain View', 'CA', '94040']
['Sunnyvale', 'CA']
['Los Altos', '94023']
['Cupertino', '95014']
['Palo Alto', 'CA']

3.re模块函数和正则表达式对象方法

函数/方法	描述
sub(pattern, repl, string, count=0)	使用repl替换所有正则表达式的模式在字符串中出现的位置，除非定义count，否则就将替换所有出现的位置
purge()	清除隐式编译的正则表达式模式

3.1使用sub()和subn()搜索与替换

示例代码如下：

>>> import re
>>> re.sub('[ae]','X','abcdef')
'XbcdXf'
>>> re.subn('[ae]','X','abcdef')
('XbcdXf', 2)

使用匹配对象的group()方法除了能够取出匹配分组编号外，还可以使用\N,其中N是在替换字符串中使用的分组编号。下面是将美式日期表示法MM/DD/YY{,YY}格式转换为其他国家常用的DD/MM/YY{,YY}。
示例代码如下：

>>> re.sub(r'(\d{1,2})/(\d{1,2})/(\d{2}|\d{4})', r'\2/\1/\3','2/20/19')
'20/2/19'
>>> re.sub(r'(\d{1,2})/(\d{1,2})/(\d{2}|\d{4})', r'\2/\1/\3','2/20/2019')
'20/2/2019'

3.2purge()函数

模块函数会对已编译的对象进行缓存，不是所有使用相同正则表达式模式的search()和match()都需要编译。在不同的Python版本中，缓存中已编译过的正则表达式对象的数目可能不同，而且没有文档记录。purge()函数能够用于清除这些缓存。

4.常用的匹配对象方法

函数/方法	描述
group(num=0)	返回整个匹配对象，或者编号为num的特定子组
groups(default=None)	返回一个包含所有匹配子组的元组(如果没有成功匹配，则返回一个空元组)
groupdict(default=None)	返回一个包含所有匹配的命名子组的字典，所有的子组名称作为字典的键(如果没有成功匹配，则返回一个空字典)

>>> import re
>>> m = re.match('ab','ab')
>>> m.group()
'ab'
>>> m.groups()
()
>>> m = re.match('(ab)','ab')
>>> m.group()
'ab'
>>> m.group(1)
'ab'
>>> m.groups()
('ab',)
>>> m = re.match('(a(b))','ab')
>>> m.group()
'ab'
>>> m.group(1)
'ab'
>>> m.group(2)
'b'
>>> m.groups()
('ab', 'b')
>>> m = re.match('(a)(b)','ab')
>>> m.group()
'ab'
>>> m.group(1)
'a'
>>> m.group(2)
'b'
>>> m.groups()
('a', 'b')