Python | 较全的"正则表达式"学习笔

来源： 《Python编程快速上手—让繁琐工作自动化》

正则表达式

持续更新：
2019年02月14日 13:49:50

在本章中，你将从编写一个程序开始，先不用正则表达式来寻找文本模式。
然后再看看，使用正则表达式让代码变得多么简洁。我将展示用正则表达式进行基本匹配，然后转向一些更强大的功能，诸如字符串替换，以及创建你自己的字符类型。
最后，在本章末尾，你将编写一个程序，从一段文本中自动提取电话号码和E-mail 地址。

7.1 不用正则表达式来查找文本模式：

def isPhoneNumber(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('415-555-4242 is a phone number:')
print(isPhoneNumber('415-555-4242'))
print('Moshi moshi is a phone number:')
print(isPhoneNumber('Moshi moshi'))

message = 'Call me at 415-555-1011 tomorrow. 415-555-9999 is my office.'
for i in range(len(message)):
    chunk = message[i:i+12]
    if isPhoneNumber(chunk):
        print('Phone number found: ' + chunk)
print('Done')

打印结果：

415-555-4242 is a phone number:
True
Moshi moshi is a phone number:
False
Phone number found: 415-555-1011
Phone number found: 415-555-9999
Done
[Finished in 0.8s]

---

7.2 采用“正则表达式”

>>> import re
>>> phoneNumRegex = re.compile(r'\d\d\d-\d\d\d-\d\d\d\d')
>>> mo = phoneNumRegex.search('My number is 415-555-4242.')
>>> print('Phone number found: ' + mo.group())
Phone number found: 415-555-4242

---

使用正则表达式的步骤：

虽然在Python 中使用正则表达式有几个步骤，但每一步都相当简单。

1. 用import re 导入正则表达式模块。
2. 用re.compile()函数创建一个Regex 对象（记得使用原始字符串）。
3. 向Regex 对象的search()方法传入想查找的字符串。它返回一个Match 对象。
4. 调用Match 对象的group()方法，返回实际匹配文本的字符串。

---

---

7.3 用正则表达式匹配更多模式

7.3.1 利用括号()分组

• 正则表达式字符串中的第一对括号是第1 组、第二对括号是第2 组。
• 向group()匹配对象方法传入整数1 或2，就可以取得匹配文本的不同部分。
• 向group()方法传入0 或不传入参数，将返回整个匹配的文本。
  在交互式环境中输入以下代码：

>>> phoneNumRegex = re.compile(r'(\d\d\d)-(\d\d\d-\d\d\d\d)')
>>> mo = phoneNumRegex.search('My number is 415-555-4242.')
>>> mo.group(1)
'415'
>>> mo.group(2)
'555-4242'
>>> mo.group(0)
'415-555-4242'
>>> mo.group()
'415-555-4242'

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

>>> mo.groups()
('415', '555-4242')
>>> areaCode, mainNumber = mo.groups()
>>> print(areaCode)
415
>>> print(mainNumber)
555-4242

括号在正则表达式中有特殊的含义，但是如果你需要在文本中匹配括号，怎么办？
例如，你要匹配的电话号码，可能将区号放在一对括号中。在这种情况下，就需要用倒斜杠对(和)进行字符转义。在交互式环境中输入以下代码：

>>> phoneNumRegex = re.compile(r'(\(\d{3}\))(\d{3}-\d{4})')
或者
>>> phoneNumRegex = re.compile(r'(\(\d\d\d\))(\d\d\d-\d\d\d\d)')

>>> mo = phoneNumRegex.search('My number is (415)555-4242.')
>>> mo.group(1)
'(415)'
>>> mo.group(2)
'555-4242'
>>> mo.group()
'(415)555-4242'

我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。

• group(num=0): 匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。
• groups(): 返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。

7.3.2 用管道|匹配多个分组

字符 | 称为“管道”，希望匹配许多表达式中的一个时，就可以使用它。

例如正则表达式r'Batman|Tina Fey'将匹配'Batman'或'Tina Fey'。如果 Batman 和Tina Fey 都出现在被查找的字符串中，第一次出现的匹配文本，将作为Match 对象返回。
在交互式环境中输入以下代码：

>>> hero = re.compile(r'Batman|Tina Fey')

>>> mo1 = hero.search('Batman and Tina Fey.')
>>> mo1.group()
'Batman'

>>> mo2 = hero.search('Tina Fey and Batman.')
>>> mo2.group()
'Tina Fey'

也可以使用管道来匹配多个模式中的一个，作为正则表达式的一部分。

例如，假设你希望匹配'Batman'、 'Batmobile'、 'Batcopter'和'Batbat'中任意一个。因为所有这些字符串都以Bat 开始，所以如果能够只指定一次前缀，就很方便，这可以通过括号实现。
在交互式环境中输入以下代码：

>>> batRegex = re.compile(r'Bat(man|mobile|copter|bat)')
>>> mo = batRegex.search('Batmobile lost a wheel')
>>> mo.group()
'Batmobile'
>>> mo.group(1)
'mobile'

方法调用 mo.group()返回了完全匹配的文本'Batmobile'，而mo.group(1)只是返回第一个括号分组内匹配的文本'mobile'。通过使用管道字符和分组括号，可以指定几种可选的模式，让正则表达式去匹配。
如果需要匹配真正的管道字符，就用倒斜杠转义，即\|

---

2019年02月15日 09:12:20

7.3.3 用问号?实现可选匹配

字符?表明它前面的分组在这个模式中是可选的。

>>> import re
>>> batRegex = re.compile(r'Bat(wo)?man')

>>> mo1 = batRegex.search('The Adventures of Batman')
>>> mo1.group()
'Batman'

>>> mo2 = batRegex.search('The Adventures of Batwoman')
>>> mo2.group()
'Batwoman'

正则表达式中的(wo)?部分表明，模式wo 是可选的分组。该正则表达式匹配的文本中，wo 将出现零次或一次。这就是为什么正则表达式既匹配'Batwoman'，又匹配'Batman'。

如果出现超过1次则无法查到：

>>> batRegex = re.compile(r'Bat(wo)?man')
>>> mo2 = batRegex.search('The Adventures of Batwowoman')
>>> mo2 == None
True

利用前面电话号码的例子，你可以让正则表达式寻找包含区号或不包含区号的
电话号码。

>>> phoneRegex = re.compile(r'(\d\d\d-)?\d\d\d-\d\d\d\d')

>>> mo1 = phoneRegex.search('My number is 415-555-4242')
>>> mo1.group()
'415-555-4242'

>>> mo2 = phoneRegex.search('My number is 555-4242')
>>> mo2.group()
'555-4242'

7.3.4 用星号*匹配零次或多次

*（称为星号）意味着“匹配零次或多次”，即星号之前的分组，可以在文本中出现任意次。它可以完全不存在，或一次又一次地重复。

>>> batRegex = re.compile(r'Bat(wo)*man')

>>> mo1 = batRegex.search('The Adventures of Batman')
>>> mo1.group()
'Batman'

>>> mo2 = batRegex.search('The Adventures of Batwoman')
>>> mo2.group()
'Batwoman'

>>> mo3 = batRegex.search('The Adventures of Batwowowowoman')
>>> mo3.group()
'Batwowowowoman'

7.3.5 用加号+匹配一次或多次

*意味着“匹配零次或多次”，+则意味着“匹配一次或多次”。

星号不要求分组出现在匹配的字符串中，但加号不同，加号前面的分组必须“至少出现一次”，这不是可选的。

>>> batRegex = re.compile(r'Bat(wo)+man')

>>> mo2 = batRegex.search('The Adventures of Batwoman')
>>> mo2.group()
'Batwoman'

>>> mo3 = batRegex.search('The Adventures of Batwowowowoman')
>>> mo3.group()
'Batwowowowoman'

>>> mo1 = batRegex.search('The Adventures of Batman')
>>> mo1 == None
True

如果出现0次则会报错：

>>> mo1 = batRegex.search('The Adventures of Batman')
>>> mo1.group()
Traceback (most recent call last):
  File "<pyshell>", line 1, in <module>
AttributeError: 'NoneType' object has no attribute 'group'

7.3.6 用花括号{}匹配特定次数

如果想要一个分组重复特定次数，就在正则表达式中该分组的后面，跟上花括号包围的数字。

例如，正则表达式(Ha){3}将匹配字符串'HaHaHa'，但不会匹配'HaHa'，因为后者只重复了(Ha)分组两次。
除了一个数字，还可以指定一个范围，即在花括号中写下一个最小值、一个逗号和一个最大值。例如，正则表达式(Ha){3,5}将匹配'HaHaHa'、'HaHaHaHa'和'HaHaHaHaHa'。
也可以不写花括号中的第一个或第二个数字，不限定最小值或最大值，例如：

• (Ha){3,}将匹配3 次或更多次实例
• (Ha){,5}将匹配0 到5 次实例。
  花括号让正则表达式更简短。

(Ha){3}
等同
(Ha)(Ha)(Ha)


(Ha){3,5}
等同
((Ha)(Ha)(Ha))|((Ha)(Ha)(Ha)(Ha))|((Ha)(Ha)(Ha)(Ha)(Ha))

代码如下：

>>> batRegex = re.compile(r'(Ha){3}')

>>> mo1 = batRegex.search('HaHaHa')
>>> mo1.group()
'HaHaHa'

>>> mo2 = batRegex.search('HaHa')
>>> mo2 == None
True

---

7.4 贪心和非贪心匹配

在字符串'HaHaHaHaHa'中，因为(Ha){3,5}可以匹配3 个、4 个或5 个实例，你可能会想，为什么在前面花括号的例子中，Match 对象的group()调用会返回'HaHaHaHaHa'，而不是更短的可能结果。毕竟，'HaHaHa'和'HaHaHaHa'也能够有效地匹配正则表达式(Ha){3,5}。
Python 的正则表达式默认是“贪心”的，这表示在有二义的情况下，它们会尽可能匹配最长的字符串。

>>> greedyHaRegex = re.compile(r'(Ha){3,5}')
>>> mo1 = greedyHaRegex.search('HaHaHaHaHa')
>>> mo1.group()
'HaHaHaHaHa'

花括号的“非贪心”版本匹配尽可能最短的字符串，即在结束的花括号后跟着一个问号?。

>>> nonegreedyHaRegex = re.compile(r'(Ha){3,5}?')
>>> mo2 = nonegreedyHaRegex.search('HaHaHaHaHa')
>>> mo2.group()
'HaHaHa'

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

7.5 findall()方法

search()方法将返回一个Match对象，包含被查找字符串中的“第一次”匹配的文本.

>>> phoneNumRegex = re.compile(r'\d\d\d-\d\d\d-\d\d\d\d')
>>> mo = phoneNumRegex.search('Cell: 415-555-9999 Work: 212-555-0000')

>>> mo.group()
'415-555-9999'

findall()方法将返回一组字符串，包含被查找字符串中的所有匹配。

• findall()不是返回一个Match 对象，而是返回一个字符串列表，只要在正则表达式中没有分组。
  列表中的每个字符串都是一段被查找的文本，它匹配该正则表达式。

>>> phoneNumRegex = re.compile(r'\d\d\d-\d\d\d-\d\d\d\d') # has no groups
>>> phoneNumRegex.findall('Cell: 415-555-9999 Work: 212-555-0000')
['415-555-9999', '212-555-0000']

• 如果在正则表达式中有分组，那么findall 将返回元组的列表。每个元组表示一个找到的匹配，其中的项就是正则表达式中每个分组的匹配字符串。

>>> phoneNumRegex = re.compile(r'(\d\d\d)-(\d\d\d)-(\d\d\d\d)') # has groups
>>> phoneNumRegex.findall('Cell: 415-555-9999 Work: 212-555-0000')
[('415', '555', '9999'), ('212', '555', '0000')]

作为 findall()方法的返回结果的总结，请记住下面两点：

1. 如果调用在一个没有分组的正则表达式上，例如\d\d\d-\d\d\d-\d\d\d\d，方法findall()将返回一个匹配字符串的列表，例如['415-555-9999', '212-555-0000']。
2. 如果调用在一个有分组的正则表达式上，例如(\d\d\d)-(\d\d\d)-(\d\d\d\d)，方法findall()将返回一个字符串的元组的列表（每个分组对应一个字符串），例如[('415','555', '1122'), ('212', '555', '0000')]。

---

7.6 字符分类

在前面电话号码正则表达式的例子中，你知道\d 可以代表任何数字。也就是说，\d是正则表达式(0|1|2|3|4|5|6|7|8|9)的缩写。

缩写字符分类	表示
\d	0 到9 的任何数字
\D	除 0 到9 的数字以外的任何字符
\w	任何字母、数字或下划线字符（可以认为是匹配“单词”字符）
\W	除字母、数字和下划线以外的任何字符
\s	空格、制表符或换行符（可以认为是匹配“空白”字符）
\S	除空格、制表符和换行符以外的任何字符

>>> xmasRegex = re.compile(r'\d+\s\w+')
>>> xmasRegex.findall('12 drummers, 11 pipers, 10 lords, 9 ladies, 8 maids, 7swans, 6 geese, 5 rings, 4 birds, 3 hens, 2 doves, 1 partridge')
['12 drummers', '11 pipers', '10 lords', '9 ladies', '8 maids', '6 geese', '5 rings', '4 birds', '3 hens', '2 doves', '1 partridge']

---

7.7 用[]建立自己的字符分类

有时候你想匹配一组字符，但缩写的字符分类（\d、\w、\s 等）太宽泛。

• 你可以用方括号定义自己的字符分类
  例如，字符分类[aeiouAEIOU]将匹配所有元音字符，不论大小写。

>>> vowelRegex = re.compile(r'[aeiouAEIOU]')
>>> vowelRegex.findall('RoboCop eats baby food. BABY FOOD.')
['o', 'o', 'o', 'e', 'a', 'a', 'o', 'o', 'A', 'O', 'O']

• 可以使用短横表示字母或数字的范围
  例如，字符分类[a-zA-Z0-9]将匹配所有小写字母、大写字母和数字。

>>> numRegex = re.compile(r'[a-zA-Z0-9]')
>>> numRegex.findall('ASDF*&(&%$qaws+-')
['A', 'S', 'D', 'F', 'q', 'a', 'w', 's']

请注意：在方括号内，普通的正则表达式符号不会被解释。这意味着，你不需要前面加上倒斜杠转义. * ?或()字符。例如，字符分类将匹配数字0 到5 和一个句点。你不需要将它写成[0-5\.]。

• 通过在字符分类的左方括号后加上一个插入字符^，就可以得到“非字符类”，非字符类将匹配不在这个字符类中的所有字符。

>>> consonantRegex = re.compile(r'[^aeiouAEIOU]')
>>> consonantRegex.findall('RoboCop eats baby food. BABY FOOD.')
['R', 'b', 'C', 'p', ' ', 't', 's', ' ', 'b', 'b', 'y', ' ', 'f', 'd', '.', ' ', 'B', 'B', 'Y', ' ', 'F', 'D', '.']

---

7.8 插入字符^和美元字符$

• 可以在正则表达式的开始处使用插入符号（^），表明匹配必须发生在被查找文本开始处。

>>> a = re.compile(r'^Hello')
>>> a.search('Hello World')
<re.Match object; span=(0, 5), match='Hello'>
>>> a.search('s Hello World') == None
True

• 类似地，可以在正则表达式的末尾加上美元符号（$），表示该字符串必须以这个正则表达式的模式结束。
  正则表达式r'\d$'匹配以数字0 到9 结束的字符串。

>>> b = re.compile(r'\d$')
>>> b.search('s Hello World 7788')
<re.Match object; span=(17, 18), match='8'>

>>> b = re.compile(r'\d{4}$')
>>> b.search('s Hello World 7788')
<re.Match object; span=(14, 18), match='7788'>

• 可以同时使用^和$，表明整个字符串必须匹配该模式，也就是说，只匹配该字符串的某个子集是不够的。

>>> c = re.compile(r'^\d$')
>>> c.search('1s Hello World 7788') == None
True
>>> c.search('18') == None
True
>>> c.search('1')
<re.Match object; span=(0, 1), match='1'>

>>> c = re.compile(r'^\d+$')
>>> c.search('1s Hello World 7788') == None
True
>>> c.search('18567788502123')
<re.Match object; span=(0, 14), match='18567788502123'>

---

7.9 通配字符句号.

在正则表达式中，.（句点）字符称为“通配符”。它匹配除了换行之外的所有字符。

>>> atRegex = re.compile(r'.at')
>>> atRegex.findall('The cat in the hat sat on the flat mat.')
['cat', 'hat', 'sat', 'lat', 'mat']

要记住：句点字符只匹配一个字符

---

7.9.1 用点-星.*匹配所有字符

有时候想要匹配所有字符串。
例如，假定想要匹配字符串'First Name:'，接下来是任意文本，接下来是'Last Name:'，然后又是任意文本。可以用点-星（.*）表示“任意文本”

>>> name = re.compile(r'First Name:(.*) Last Name:(.*)')
>>> mo = name.search('First Name: Al Last Name: Sweigart')
>>> mo.group(1)
' Al'
>>> mo.group(2)
' Sweigart'
>>> mo.group()
'First Name: Al Last Name: Sweigart'
---

>>> name = re.compile(r'First Name:(.*);Last Name:(.*)')
>>> mo = name.search('First Name: Al;Last Name: Sweigart')
>>> mo.group()
'First Name: Al;Last Name: Sweigart'

compile和search格式必须保持统一，否则报错

点-星使用“贪心”模式：它总是匹配尽可能多的文本。
要用“非贪心”模式匹配所有文本，就使用点-星和问号。
像和大括号一起使用时那样，问号告诉Python 用非贪心模式匹配。

>>> nongreedyRegex = re.compile(r'<.*?>')
>>> mo = nongreedyRegex.search('<To serve man> for dinner.>')
>>> mo.group()
'<To serve man>'

>>> greedyRegex = re.compile(r'<.*>')
>>> mo = greedyRegex.search('<To serve man> for dinner.>')
>>> mo.group()
'<To serve man> for dinner.>'

---

7.9.2 用句点字符匹配换行

• 点-星将匹配除换行外的所有字符。

>>> noNewlineRegex = re.compile('.*')
>>> noNewlineRegex.search('Serve the public trust.\nProtect the innocent.\nUphold the law.').group()
'Serve the public trust.'

正则表达式noNewlineRegex 在创建时没有向re.compile()传入re.DOTALL，它将匹配所有字符，直到第一个换行字符。

• 通过传入re.DOTALL 作为re.compile()的第二个参数，可以让句点字符匹配所有字符，包括换行字符。

>>> newlineRegex = re.compile('.*', re.DOTALL)
>>> newlineRegex.search('Serve the public trust.\nProtect the innocent.\nUphold the law.').group()
'Serve the public trust.\nProtect the innocent.\nUphold the law.'

newlineRegex 在创建时向re.compile()传入了re.DOTALL，它将匹配所有字符。

---

7.10 正则表达式符号复习

• ?匹配零次或一次前面的分组。
• *匹配零次或多次前面的分组。
• +匹配一次或多次前面的分组。
• {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]匹配不在方括号内的任意字符。

---

7.11 不区分大小写的匹配

通常正则表达式用你指定的大小写匹配文本
例如，下面的正则表达式匹配完全不同的字符串：

>>> regex1 = re.compile('RoboCop')
>>> regex2 = re.compile('ROBOCOP')
>>> regex3 = re.compile('robOcop')
>>> regex4 = re.compile('RobocOp')

但是，有时候你只关心匹配字母，不关心它们是大写或小写。
要让正则表达式不区分大小写，可以向re.compile()传入re.IGNORECASE 或re.I，作为第二个参数。

>>> robocop = re.compile(r'robocop', re.I)
>>> robocop.search('RoboCop is part man, part machine, all cop.').group()
'RoboCop'

>>> robocop = re.compile(r'robocoP', re.I)
>>> robocop.search('RoboCop is part man, part machine, all cop.').group()
'RoboCop'
>>> robocop.search('ROBOCOP protects the innocent.').group()
'ROBOCOP'
>>> robocop.search('Al, why does your programming book talk about robocop so much?').group()
'robocop'

---

7.12 用sub()方法替换字符串

正则表达式不仅能找到文本模式，而且能够用新的文本替换掉这些模式。Regex对象的sub()方法需要传入两个参数。

• 第一个参数是一个字符串，用于取代发现的匹配。
• 第二个参数是一个字符串，即正则表达式。

>>> help(re.sub)
Help on function sub in module re:

sub(pattern, repl, string, count=0, flags=0)
    Return the string obtained by replacing the leftmost
    non-overlapping occurrences of the pattern in string by the
    replacement repl.  repl can be either a string or a callable;
    if a string, backslash escapes in it are processed.  If it is
    a callable, it's passed the Match object and must return
    a replacement string to be used.

sub()方法返回替换完成后的字符串。

>>> namesRegex = re.compile(r'Agent \w+')
>>> namesRegex.sub('CENSORED', 'Agent Alice gave the secret documents to Agent Bob.')
'CENSORED gave the secret documents to CENSORED.'

Agent \w+：表示Agent 空格和后续的一个单词，到空格截止。

有时候，你可能需要使用匹配的文本本身，作为替换的一部分。
在sub()的第一个参数中，可以输入\1、\2、\3……，表示“在替换中输入分组1、2、3……的文本”。
例如，假定想要隐去密探的姓名，只显示他们姓名的第一个字母。要做到这一点，可以使用正则表达式Agent (\w)\w*，传入r'\1****'作为sub()的第一个参数。
字符串中的\1 将由分组1 匹配的文本所替代，也就是正则表达式的(\w)分组。

>>> agentNamesRegex = re.compile(r'Agent (\w)\w*')
>>> agentNamesRegex.sub(r'\1****', 'Agent Alice told Agent Carol that Agent Eve knew Agent Bob was a double agent.')
'A**** told C**** that E**** knew B**** was a double agent.'

拓展：

>>> agentNamesRegex = re.compile(r'Agent \w(\w)\w*')
>>> agentNamesRegex.sub(r'\1****', 'Agent Alice told Agent Carol that Agent Eve knew Agent Bob was a double agent.')
'l**** told a**** that v**** knew o**** was a double agent.'

>>> agentNamesRegex.sub(r'*\1***', 'Agent Alice told Agent Carol that Agent Eve knew Agent Bob was a double agent.')
'*l*** told *a*** that *v*** knew *o*** was a double agent.'

>>> agentNamesRegex = re.compile(r'Agen(\w) (\w)\w*')
>>> agentNamesRegex.sub(r'\1_\2***', 'Agent Alice told Agent Carol that Agent Eve knew Agent Bob was a double agent.')
't_A*** told t_C*** that t_E*** knew t_B*** was a double agent.'

理解：

1. 先按格式Agent \w(\w)\w*找到"Agent"-"空格"-"第一个字母"-''第二个字母(对应\1)“-"其余字母"，如Agent Alice

• r'\1****'：\1对应的内容，如Alice中的l，保留，前面的内容被删除，后面的内容换成****
• r'*\1***'：\1对应的内容，如Alice中的l，保留，前一个字符换成*，后续字符换成***

2. 先按格式r'Agen(\w) (\w)\w*'找到字符串，如Agent Alice

• 然后根据r'\1_\2***'处理：\1对应Agent中的t，保留；\2对应Alice中的A，也保留；后续字母换成***。

---