Python 初学习系列（三）

前言

提示：继续Python学习，这部分是自动化任务部分，先学习模式匹配和正则表达式。

第七章：模式匹配和正则表达式

介绍python如何用正则表达式处理字符串，以及查找文本模式。

假设希望在字符串中查找电话号码，已知模式：3个数字，一个短横线，3个数字，1个短横线，最后3个数字，例如：122-333-4444.。当不用正则表达式编写代码如下：

def isPhoneNumer(text):
    if len(text)!=12:
        return False
    for i in range(0,3):
        if not text[i].isdecimal():
            return False
    if text[3]!='-':
        return False
    for i in range(4,7):
        if not text[i].isdecimal():
            return False
    if text[7]!='-':
        return False
    for i in range(8,12):
        if not text[i].isdecimal():
            return False
    return True
print(isPhoneNumer('111-222-2222'))
print(isPhoneNumer('111-222-222'))
print(isPhoneNumer('1111-222-222'))
结果
True
False
False

必须添加更多代码，才能在更长的字符串中寻找这种文本模式，例子如下：

message='Call me at 412-222-2222 tomorrow.122-344-2345 is my office.'
for i in range(len(message)):
    chunk =message[i:i+12]
    if isPhoneNumer(chunk):
        print('Phone number found:'+chunk)
print('Done')
结果
Phone number found:412-222-2222
Phone number found:122-344-2345
Done

正则表达式，简称regex，是文本模式的描述方法。例如，\d是一个正则表达式，表示一个数字字符，即任何0到9的数字。Python使用正则表达式\d\d\d-\d\d\d-\d\d\d\d可以完成前面查找电话的功能。正则表达式可以很复杂，例如在一个模式后加上花括号包围的3（{3}），就是匹配这个模式三次，所以可简化为\d{3}-\d{3}-\d{4}。

Python中所有正则表达式的函数都在re模块中。向re.compile()传入一个字符串值，表示正则表达式，将返回一个Regex模式对象。创建一个Regex对象来匹配电话号码模式，代码如下：

import re
phoneNumRegex = re.compile(r'\d\d\d-\d\d\d-\d\d\d\d')

此时phoneNumRegex变量包含一个Regex对象。匹配Regex对象的过程中，Regex对象的search()方法查找传入的字符串，寻找该正则表达式的所有匹配。如果字符串中没有找到该正则表达式模式，search()方法就返回None。如果找到该模式，search()方法将返回一个Match对象。Match对象有一个Group()方法，返回被查找字符串中实际匹配的文本。例子如下：

import re
phoneNumRegex = re.compile(r'\d\d\d-\d\d\d-\d\d\d\d')
mo = phoneNumRegex.search('My number is 415-222-3464.')
print('Phone number found: '+mo.group())
结果
Phone number found: 415-222-3464

小知识：在字符串前加小写r，可以将该字符串标记为原始字符串，不包括转义字符。

总结下正则表达式的几个步骤：首先用import re 导入正则表达式模块；然后用re.compile()函数创建一个Regex对象(记得使用原始字符串);接着向Regex对象的search()方法传入想查找的字符串，将返回一个Match对象；最后调用Match对象的group()方法，返回实际匹配文本的字符串。

假如想要将区号从电话号码中分离，添加括号将在正则表达式中创建分组，(\d\d\d)-(\d\d\d-\d\d\d\d)。第一对括号是第一组，第二对括号是第二组，向group()方法传入1或者2，取得匹配文本的不同部分，传入0或者不传参数，返回整个匹配的文本。例子如下：

import re
phoneNumRegex = re.compile(r'(\d\d\d)-(\d\d\d-\d\d\d\d)')
mo = phoneNumRegex.search('My number is 415-222-3464.')
print(mo.group(1))
print(mo.group(2))
print(mo.group(0))
print(mo.group())
结果
415
222-3464
415-222-3464
415-222-3464

如果想要一次获取所有的分组，使用groups()方法，注意函数名的复数形式。例子如下：

print(mo.groups())
areaCode,mainNumber =mo.groups()
print(areaCode)
print(mainNumber)
结果
('415', '222-3464')
415
222-3464

括号在正则表达式中有特殊的含义，如果需要在文本中匹配括号，需要使用转义字符，例子如下：

