Python编程快速上手第七章正则表达式

最新推荐文章于 2024-07-19 16:36:18 发布

LinYinOrTa

最新推荐文章于 2024-07-19 16:36:18 发布

阅读量1k

点赞数 29

文章标签： python 正则表达式

本文链接：https://blog.csdn.net/LinYinOrTa/article/details/137206755

版权

第七章-模式匹配与正则表达式

7.2.3 正则表达式匹配

1．用 import re 导入正则表达式模块。

2．用 re.compile()函数创建一个 Regex 对象（记得使用原始字符串）。

3．向 Regex 对象的 search()方法传入想查找的字符串。它返回一个 Match 对象。

4．调用 Match 对象的 group()方法，返回实际匹配文本的字符串。

示例代码：

# isPhoneNumber
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

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')

输出：

Phone number found: 415-555-1011
Phone number found: 415-555-9999
Done

7.3.1 利用括号分组

假定想要将区号从电话号码中分离。添加括号将在正则表达式中创建“分组”： (\d\d\d)-(\d\d\d-\d\d\d\d)。然后可以使用 group()匹配对象方法，从一个分组中获取匹配的文本。

向 group() 匹配对象方法传入整数 1 或 2，就可以取得匹配文本的不同部分。向 group()方法传入 0 或不传入参数，将返回整个匹配的文本。如果想要一次就获取所有的分组，请使用 groups()方法，注意函数名的复数形式。

例如：

>>> 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'
>>> mo.groups()
('415', '555-4242')
>>> areaCode, mainNumber = mo.groups()
>>> print(areaCode)
415
>>> print(mainNumber)
555-4242

括号在正则表达式中有特殊的含义，但是如果你需要在文本中匹配括号

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

7.3.2 用管道匹配多个分组

字符|称为“管道”。希望匹配许多表达式中的一个时，就可以使用它。例如，正则表达式 r'Batman|Tina Fey'将匹配'Batman'或'Tina Fey'。

>>> heroRegex = re.compile (r'Batman|Tina Fey')
>>> mo1 = heroRegex.search('Batman and Tina Fey.')
>>> mo1.group()
'Batman'
>>> mo2 = heroRegex.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'

7.3.3 用问号实现可选匹配

有时候，想匹配的模式是可选的。就是说，不论这段文本在不在，正则表达式都会认为匹配。字符?表明它前面的分组在这个模式中是可选的。

>>> 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'

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')
>>> mo1 = batRegex.search('The Adventures of Batwoman')
>>> mo1.group()
'Batwoman'
>>> mo2 = batRegex.search('The Adventures of Batwowowowoman')
>>> mo2.group()
'Batwowowowoman'
>>> mo3 = batRegex.search('The Adventures of Batman')
>>> mo3 == None
True

7.3.6 用花括号匹配特定次数

如果想要一个分组重复特定次数，就在正则表达式中该分组的后面，跟上花括号包围的数字。例如，正则表达式(Ha){3}将匹配字符串'HaHaHa'，但不会匹配'HaHa'，因为后者只重复了(Ha)分组两次。

除了一个数字，还可以指定一个范围，即在花括号中写下一个最小值、一个逗号和一个最大值。例如，正则表达式(Ha){3,5}将匹配'HaHaHa'、'HaHaHaHa'和'HaHaHaHaHa'。

也可以不写花括号中的第一个或第二个数字，不限定最小值或最大值。例如，第 7 章模式匹配与正则表达式

(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))

>>> haRegex = re.compile(r'(Ha){3}')
>>> mo1 = haRegex.search('HaHaHa')
>>> mo1.group()
'HaHaHa'
>>> mo2 = haRegex.search('Ha')
>>> mo2 == None
True

7.4 贪心和非贪心匹配

