⭐模式匹配与正则表达式
文章目录
- 前言
- 一、普通方法查找文本
- 二、正则表达式查找文本
-
- 2.1 正则表达式
- 2.2 用正则表达式匹配更多模式
- 三、贪心和非贪心匹配
- 四、findall()方法
- 五、字符分类
- 六、建立自己的字符分类
- 七、插入字符和美元字符
- 八、通配字符
-
- 8.1 用点-星匹配所有字符
- 8.2 用句点字符匹配换行
- 九、正则表达式符号复习⭐
- 十、正则表达式使用
-
- 10.1 不区分大小写的匹配
- 10.2 用sub()方法替换字符串
- 10.3 管理复杂的正则表达式
- 10.4 组合使用re.IGNORECASE、re.DOTALL 和re.VERBOSE
- 习题
- 项目案例
-
- 1. 电话号码和E-mail 地址提取程序
- 总结
前言
一直想找个机会好好的学习正则表达式的基础知识，现在随着学习和复习Python有关知识遇到了正则表达式，在此记录，以便日后复习使用。
正则表达式的主要应用是网络爬虫，日后学习爬虫遇到新的感悟体会会不断加入到这篇博客。
一、普通方法查找文本
保存isPhoneNumber.py：在字符串中查找电话号码。例如：415-555-4242
# 不用正则表达式来查找文本模式
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 foound:'+chunk)
# print('Done')
二、正则表达式查找文本
正则表达式，简称为regex，是文本模式的描述方法。例如，\d 是一个正则表达式，表示一位数字字符，即任何一位 0 到 9 的数字。
正则表达式可以复杂得多。例如，在一个模式后加上花括号包围的3（{3}），就是说，“匹配这个模式3 次”。所以较短的正则表达式\d{3}-\d{3}-\d{4}，也匹配正
确的电话号码格式。
2.1 正则表达式
⭐Python 中使用正则表达式有几个步骤:
- 用
import re导入正则表达式模块。- 用
re.compile()函数创建一个Regex对象（记得使用原始字符串）。- 向
Regex对象的search()方法传入想查找的字符串。它返回一个Match对象。- 调用
Match对象的group()方法，返回实际匹配文本的字符串。
- 创建正则表达式对象
>>> import re
向re.compile()传入一个字符串值，表示正则表达式，它将返回一个Regex 模式对象（或者就简称为Regex 对象）。
正则表达式常常使用倒斜杠，向re.compile()函数传入原始字符串就很方便， 而不是输入额外得到斜杠。输入r'\d\d\d-\d\d\d-\d\d\d\d'， 比输入’\d\d\d-\d\d\d-\d\d\d\d’要容易得多。
>>> phoneNumRegex = re.compile(r'\d\d\d-\d\d\d-\d\d\d\d')
现在phoneNumRegex 变量包含了一个Regex 对象。
- 匹配Regex 对象
Regex 对象的search()方法查找传入的字符串，寻找该正则表达式的所有匹配。如果字符串中没有找到该正则表达式模式，search()方法将返回None。如果找到了该模式，search()方法将返回一个Match 对象。
>>> 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
变量名mo 是一个通用的名称，用于Match 对象。
2.2 用正则表达式匹配更多模式
- 利用括号分组
添加括号将在正则表达式中创建“分组”：(\d\d\d)-(\d\d\d-\d\d\d\d)。然后可以使用group()匹配对象方法，从一个分组中获取匹配的文本。
正则表达式字符串中的第一对括号是第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
- 多重复制的技巧
>>> mo.groups()
('415', '555-4242')
>>> areaCode, mainNumber = mo.groups()
>>> print(areaCode)
415
>>> print(mainNumber)
555-4242
- 用管道匹配多个分组
字符
|称为“管道”。希望匹配许多表达式中的一个时，就可以使用它。
例如，正则表达式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'
只要出现括号，就可以使用group()
⭐方法调用mo.group()返回了完全匹配的文本’Batmobile’，而mo.group(1)只是返回第一个括号分组内匹配的文本’mobile’。通过使用管道字符和分组括号，可以指定几种可选的模式，让正则表达式去匹配。
- 用问号实现可选匹配
字符
?表明它前面的分组在这个模式中是可选的，匹配?之前的分组零次或一次
>>> 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'
>>> mo2.group(1)
'wo'
正则表达式中的(wo)?部分表明，模式wo 是可选的分组。该正则表达式匹配的文本中，wo 将出现零次或一次。这就是为什么正则表达式既匹配’Batwoman’，又匹配’Batman’。
如果需要匹配真正的问号字符，就使用转义字符?
- 用星号匹配零次或多次
*（称为星号）意味着“匹配零次或多次”，即星号之前的分组，可以在文本中出现任意次。它可以完全不存在，或一次又一次地重复.
>>> 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'
如果需要匹配真正的星号字符，就在正则表达式的星号字符前加上倒斜杠，即*
- 用加号匹配一次或多次
+（加号）则意味着"匹配一次或多次"，加号不同，加号前面的分组必须"至少出现一次"
在这里插入代码片>>> 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
如果需要匹配真正的加号字符，在加号前面加上倒斜杠实现转义：+。
- 用花括号匹配特定次数
花括号让正则表达式更简短
如果想要一个分组重复特定次数，就在正则表达式中该分组的后面，跟上花括号包围的数字.
- 正则表达式
(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))
>>> haRegex = re.compile(r'(Ha){3}')
>>> mo1 = haRegex.search('HaHaHa')
>>> mo1.group()
'HaHaHa'
>>> mo2 = haRegex.search('Ha')
>>> mo2 == None
True
三、贪心和非贪心匹配
- 问题引入
在字符串’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'
# 非贪心版本
>>> nongreedyHaRegex = re.compile(r'(Ha){3,5}?')
>>> mo2 = nongreedyHaRegex.search('HaHaHaHaHa')
>>> mo2.group()
'HaHaHa'
请注意，问号在正则表达式中可能有两种含义：
- 声明非贪心匹配
- 表示可选的分组。
这两种含义是完全无关的。
四、findall()方法
search()将返回一个Match对象，包含被查找字符串中的“第一次”匹配的文本
findall()方法将返回一组字符串列表（返回的是列表，列表内容是字符串），包含被查找字符串中的所有匹配
- 案例展示
>>> 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') # has no groups
>>> phoneNumRegex.findall('Cell: 415-555-9999 Work: 212-555-0000')
['415-555-9999', '212-555-0000']
- 有分组 —有括号
有分组，那么findall()将返回
元组的列表（多个括号[>1]的情况下）。每个元组表示一个找到的匹配，其中的项就是正则表达式中每个分组的匹配字符串
- 上述验证
>>> import re
# --------------只有一个括号和没有括号的情况相同-----------------------
# 1. 一个括号
>>> 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']
>>> 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', '212-555']
# 2. 没有括号
>>> 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']
-------------------------------------------------------------------------
# 3. 两个括号 返回的列表中含有元组
>>> 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')]
# 4. 三个括号 返回的列表中含有元组
>>> 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')]
- 结论
- 如果调用在一个没有分组或只有一个分组的正则表达式上，例如：
\d\d\d-\d\d\d-\d\d\d\d，方法
findall()将返回一个匹配字符串的列表，例如[‘415-555-9999’, ‘212-555-0000’]。- 如果调用在一个有分组的正则表达式上，例如：
(\d\d\d)-(\d\d\d)-(\d\d\d\d)，方法findall()将返回一个字符串的元组的列表（每个分组对应一个字符串）,例如[(‘415’,‘555’, ‘1122’), (‘212’, ‘555’, ‘0000’)]
使用findall()方法，无法使用group()函数
五、字符分类
- 常用字符分类的缩写代码
缩写字符分类 表示
\d 0 到9 的任何数字
\D 除0 到9 的数字以外的任何字符
\w 任何字母、数字或下划线字符（可以认为是匹配“单词”字符）
\W 除字母、数字和下划线以外的任何字符
\s 空格、制表符或换行符（可以认为是匹配“空白”字符）
\S 除空格、制表符和换行符以外的任何字符
字符分类对于缩短正则表达式很有用。字符分类[0-5]只匹配数字0 到5，这比输入(0|1|2|3|4|5)要短很多。
'''
\d+\s\w+匹配的文本有一个或多个数字(\d+)，
接下来是一个空白字符(\s)，
接下来是一个或多个字母/数字/下划线字符(\w+)
'''
>>> 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']
findall()方法将返回所有匹配该正则表达式的字符串，放在一个列表中。
六、建立自己的字符分类
使用
[ ]（方括号)定义自己的字符分类
- 字符分类
[aeiouAEIOU]将匹配所有元音字符，不论大小写。- 使用短横表示字母或数字的范围，字符分类
[a-zA-Z0-9]将匹配所有小写字母、大写字母和数字。- 通过在字符分类的左方括号后加上一个
插入字符（^），就可以得到“非字符类”。非字符类将匹配不在这个字符类中的所有字符。
# 代码一
>>> vowelRegex = re.compile(r'[aeiouAEIOU]')
>>> vowelRegex.findall('RoboCop eats baby food. BABY FOOD.')
['o', 'o', 'o', 'e', 'a', 'a', 'o', 'o', 'A', 'O', 'O']
# 代码二 不是匹配所有元音字符，而是匹配所有非元音字符
>>> 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', '.']
- ⭐请注意，在方括号内，普通的正则表达式符号不会被解释：例如，字符分类将匹配数字0 到5 和一个句点。你不需要将它写成[0-5.]。
七、插入字符和美元字符
插入符号（^）:表明匹配必须发生在被查找文本开始处。{⭐注意和[^字符串]区分}美元符号($)：表示该字符串必须以这个正则表达式的模式结束。
同时使用^和$，表明整个字符串必须匹配该模式，也就是说，只匹配该字符串的某个子集是不够的。
# 代码一
>>> beginsWithHello = re.compile(r'^Hello')
# 以 Hello 开头
>>> beginsWithHello.search('Hello world!')
<_sre.SRE_Match object; span=(0, 5), match='Hello'>
# 不以 Hello 开头
>>> beginsWithHello.search('He said hello.') == None
True
# 代码二 r'\d$'匹配以数字0到9结束的字符串。
>>> 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
# 代码三 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
八、通配字符
在正则表达式中，
.（句点）字符称为“通配符”。它匹配除了换行之外的所有字符。
要记住，句点字符只匹配一个字符。
要匹配真正的句点，用倒斜杠转义：\.
8.1 用点-星匹配所有字符
句点字符表示“除换行外所有单个字符”
星号字符表示“前面字符出现零次或多次”
>>> 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'
点-星使用
“贪心”模式，总是匹配尽可能多的文本
“非贪心”模式匹配所有文本，就使用点-星和问号
# 非贪心模式
>>> nongreedyRegex = re.compile(r'<.*?>')
>>> mo = nongreedyRegex.search(' for dinner.>' )
>>> mo.group()
''
# 贪心模式
>>> greedyRegex = re.compile(r'<.*>')
>>> mo = greedyRegex.search(' for dinner.>' )
>>> mo.group()
' for dinner.>'
'''
两个正则表达式都可以翻译成“匹配一个左尖括号，接下来是任意字符，接下来是一个右尖括号”。但是字符串'<To serve man> for dinner.>'对右肩括号有两种可能的匹配。
在非贪心的正则表达式中，Python 匹配最短可能的字符串：'<To serve man>'。
在贪心版本中,Python 匹配最长可能的字符串：'<To serve man> for dinner.>'。
'''
8.2 用句点字符匹配换行
点-星将匹配除换行外的所有字符。通过传入
re.DOTALL作为re.compile()的第二个参数，可以让句点字符匹配所有字符，包括换行字符。
# `search()`将返回一个Match对象，包含被查找字符串中的“第一次”匹配的文本
>>> noNewlineRegex = re.compile('.*')
>>> noNewlineRegex.search('Serve the public trust.\nProtect the innocent.
\nUphold the law.').group()
'Serve the public trust.'
>>> 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.'
九、正则表达式符号复习⭐
?匹配零次或一次前面的分组。
*匹配零次或多次前面的分组。
+匹配一次或多次前面的分组。
{
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]匹配不在方括号内的任意字符。
十、正则表达式使用
10.1 不区分大小写的匹配
要让正则表达式不区分大小写，可以向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.search('ROBOCOP protects the innocent.').group()
'ROBOCOP'
>>> robocop.search('Al, why does your programming book talk about robocop so much?').group()
'robocop'
10.2 用sub()方法替换字符串
正则表达式不仅能找到文本模式，而且能够用新的文本替换掉这些模式。
Regex对象的sub()方法需要传入两个参数。
- 第一个参数是一个字符串，用于取代发现的匹配。
- 第二个参数是一个字符串，即正则表达式。
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.'
在sub()的第一个参数中，可以输入\1、\2、\3……。表示“在替换中输入分组1、2、3……的文本”。
>>> 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.'
10.3 管理复杂的正则表达式
匹配复杂的文本模式，可能需要长的、费解的正则表达式。
你可以告诉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)
'''
请注意，前面的例子使用了三重引号，
创建了一个多行字符串。
这样就可以将正则表达式定义放在多行中，让它更可读。
'''
正则表达式字符串中的注释规则:
#符号和它后面直到行末的内容，都被忽略
10.4 组合使用re.IGNORECASE、re.DOTALL 和re.VERBOSE
- 问题引入
如果你希望在正则表达式中使用re.VERBOSE 来编写注释，还希望使用
re.IGNORECASE来忽略大小写，该怎么办？
re.compile()函数只接受一个值作为它的第二参数。可以使用管道字符（|）将变量组合起来，从而绕过这个限制。管道字符在这里称为“按位或”操作符。
# 不区分大小写，并且句点字符匹配换行
>>> someRegexValue = re.compile('foo', re.IGNORECASE | re.DOTALL)
# 使用第二个参数的全部3 个选项
someRegexValue = re.compile('foo', re.IGNORECASE | re.DOTALL | re.VERBOSE)
习题
- 创建Regex 对象的函数是什么？
re.compile() 函数返回Regex 对象。
- 在创建Regex 对象时，为什么常用原始字符串？
使用原始字符串是为了让反斜杠不必转义。
- search()方法返回什么？
search() 方法返回Match 对象。
- 通过Match 对象，如何得到匹配该模式的实际字符串？
group() 方法返回匹配文本的字符串。
- 用r’(\d\d\d)-(\d\d\d-\d\d\d\d)'创建的正则表达式中，分组0 表示什么？分组1呢？分组2 呢？
分组0 是整个匹配，分组1 包含第一组括号，分组2 包含第二组括号。
- 括号和句点在正则表达式语法中有特殊的含义。如何指定正则表达式匹配真正的括号和句点字符？
句号和括号可以用反斜杠转义：\.、\(、\）
- ⭐ findall()方法返回一个字符串的列表，或字符串元组的列表。是什么决定它提供哪种返回？
如果正则表达式没有分组，就返回字符串的列表。如果正则表达式有分组，就返回字符串的元组的列表。
- 在正则表达式中，|字符表示什么意思？
| 字符表示匹配两个组中的“任何一个”。
- 在正则表达式中，?字符有哪两种含义？
? 字符可以表示“匹配前面分组0 次或1 次”，或用于表示非贪心匹配。
- 在正则表达式中，+和*字符之间的区别是什么？
+匹配1 次或多次。*匹配0 次或多次。
- 在正则表达式中，{3}和{3,5}之间的区别是什么？
{3}匹配前面分组的精确3 次实例。{3, 5} 匹配3至5次实例。
- 在正则表达式中，\d、\w 和\s 缩写字符类是什么意思？
缩写字符分类\d、\w 和\s 分别匹配一个数字、单词或空白字符。
- 在正则表达式中，\D、\W 和\S 缩写字符类是什么意思？
缩写字符分类\D、\W 和\S 分别匹配一个字符，它不是数字、单词或空白字符
缩写字符分类 表示
\d 0 到9 的任何数字
\D 除0 到9 的数字以外的任何字符
\w 任何字母、数字或下划线字符（可以认为是匹配“单词”字符）
\W 除字母、数字和下划线以外的任何字符
\s 空格、制表符或换行符（可以认为是匹配“空白”字符）
\S 除空格、制表符和换行符以外的任何字符
- 如何让正则表达式不区分大小写？
将re.I 或re.IGNORECASE 作为第二个参数传入re.compile()，让匹配不区分大小写
- 字符.通常匹配什么？如果re.DOTALL 作为第二个参数传递给re.compile()，它会匹配什么？
字符.通常匹配任何字符，换行符除外。如果将re.DOTALL 作为第二个参数传入re.compile()，那么点也会匹配换行符
- .*和*?之间的区别是什么？
.*执行贪心匹配，*?执行非贪心匹配
- 匹配所有数字和小写字母的字符分类语法是什么？
[0-9a-z]或[a-z0-9]
- 如果numRegex = re.compile(r’\d+’)，那么
numRegex.sub(‘X’, ‘12 drummers, 11 pipers, five rings, 3 hens’)返回什么？
‘X drummers, X pipers, five rings, X hens’
- 将re.VERBOSE 作为第二个参数传递给re.compile()，让你能做什么？
re.VERBOSE 参数允许为传入 re.compile() 的字符串添加空格和注释。
- 如何写一个正则表达式，匹配每3 位就有一个逗号的数字？它必须匹配以下数字
· ‘42’
· ‘1,234’
· ‘6,368,745’
但不会匹配：
· ‘12,34,567’ （逗号之间只有两位数字）
· ‘1234’ （缺少逗号）
re.compile（r’^\d{1,3}(,{3})*$’）将创建这个正则表达式，但其他正则表达式字符串可以生成类似的正则表达式
- 如何写一个正则表达式，匹配姓Nakamoto 的完整姓名？你可以假定名字总是出现在姓前面，是一个大写字母开头的单词。该正则表达式必须匹配：
· ‘Satoshi Nakamoto’
· ‘Alice Nakamoto’
· ‘RoboCop Nakamoto’
但不匹配：
· ‘satoshi Nakamoto’（名字没有大写首字母）
· ‘Mr. Nakamoto’（前面的单词包含非字母字符）
· ‘Nakamoto’ （没有名字）
· ‘Satoshi nakamoto’（姓没有首字母大写）
re.compile(r’[A-Z][a-z]*\sNakamoto’)
- 如何编写一个正则表达式匹配一个句子，它的第一个词是Alice、Bob 或Carol，第二个词是eats、pets 或throws，第三个词是apples、cats 或baseballs。该句子以句点结束。这个正则表达式应该不区分大小写。它必须匹配：
· ‘Alice eats apples.’
· ‘Bob pets cats.’
· ‘Carol throws baseballs.’
· ‘Alice throws Apples.’
· ‘BOB EATS CATS.’
但不匹配：
· ‘RoboCop eats apples.’
· ‘ALICE THROWS FOOTBALLS.’
· ‘Carol eats 7 cats.’
re.compile(r’(Alice|Bob|Carol)\s(eats|pets|throws)\s(apples|cats|baseballs).’,
re.IGNORECASE)
项目案例
1. 电话号码和E-mail 地址提取程序
- 任务描述
在一篇长的网页或文章中，找出所有电话号码和邮件地址
- 任务列表
- 从剪贴板取得文本。
- 找出文本中所有的电话号码和E-mail 地址。
- 将它们粘贴到剪贴板。
- 代码编写列表
- 使用pyperclip 模块复制和粘贴字符串。
- 创建两个正则表达式，一个匹配电话号码，另一个匹配E-mail 地址。
- 对两个正则表达式，找到所有的匹配，而不只是第一次匹配。
- 将匹配的字符串整理好格式，放在一个字符串中，用于粘贴。
- 如果文本中没有找到匹配，显示某种消息。
- 为电话号码创建一个正则表达式
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)
'''
电话号码从一个“可选的”区号开始,区号分组跟着一个问号。
(415) 555-4242
因为区号可能只是3 个数字（\d{3}）或括号中的3 个数字（即\(\d{3}\)）
电话号码分割字符可以是空格（\s）、短横（-）或句点（.）
接下来的几部分:3 个数字，接下来是另一个分割符，接下来是4 个数字。最后的部分是可选的分机号，包括任意数目的空格，接着ext、x 或ext.，再接着2 到5 位数字。
'''
- 为E-mail 地址创建一个正则表达式
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)
'''
E-mail地址
用户名部分 : 一个或多个字符，可以包括：小写和大写字母、数字、句点、下划线、百分号、加号或短横，放入一个字符分类：[a-zA-Z0-9._%+-]
域名和用户名用@符号分割@
域名只允许字母、数字、句点和短横：[a-zA-Z0-9.-]
“dot-com”部分（技术上称为“顶级域名”），它实际上可以是“dot-anything”。它有2 到4 个字符
'''
正则表达式中() [] {}的区别
- 在剪贴板文本中找到所有匹配
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])
'''
1.每个匹配对应一个元组[一个括号即为一个元组，步骤一有5个括号]
每个元组包含正则表达式中每个分组的字符串
2.对于E-mail 地址，你将每次匹配的分组0[即所有内容，格式不变]添加到列表中
3.对于匹配的电话号码，你不想只是添加分组0。虽然程序可以“检测”
几种不同形式的电话号码，你希望添加的电话号码是唯一的、标准的格式。
phoneNum 变量包含一个字符串，它由匹配文本的分组1、3、5 和8 构成。
（这些分组是区号、前3 个数字、后4 个数字和分机号。）
'''
- 所有匹配连接成一个字符串，复制到剪贴板
pyperclip.copy()函数只接收一个字符串值，而不是字符串的列表，所以你在matches 上调用join()方法。
if len(matches) > 0:
pyperclip.copy('\n'.join(matches))
# print(matches)
print('Copied to clipboard:')
print('\n'.join(matches))
else:
print('No phone numbers or email addresses found.')
- 运行程序
输入文本：
[email protected]
[email protected]
[email protected]
[email protected]
800-420-7240
Python 编程快速上手——让繁琐工作自动化
415-863-9900
415-863-9950
邮箱无法识别正在查找原因！！！
总结
1. 正则表达式中`() [] {}`的区别
括号( ) ：
括号是多个匹配，它把括号内的当做一组来处理，限制一些多选的范围，比如上面的需求只能是com cn net结尾的用括号就是最好的选择。括号能提取字符串，如(com|cn|net)就可以限制，只能是com或cn或net。括号将括号里面的内容作为一组，这就是与[]不同的地方。
方括号[ ]：方括号是单个匹配，如**[abc]他限制的不是abc连续出现，而是只能是其中一个**，这样写那么规则就是找到这个位置时只能是a或是b或是c；方括号是正则表达式中最常用的，常用的用法有：[a-zA-Z0-9]匹配所有英文字母和数字，[^a-zA-Z0-9]匹配所有非英文字母和数字。
大括号{ }： 大括号的用法很简单，就是匹配次数，它需要和其他有意义的正则表达式一起使用。
- [a-c]{2}意思就是匹配a-c之间的一个字母出现且只出现两次；
- (com){1}意思就是com必须出现一次
- \W{1,3}意思就是非字母数字最少出现一次最多出现3次。