import re
phoneNumRegex = re.compile(r'(\(\d\d\d\))(\d\d\d-\d\d\d\d)')
mo = phoneNumRegex.search('My number is (415)222-3464.')
print(mo.group(1))
print(mo.group(2))
结果
(415)
222-3464

字符|称为“管道”。希望匹配许多表达式中的一个时使用。比如，正则表达式r’Batman|Tina Fey’将匹配’Batman’或‘TinaFey’。如果都出现在被查找的字符串中，第一次出现的匹配文本将作为Match对象返回，例子如下：

import re
heroRegex = re.compile(r'Batman|Tina Fey')
mo1 = heroRegex.search('Batman and Tina Fey.')
mo2 = heroRegex.search('Tina Fey and Batman.')
print(mo1.group())
print(mo2.group())
结果
Batman
Tina Fey

也可以使用管道匹配多个模式中一个，作为正则表达式一部分。例如只指定一次前缀，后面通过括号管道分配，例子如下：

import re
batRegex = re.compile(r'Bat(man|mobile|bat)')
mo = batRegex.search('Batman and Tina Fey.')
print(mo.group())
print(mo.group(1))
结果
Batman
man

有时候想匹配的模式是可选的。话句话说，不论这段文本在不在，正则表达式都会认为匹配。字符？表明它前面的分组在这个模式中是可选的。例子如下，匹配wo零次或者一次：

import re
batRegex = re.compile(r'Bat(wo)?man')
mo1 = batRegex.search('Batman and Tina Fey.')
mo2 = batRegex.search('Batwoman and Tina Fey.')
print(mo1.group())
print(mo2.group())
结果
Batman
Batwoman

*(称为星号)意味着匹配零次或者多次，即星号之前的分组，可以在文本中出现任意次，它可以完全不存在，或一次又一次的出现。

import re
batRegex = re.compile(r'Bat(wo)*man')
mo1 = batRegex.search('Batman and Tina Fey.')
mo2 = batRegex.search('Batwoman and Tina Fey.')
mo3 = batRegex.search('Batwowowowowowoman and Tina Fey.')
print(mo1.group())
print(mo2.group())
print(mo3.group())
结果
Batman
Batwoman
Batwowowowowowoman

+(加号)意味着“匹配一次或者多次”。加号之前的分组必须至少出现一次。

import re
batRegex = re.compile(r'Bat(wo)+man')
mo1 = batRegex.search('Batman and Tina Fey.')
mo2 = batRegex.search('Batwoman and Tina Fey.')
mo3 = batRegex.search('Batwowowowowowoman and Tina Fey.')
print(mo1 == None)
print(mo2.group())
print(mo3.group())
结果
True
Batwoman
Batwowowowowowoman

如果想要一个分组重复特定次数，在该分组的后面，根上花括号包围的数字，例如正则表达式(Ha){3}将匹配字符串”HaHaHa”，也可以指定一个范围，在花括号中写下一个最小值，逗号和一个最大值。例如，正则表达式(Ha){3,4}将匹配‘HaHaHa’，‘HaHaHaHa’。(Ha){3,}将匹配三次或更多次实例，(Ha){,5}将匹配0到次实例。Python的正则表达式默认是“贪心”的，这表示在有二义的情况下，它们尽可能匹配最长的字符串，花括号的“非贪心”版本匹配尽可能最短的字符串，即在结束的花括号后面跟着一个问号。例子如下：

import re
batRegex = re.compile(r'(wo){3,5}')
nobatRegex = re.compile(r'(wo){3,5}?')
mo1 = batRegex.search('wowowowowo')
mo2 = nobatRegex.search('wowowowowo')
print(mo1.group())
print(mo2.group())
结果
wowowowowo
wowowo

注意点：问号在正则表达式中有两个含义，声明非贪心匹配或表示可选的分组，这两个含义是完全无关的。

除了search()方法外，Regex对象还有findall()方法。search()将返回一个Match对象，包含被查找字符串的第一次匹配的文本，而findall()方法将返回一组字符串，包含被查找字符串中的所有匹配。例子如下：