Python 的正则表达式默认是“贪心”的，这表示在有二义的情况下，它们会尽可能匹配最长的字符串。比如：使用(Ha){3,5}去匹配'HaHaHaHaHa'只会返回'HaHaHaHaHa'而不是更短的结果，'HaHaHa'和'HaHaHaHa'也能够有效地匹配正则表达式(Ha){3,5}。可他只会返回最长的。

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

花括号的贪心形式和非贪心形式之间的区别：

# 默认的贪心匹配
>>> greedyHaRegex = re.compile(r'(Ha){3,5}')
>>> mo1 = greedyHaRegex.search('HaHaHaHaHa')
>>> mo1.group()
'HaHaHaHaHa'
# 使用?变成非贪心匹配
>>> nongreedyHaRegex = re.compile(r'(Ha){3,5}?')
>>> mo2 = nongreedyHaRegex.search('HaHaHaHaHa')
>>> mo2.group()
'HaHaHa'

7.5 findall()方法

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

# 使用search()进行匹配
>>> 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()不是返回一个 Match 对象，而是返回一个字符串列表，只要在正则表达式中没有分组。列表中的每个字符串都是一段被查找的文本，它匹配该正则表达式。

# 正则表达式中没有分组
>>> phoneNumRegex = re.compile(r'\d\d\d-\d\d\d-\d\d\d\d')
>>> 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', '1122'), ('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	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, 7 swans, 6 geese, 5 rings, 4 birds, 3 hens, 2 doves, 1 partridge')
['12 drummers', '11 pipers', '10 lords', '9 ladies', '8 maids', '7 swans', '6 geese', '5 rings', '4 birds', '3 hens', '2 doves', '1 partridge']

正则表达式\d+\s\w+匹配的文本有一个或多个数字(\d+)，接下来是一个空白字符(\s)，接下来是一个或多个字母/数字/下划线字符(\w+)。findall()方法将返回所有匹配该正则表达式的字符串，放在一个列表中。

7.7 建立自己的字符分类

使用方括号定义自己的字符分类。例如，字符分类[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]将匹配所有小写字母、大写字母和数字。

>>> allRegex = re.compile(r'[a-zA-Z0-9]')
>>> allRegex.findall('My number is 1231234560')
['M', 'y', 'n', 'u', 'm', 'b', 'e', 'r', 'i', 's', '1', '2', '3', '1', '2', '3', '4', '5', '6', '0']

在方括号内，普通的正则表达式符号不会被解释。这意味着，你不需要前面加上倒斜杠转义.、*、?或()字符。例如，字符分类将匹配数字 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 插入字符和美元字符

插入字符(^)，若在正则表达式的开始处使用，表明匹配的表达式必须发生在被查找文本的开始处

例如：

>>> beginsWithHello = re.compile(r'^Hello')     # 在正则表达式开始处使用^
>>> beginsWithHello.search('Hello world!')
<_sre.SRE_Match object; span=(0, 5), match='Hello'>
>>> beginsWithHello.search('He said hello.') == None
True

line2 的被查找文本'Hello world'开始处有正则表达式'Hello'，所以可以匹配到

line4 的被查找文本'He said hello'开始处没有'Hello'，所以无法匹配到

美元符号($)，可在正则表达式的末尾加上$，表示该字符必须以这个正则表达式结束

例如：

>>> endsWithNumber = re.compile(r'\d$')
>>> endsWithNumber.search('Your number is 42')
<_sre.SRE_Match object; span=(16, 17), match='2'>
>>> endsWithNumber.search('Your number is forty two.') == None
True
>>> endsWithNumber.search('Your number is 4 two.') == None
True

line2 的被查找文本'Your number is 42'结束处有正则表达式'\d'，所以可以匹配到

line4 的被查找文本'Your number is forty two.'结束处没有'\d'，所以无法匹配到

可以同时使用^和$，表明整个字符串必须匹配该模式，如正则表达式 r'^\d+$'匹配从开始到结束都是数字的字符串。

