四、正则表达式
字符串是编程时涉及到的最多的一种数据结构，对字符串进行操作的需求几乎无处不在。比如判断一个字符串是否是合法的Email地址，虽然可以编程提取@前后的子串，再分别判断是否是单词和域名，但这样做不但麻烦，而且代码难以复用。
正则表达式是一种用来匹配字符串的强有力的武器。它的设计思想是用一种描述性的语言来给字符串定义一个规则，凡是符合规则的字符串，我们就认为它“匹配”了，否则，该字符串就是不合法的。
下面这张图展示了使用正则表达式匹配的流程
1、Python支持的正则表达式元字符和语法
| 语法 | 说明 | 表达式实例 | 完整匹配的字符串 |
| 字符 | |||
| 一般字符 | 匹配自己 | abc | abc |
| . | 匹配任意字符“
”除外 DOTALL模式中（re.DOTALL）也能匹配换行符 |
a.b | abc或abc或a1c等 |
| [...] | 字符集[abc]表示a或b或c，也可以-表示一个范围如[a-d]表示a或b或c或d | a[bc]c | abc或adc |
| [^...] | 非字符集，也就是非[]里的之外的字符 | a[^bc]c | adc或aec等 |
| 预定义字符集（也可以系在字符集[...]中） | |||
| d | 数字：[0-9] | adc | a1c等 |
| D | 非数字：[^0-9]或[^d] | aDc | abc等 |
| s | 空白字符：[<空格> fv] | asc | a b等 |
| S | 非空白字符：[^s] | aSc | abc等 |
| w | 字母数字（单词字符）[a-zA-Z0-9] | awc | abc或a1c等 |
| W | 非字母数字（非单词字符）[^w] | aWc | a.c或a_c等 |
| 数量词（用在字符或(...)分组之后） | |||
| * | 匹配0个或多个前面的表达式。（注意包括0次） |
abc* | ab或abcc等 |
| + | 匹配1个或多个前面的表达式。 |
abc+ | abc或abcc等 |
| ? | 匹配0个或1个前面的表达式。（注意包括0次） | abc? | ab或abc |
| {m} | 匹配m个前面表达式（非贪婪） | abc{2} | abcc |
| {m,} | 匹配至少m个前面表达式（m至无限次） | abc{2,} | abcc或abccc等 |
| {m,n} | 匹配m至n个前面的表达式 | abc{1,2} | abc或abcc |
| 边界匹配（不消耗待匹配字符中的字符） | |||
| ^ | 匹配字符串开头，在多行模式中匹配每一行的开头 | ^abc | abc或abcd等 |
| $ | 匹配字符串结尾，在多行模式中匹配每一行的结尾 | abc$ | abc或123abc等 |
| A | 仅匹配字符串开头 | Aabc | abc或abcd等 |
| 仅匹配字符串结尾 | abc | abc或123abc等 | |
| 匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。 | |||
| B | 匹配非单词边界。'erB' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。 | ||
| 逻辑、分组 | |||
| | | 或左右表达式任意一个（短路）如果|没有在()中表示整个正则表达式（注意有括号和没括号的区别） | abc|def ab(c|d)ef |
abc或def abcef或abdef |
| (...) | 分组，可以用来引用，也可以括号内的被当做一组进行数量匹配后接数量词 | (abc){2}a | abcabca |
| (?P<name>...) | 分组别名，给分组起个名字，方便后面调用 | ||
| <number> | 引用编号为<number>的分组匹配到的字符串（注意是配到的字符串不是分组表达式本身） | (d)abc1 | 1ab1或5ab5等 |
| (?=name) | 引用别名为name的分组匹配到的字符串（注意是配到的字符串不是分组表达式本身） | (?P<id>d)abc(?P=id) | 1ab1或5ab5等 |
2、数量词的贪婪模式与分贪婪模式
正则表达式通常用于在文本中查找匹配的字符串。Python里数量词默认是贪婪的（在少数语言里也可能是默认非贪婪），总是尝试匹配尽可能多的字符；非贪婪的则相反，总是尝试匹配尽可能少的字符。例如：正则表达式"ab*"如果用于查找"abbbc"，将找到"abbb"。而如果使用非贪婪的数量词"ab*?"，将找到"a"。
3、python的re模块
Python通过re模块提供对正则表达式的支持。使用re的一般步骤是先将正则表达式的字符串形式编译为Pattern实例，然后使用Pattern实例处理文本并获得匹配结果（一个Match实例），最后使用Match实例获得信息，进行其他的操作。
1 import re 2 3 # 将正则表达式编译成Pattern对象 4 pattern = re.compile(r'hello') 5 6 # 使用Pattern匹配文本，获得匹配结果，无法匹配时将返回None 7 match = pattern.match('hello world!') 8 9 if match: 10 # 使用Match获得分组信息 11 print match.group()
执行结果
hello
当然也可以直接使用re的模块的方法时候直接传递正则表达式参数来完成
1 macth = re.match('hello', 'hello world') 2 if match: 3 print match.group()
执行结果是一样的
4、re模块的常用方法
re.compile(strPattern[, flag])
参数：
strPattern：正则表达式
flag：匹配模式，可选值有
re.I(re.IGNORECASE): 忽略大小写（括号内是完整写法，下同）
M(MULTILINE): 多行模式，改变'^'和'$'的行为（参见上图）
S(DOTALL): 点任意匹配模式，改变'.'的行为
L(LOCALE): 使预定字符类 w W B s S 取决于当前区域设定
U(UNICODE): 使预定字符类 w W B s S d D 取决于unicode定义的字符属性
X(VERBOSE): 详细模式。这个模式下正则表达式可以是多行，忽略空白字符，并可以加入注释。
返回值：Pattern对象是一个编译好的正则表达式，通过Pattern提供的一系列方法可以对文本进行匹配查找
以下的方法既可以是Pattern对象的实例方法也可以是re模块的方法，语法稍有不同
match(string[, pos[, endpos]]) | re.match(pattern, string[, flags])
这个方法将从string的pos下标处起尝试匹配pattern；如果pattern结束时仍可匹配，则返回一个Match对象；如果匹配过程中pattern无法匹配，或者匹配未结束就已到达endpos，则返回None。
pos和endpos的默认值分别为0和len(string)；re.match()无法指定这两个参数，参数flags用于编译pattern时指定匹配模式。
注意：这个方法并不是完全匹配。当pattern结束时若string还有剩余字符，仍然视为成功。想要完全匹配，可以在表达式末尾加上边界匹配符'$'。
参数：
string：要匹配的字符串
pos：匹配的开始下标
endpos：匹配的结束下标
pattern：正则表达式
flags：匹配模式
返回值：如果匹配成功返回match对象，否则返回None
search(string[, pos[, endpos]]) | re.search(pattern, string[, flags])
这个方法用于查找字符串中可以匹配成功的子串。从string的pos下标处起尝试匹配pattern，如果pattern结束时仍可匹配，则返回一个Match对象；若无法匹配，则将pos加1后重新尝试匹配；直到pos=endpos时仍无法匹配则返回None。
pos和endpos的默认值分别为0和len(string))；re.search()无法指定这两个参数，参数flags用于编译pattern时指定匹配模式。
参数：同match
返回值：同match
我们通过一个实例来看一下两个方法的区别
>>> import re >>> s = 'hello world' >>> print(re.match('ello', s)) None >>> print(re.search('ello',s )) <_sre.SRE_Match object; span=(1, 5), match='ello'> 说明：可以看到macth只匹配开头，开头不匹配，就不算匹配到，search则可以从中间，只要能有匹配到就算匹配 findall(string[, pos[, endpos]]) | re.findall(pattern, string[, flags]) 搜索string，以列表形式返回全部能匹配的子串。有点像search的扩展，把所有匹配的子串放到一个列表 参数：同match 返回值：所有匹配的子串，没有匹配则返回空列表 >>> import re >>> s = 'one1two2three3four4' >>> re.findall('d+', s) ['1', '2', '3', '4']
split(string[, maxsplit]) | re.split(pattern, string[, maxsplit]):
按照匹配字子串将字符串进行分割，返回分割收的列表
参数：
string：要分割的字符串
pattern：正则表达式
maxsplit：最大分割次数
返回值：分割后的列表
实例
>>> import re >>> s = 'one1two2three3four4' >>> re.split('d+', s) ['one', 'two', 'three', 'four', '']
sub(repl, string[, count]) | re.sub(pattern, repl, string[, count])
使用repl替换string中匹配的每一子串
参数：
repl：替换的字符串或方法，这里需要说一下这个方法，方法接收macth对象，方法的返回值作为替换的字符串，换句话就是经过处理的字符串。
string：要进行替换的字符串
pattern：正则表达式
count：替换的次数
实例：对于repl是个方法的情况，正好这次作业用到，用来替换多个则很难过福号的情况。假设我们有一个四则运算表达式 '--(1.1+1+1-(-1)-(1+1+(1+1+2.2)))+-----111+--++--3-+++++++---+---1+4+4/2+(1+3)*4.1+(2-1.1)*2/2*3'，遵循奇数个负号等于正否则为负的原则进行替换，我们可以这样
1 if __name__ == '__main__': 2 import re 3 s = '--(1.1+1+1-(-1)-(1+1+(1+1+2.2)))+-----111+--++--3-+++++++---+---1+4+4/2+(1+3)*4.1+(2-1.1)*2/2*3' 4 def replace_sign(expression): 5 ''' 6 替换多个连续+-符号的问题，例如+-----，遵循奇数个负号等于正否则为负的原则进行替换 7 :param expression: 表达式，包括有括号的情况 8 :return: 返回经过处理的表达式 9 ''' 10 def re_sign(m): 11 if m: 12 if m.group().count('-')%2 == 1: 13 return '-' 14 else: 15 return '+' 16 else: 17 return '' 18 expression = re.sub('[+-]{2,}', re_sign, expression) 19 return expression 20 21 s = replace_sign(s) 22 print(s)
执行结果
24 +(1.1+1+1-(-1)-(1+1+(1+1+2.2)))-111+3-1+4+4/2+(1+3)*4.1+(2-1.1)*2/2*3