import re
batRegex = re.compile(r'\d\d\d-\d\d\d-\d\d\d\d')
batRegex1 = re.compile(r'(\d\d\d)-(\d\d\d)-(\d\d\d\d)')
mo = batRegex.search('cell:433-333-2222 Work:122-222-1111')
mo1 = batRegex.findall('cell:433-333-2222 Work:122-222-1111')
mo2 = batRegex1.findall('cell:433-333-2222 Work:122-222-1111')
print(mo.group())
print(mo1)
print(mo2)
结果
433-333-2222
['433-333-2222', '122-222-1111']
[('433', '333', '2222'), ('122', '222', '1111')]

\d是正则表达式(0|1|2|3|4|5|6|7|8|9)的缩写。常用的还有：\D表示除0到9之外的任何字符；\w表示任何字母、数字或下划线字符，可以认为是匹配单词字符；\W表示除字母、数字和下划线之外的任何字符；\s表示空格，制表符或换行符，可以认为是匹配空白字符；\S表示除空格，制表符和换行符之外的任何字符。

字符分类对于缩短正则表达式很有用，字符分类[0-5]只匹配数字0到5，比输入(0|1|2|3|4|5)容易多了。例子如下:

import re
batRegex = re.compile(r'\d+\s\w+')
batRegex1 = re.compile(r'[0-5]+\s\w+')
mo1 = batRegex.findall('12 dedef,11 dwdw, 10 dedeffe,6 d.')
mo2 = batRegex1.findall('12 dedef,11 dwdw, 10 dedeffe,6 d.')
print(mo1)
print(mo2)
结果
['12 dedef', '11 dwdw', '10 dedeffe', '6 d']
['12 dedef', '11 dwdw', '10 dedeffe']

有时候你想匹配一组字符，但缩写的字符分类太宽泛。可以用方括号定义自己的字符分类。也可以使用短横表示字母或数字的范围。请注意，在方括号内，普通的正则表达式符号不被解释，这意味着，不需要在前面加上倒斜杠转义，*，？或()。在字符分类的左方括号后加上一个插入字符(^)，得到“非字符类”，非字符类匹配不在这个字符类中的所有字符。

在正则表达式的开始处插入字符(^)，表明匹配必须发生在被查找文本的开始处。类似地，在正则表达式地末尾加上美元符号($)，表示该字符串必须以这个正则表达式的模式结束。同时使用^和$，表明整个字符串必须匹配该模式，换句话说，只匹配该字符串的某个子集是不够的。例子如下：

import re
beginsWithHello = re.compile(r'^Hello')
endsWithNumber = re.compile(r'\d$')
mo1 = beginsWithHello.search('Hello World!')
mo2 = beginsWithHello.search('He said Hello.')
mo3 = endsWithNumber.search('Your number is 42')
mo4 = endsWithNumber.search('Your number is 42.')
print(mo1)
print(mo2)
print(mo3)
print(mo4)
结果
<re.Match object; span=(0, 5), match='Hello'>
None
<re.Match object; span=(16, 17), match='2'>
None

在正则表达式中，.(句号)字符称为通配符，它匹配除换行之外的所有字符。句点字符只匹配一个字符。点星(.*)表示任意文本。句点字符表示除换行意外所有单个字符，星号字符表示前面字符出现零次或多次。例子如下：

import re
nameRegex = re.compile(r'First Name:(.*) Last Name:(.*)')
mo = nameRegex.search('First Name:alll Last Name:swfwgtg')
print(mo.group(1))
print(mo.group(2))
结果
alll
swfwgtg

点星使用贪心模式：总是匹配尽可能多的文本。要使用非贪心模式，使用典型和问号。例子如下：

import re
nameRegex = re.compile(r'<.*?>')
nameRegex1 = re.compile(r'<.*>')
mo = nameRegex.search('<To serve man> for dinner.>')
mo1 = nameRegex1.search('<To serve man> for dinner.>')
print(mo.group())
print(mo1.group())
结果
<To serve man>
<To serve man> for dinner.>

上面讲到点-星匹配除换行外的所有字符。通过传入re.DOTALL作为re.compile()的第二个参数，可以让句点字符匹配所有字符，包括换行字符。例子如下：