>>> wholeStringIsNum = re.compile(r'^\d+$')
>>> wholeStringIsNum.search('1234567890')
<_sre.SRE_Match object; span=(0, 10), match='1234567890'>
>>> wholeStringIsNum.search('12345xyz67890') == None
True
>>> wholeStringIsNum.search('12 34567890') == None
True

如果使用了^和$，那么整个字符串必须匹配该正则表达式。

7.9 通配字符

通配字符(.)，它匹配除了换行之外的所有字符。且只匹配一个字符

例如：

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

可见 'flat' 只匹配到了 'lat'

7.9.1 用点-星匹配所有字符

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

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

点-星使用“贪心”模式：它总是匹配尽可能多的文本。要用“非贪心”模式匹配所有文本，就使用点-星和问号。像和大括号一起使用时那样，问号告诉 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 用句点字符匹配换行

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

>>> noNewlineRegex = re.compile('.*')
>>> noNewlineRegex.search('Serve the public trust.\nProtect the innocent.\nUphold the law.').group()
'Serve the public trust.'   # 没有传入re.DOTALL所以到第一个换行符就停止了

>>> 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.'

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 不区分大小写的匹配

通常，正则表达式用你指定的大小写匹配文本。要让正则表达式不区分大小写，可以向 re.compile()传入 re.IGNORECASE 或 re.I，作为第二个参数。

>>> robocop = re.compile(r'robocop', re.I)  # 此处第二个参数传入了 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()方法需要传入两个参数。第一个参数是一个字符串，用于取代发现的匹配。第二个参数是一个字符串，即正则表达式。sub()方法返回替换完成后的字符串。

>>> namesRegex = re.compile(r'Agent \w+')   # 匹配'Agent'+' '+'单词'到下一个数字或空格停止 
>>> namesRegex.sub('CENSORED', 'Agent Alice gave the secret documents to Agent Bob.')
'CENSORED gave the secret documents to CENSORED.'

在 sub()的第一个参数中，可以输入\1、\2、\3……。表示“在替换中输入分组 1、2、3……的文本”。

>>> agentNamesRegex = re.compile(r'Agent (\w)\w*')  # 匹配'Agent'+' '+'单词'到下一个数字或空格停止
>>> agentNamesRegex.sub(r'\1****', 'Agent Alice told Agent Carol that Agent Eve knew Agent Bob was a double agent.')    # 此处的\1代表(\w)的内容
A**** told C**** that E**** knew B**** was a double agent.'

对于re.sub(pattern, repl, string, count=0, flags=0)

pattern: 要搜索和替换的正则表达式模式。
repl: 替换 pattern 匹配的字符串的内容。
string: 要进行替换操作的原始字符串。
count（可选参数）: 指定替换的最大次数。默认值为 0，表示替换所有匹配项。
flags（可选参数）: 用于修改正则表达式引擎的行为，比如 re.IGNORECASE 可以使匹配对大小写不敏感。

re.sub() 函数在 string 中搜索 pattern 匹配的部分，并用 repl 参数指定的内容替换它们。如果 pattern 在 string 中找到了多个匹配项，将会替换所有的匹配项，除非指定了 count 参数来限制替换的次数。

7.13 管理复杂的正则表达式

为了在复杂的正则表达式中添加注释，你可以告诉 re.compile()，忽略正则表达式字符串中的空白符和注释，从而缓解这一点。要实现这种详细模式，可以向 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})?)')

可以为它添加注释：

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