import re
noNewlineRegex = re.compile('.*')
newlineRegex = re.compile('.*',re.DOTALL)
mo = noNewlineRegex.search('Serve the public trust.\nProtect the innocent.'
                           '\nUphold the law.')
mo1 = newlineRegex.search('Serve the public trust.\nProtect the innocent.'
                           '\nUphold the law.')
print(mo.group())
print(mo1.group())
结果
Serve the public trust.
Serve the public trust.
Protect the innocent.
Uphold the law.

对正则表达式符号的复习，默认都是贪心匹配，即匹配符合要求的最长的字符串。

?匹配零次或1次前面的分组。

*匹配零次或多次前面的分组。

+匹配一次或多次前面的分组。

{n}匹配n次前面的分组。

{n,}匹配n次或更多前面的分组。

{,m}匹配零次到m次前面的分组。

{n,m}匹配至少n次，至多m次前面的分组。

{n,m}?或*?或+?对前面的分组进行非贪心匹配。

^spam意味着字符串必须以spam开始。

spam$意味着字符串必须以spam结束。

.匹配所有字符，换行符除外。

\d,\w,\s分别匹配数字，单词和空格。

\D,\W,\S分别匹配除数字，单词和空格外的所有字符。

[abc]匹配方括号内的任意字符(诸如a,b或c)。

[^abc]匹配不在方括号内的任意字符。

为了使正则表达式不区分大小写，在re.compile()的第二个参数传入re.IGNORECASE或re.I。例子如下：
 

import re
rebocop = re.compile(r'rebocop',re.I)
rebocop1 = re.compile(r'rebocop',re.IGNORECASE)
mo = rebocop.search('REBOCOP.')
mo1 = rebocop1.search('ReBoCop')
print(mo.group())
print(mo1.group())
结果
REBOCOP
ReBoCop

正则表达式不仅能够找到文本模式，还能用新的文本替换掉这些模式。Regex对象的sub()方法需要传入两个参数。第一个参数是一个字符串，用于取代发现的匹配，第二个参数是一个字符串，即正则表达式。sub()方法返回替换完成后的字符串。例子如下：

import re
namesRegex = re.compile(r'Agent \w+')
mo = namesRegex.sub('CENSORED','Agent Alice gave the secret documents to Agent Bob.')
print(mo)
结果
CENSORED gave the secret documents to CENSORED.

有时候，可能需要使用匹配的文本本身，作为替换的一部分。在sub()的第一个参数中，输入\1,\2,\3，表示在替换中输入分组1，2，3的文本。例子如下：

import re
agentNamesRegex = re.compile(r'Agent (\w)\w*')
mo = agentNamesRegex.sub(r'\1***', 'Agent Alice told Agent Carol that Agent Eve knew Agent Bob.')
print(mo)
结果
A*** told C*** that E*** knew B***.

如果要匹配的文本模式简单，正则表达式很好。但若匹配复杂的文本模式，可能需要长的，费解的正则表达式。可以向re.compile()传入变量re.VERBOSE，作为第二个参数，从而忽略正则表达式字符串中的空白符和注释。例子如下：

phoneRegex= re.compile(r'((\d{3}|\(\d{3}\))?(\s-|\.)?\d{3}(\s-|\.)\d{4}(\s*(ext|x|ext.)\s*\d{2,5})?)')
phoneRegex1 = re.compile(r'''(
(\d{3}|\(\d{3}\))? #area code
(\s-|\.)?          #seperator
\d{3}              #first 3 digits
(\s-|\.)           #seperator
\d{4}              #last 4 digits
(\s*(ext|x|ext.)\s*\d{2,5})? #extension
)''',re.VERBOSE)

这样使用三重引号，创建一个多行字符串，可以将正则表达式定义放在多行中，让它更可读。

如果希望在正则表达式中编写注释，又希望忽略大小写。由于re.compile()函数只接受一个值作为它的第二参数。可以使用管道字符(|)将变量组合起来，从而绕过这个限制，这里的管道字符称为”按位或”操作符。re.VERBOSE编写注释，re.I忽略大小写，DOTALL匹配换行。例子如下：

someRegexValue = re.compile('foo',re.I|re.DOTALL|re.VERBOSE)

---

总结

主要学习了正则表达式，知识点很多，需要多复习。