前面的例子使用了三重引号('")，创建了一个多行字符串。这样就可以将正则表达式定义放在多行中，让它更可读。

7.14 组合使用re.IGNOREC ASE、re.DOTALL和re.VERBOSE

re.compile()函数只接受一个值作为它的第二参数。可以使用管道字符（|）将变量组合起来，从而绕过这个限制。管道字符在这里称为“按位或”操作符。

例如：

>>> someRegexValue = re.compile('foo', re.IGNORECASE | re.DOTALL)

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

这个语法有一点老式，源自于早期的 Python 版本。位运算符的细节超出了本书的范围，更多的信息请查看资源 http://nostarch.com/automatestuff/。可以向第二个参数传入其他选项，它们不常用，但你也可以在前面的资源中找到有关它们的信息。

7.15 项目：电话号码和E-mail地址提取程序

例如，你的电话号码和 E-mail 地址提取程序需要完成以下任务：

从剪贴板取得文本。

找出文本中所有的电话号码和 E-mail 地址。

将它们粘贴到剪贴板。

现在你可以开始思考，如何用代码来完成工作。代码需要做下面的事情：

使用 pyperclip 模块复制和粘贴字符串。

创建两个正则表达式，一个匹配电话号码，另一个匹配 E-mail 地址。

对两个正则表达式，找到所有的匹配，而不只是第一次匹配。

将匹配的字符串整理好格式，放在一个字符串中，用于粘贴。

如果文本中没有找到匹配，显示某种消息。

第1步：为电话号码创建一个正则表达式

# phoneAndEmail.py:

import pyperclip, re

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

# TODO: Create email regex.

# TODO: Find matches in clipboard text.

# TODO: Copy results to the clipboard.

第2步：为E-mail地址创建一个正则表达式

# Create email regex.
emailRegex = re.compile(r'''(
    [a-zA-Z0-9._%+-]+           # username
    @                          # @ symbol
    [a-zA-Z0-9.-]+              # domain name
    (\.[a-zA-Z]{2,4})           # dot-something
    )''', re.VERBOSE)

第3步：在剪贴板文本中找到所有匹配

# Find matches in clipboard text.
text = str(pyperclip.paste())
matches = []
for groups in phoneRegex.findall(text):
    phoneNum = '-'.join([groups[1], groups[3], groups[5]])
    if groups[8] != '':
        phoneNum += ' x' + groups[8]
    matches.append(phoneNum)
for groups in emailRegex.findall(text):
matches.append(groups[0])

你希望添加的电话号码是唯一的、标准的格式。phoneNum 变量包含一个字符串，它由匹配文本的分组 1、3、5 和 8 构成。

第4步：所有匹配连接成一个字符串，复制到剪贴板

# Copy results to the clipboard.
if len(matches) > 0:
    pyperclip.copy('\n'.join(matches))
    print('Copied to clipboard:')
    print('\n'.join(matches))
else:
    print('No phone numbers or email addresses found.')

第 5 步：运行程序

可以在Web浏览器随便选择一个页面按下 Ctrl-A 选择该页的所有文本，按下 Ctrl-C将它复制到剪贴板。运行这个程序。

例如:

Copied to clipboard:
800-420-7240
415-863-9900
415-863-9950
info@nostarch.com
media@nostarch.com
academic@nostarch.com
help@nostarch.com

第6步：类似程序的构想

识别文本的模式（并且可能用 sub()方法替换它们）有许多不同潜在的应用。

寻找网站的 URL，它们以 http://或 https://开始。

整理不同日期格式的日期（诸如 3/14/2015、03-14-2015 和 2015/3/14），用唯一的标准格式替代。

删除敏感的信息，诸如社会保险号或信用卡号。

寻找常见打字错误，诸如单词间的多个空格、不小心重复的单词，或者句子末尾处多个感叹号。

7.16 小结

Python 自带的 re 模块让你编译 Regex 对象。该对象有几种方法：search()查找单词匹配，findall()查找所有匹配实例，sub()对文本进行查找和替换。

可以在官方 Python 文档中找到更多内容：re — Regular expression operations — Python 3.12.2 documentation。

指南网站 Regular-Expressions.info - Regex Tutorial, Examples and Reference - Regexp Patterns也是很有用的资源。

LinYinOrTa

关注

29
点赞
踩
16

收藏

觉得还不错? 一键收藏
1
评论
Python编程快速上手第七章正则表达式

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')]。
复制链接

扫一扫