第二章 re模块

1. re模块介绍

正则表达式

在处理字符串时，经常会有查找符合某些复杂规则的字符串的需求。正则表达式就是用于描述这些规则的工具。换句话说，正则表达式就是记录文本规则的代码。

re 模块

Python 提供了 re 模块用于实现正则表达式的操作。在实现时，可以使用 re 模块提供的方法，如search()、match()、findall() 等，进行字符串处理，也可以先使用 re 模块的 compile() 方法将模式字符串转换为正则表达式对象，然后再使用该正则表达式对象的相关方法来操作字符串。re 模块在使用时，需要先用 import 语句引入，具体代码如下：

import re

2. 定位符，描述字符的边界

3. 预定义字符集，标准字符转义序列

4. 通配符，匹配非预定义字符集合

在正则表达式中，提供了一个通配符——英文状态下输入的“.”，用于匹配除“\r”和“\n”以外的任意单个字符。如果想要使用“.”匹配“\n”换行符，则需要指定 flags=re.DOTALL。例如，“.”可以匹配 mr\nM\tR 中的 m、r、M、\t、R。

5. 非预定义字符集，匹配非预定义字符集合

6. 限定符，限定匹配次数

7. 管道符，“或”操作

正则表达式中提供了管道符，即“或”操作符，用于匹配两个或者多个正则表达式中的一个。例如，A|B，其中 A 和 B 都是正则表达式，在匹配时，从左到右进行匹配，当一个样式完全匹配时，另一个就不再匹配。即如果 A 匹配成功，则 B 就不再匹配。

8. 子模式，分组

子模式也就是分组的意思，使用小括号可以对正则表达式进行分组。如 (.[0-9]{1,3}){3}，就是对分组 (.[0-9]{1,3}) 进行重复操作。

另外，小括号字符也可以改变限定符的作用范围，如“|”“*”“^”等。来看下面的一个表达式：

(thir|four)th

这个表达式的意思是匹配单词 thirth 或 fourth，如果不使用小括号，那么就变成了匹配单词 thir或 fourth 了。

9. 转义字符，将特殊字符变为普通字符

正则表达式中的转义字符（\）和 Python 中的大同小异，都是将特殊字符（如“.”“?”“\”等）变为普通字符。举一个 IP 地址的实例，用正则表达式匹配诸如 127.0.0.1 这样格式的 IP 地址，如果直接使用点字符，格式为：

[1-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}

这显然不对，因为“.”可以匹配一个任意字符。这时，不仅是 127.0.0.1 这样的 IP，连127101011 这样的字符串也会被匹配出来。所以在使用“.”时，需要使用转义字符（\）。修改后上面的正则表达式格式为：

[1-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}

10. 可选标志修饰符，控制匹配方式

在使用 re 模块提供的方法时，经常需要指定一个 flags 参数，该参数为标志修饰符，是一个可选参数。通过它可以指定是否区分字母大小写、多行匹配等。

11. compile()方法，编译为正则表达式对象

语法参考

compile() 方法用于编译正则表达式模式，返回一个对象的模式。然后可以通过 RegexObject 对象调用 match() 和 search() 方法。语法格式如下：

re.compile(pattern,flags=0)

参数说明：

• pattern ：编译时用的表达式字符串。

• flags ：编译标志位，用于修改正则表达式的匹配方式，如是否区分大小写、多行匹配等。

• 返回值：返回一个正则表达式对象。

锦囊1 查找包含指定字母的单词

使用 compile() 方法创建一个可以查找包含指定字母对应单词的正则表达式对象，并输出符合条件的英文单词，代码如下：

import re                                  			# 导入正则表达式re模块

# 需要匹配的字符串
string = “Tina is a good girl, she is cool, clever, and so on...”
match = re.compile(r’\w*oo\w*’)                  	# 创建正则表达式对象
print(match.findall(string ))                      	# 打印所有包含“oo”的单词

12. escape()方法，转义特殊字符

语法参考

escape() 方法用于对字符串中的非字母数字进行转义。语法格式如下：

re.escape(pattern)

参数说明：

• pattern ：表示模式字符串，由要匹配的正则表达式转换而来。

• 返回值：返回转义后的字符串。

锦囊1 对字符串中的非字母数字进行转义

使用 escape() 方法实现对字符串中的非字母数字进行转义，代码如下：

import re                   			# 导入正则表达式re模块

# 需要转义的字符串
string = ‘abcdefghijklmnopqrstuvwxyz0123456789!#$%&*+-.^_`|~’
print(re.escape(string))           		# 打印转义后的字符串

程序运行结果如下：

abcdefghijklmnopqrstuvwxyz0123456789!\#\$%\&\*\+\-\.\^_`\|\~

13. f indall()方法，搜索所有符合正则表达式的字符串

语法参考

findall() 方法用于在整个字符串中搜索所有符合正则表达式的字符串，并以列表的形式返回。如果匹配成功，则返回包含匹配结构的列表，否则返回空列表。语法格式如下：

re.findall(pattern, string, flags=0)

参数说明：

• pattern ：表示模式字符串，由要匹配的正则表达式转换而来。decimal

• string ：表示要匹配的字符串。

• flags ：可选参数，表示标志位，用于控制匹配方式，如是否区分字母大小写。

• 返回值：返回一个符合表达式匹配结果的列表。

锦囊1 搜索以“mr_”开头的字符串

使用 findall() 方法搜索以“mr_”开头的字符串，代码如下：

import re                                     			# 导入正则表达式re模块

pattern = r’mr_\w+’                          			# 模式字符串
string = ‘MR_SHOP mr_shop’                   			# 要匹配的字符串
match = re.findall(pattern,string,re.I)                	# 搜索字符串，不区分大小写
print(match)                               				# 打印匹配结果

string = ‘项目名称MR_SHOP mr_shop’
match = re.findall(pattern,string)                 		# 搜索字符串，区分大小写
print(match)                               				# 打印匹配结果

14. f inditer()方法，找到所匹配的所有子串

语法参考

finditer() 方法和 findall() 方法类似，它的功能为在字符串中找到正则表达式所匹配的所有子串，但是把它们作为一个迭代器返回。语法格式如下：

re.finditer(pattern, string, flags=0)

参数说明：

• pattern ：表示匹配的正则表达式。

• string ：表示要匹配的字符串。

• flags ：表示标志位，用户控制正则表达式的匹配方式，如是否区分大小写、多行匹配等。

• 返回值：返回一个符合表达式匹配结果的迭代器。

锦囊1 获取字符串中的数字

使用 finditer() 方法获取字符串中的所有数值，代码如下：

import re                              		# 导入正则表达式re模块

# 获取字符串中的数字
it = re.finditer(r”\d+”,”12a32bc43jf3”)

# 便利获取后的迭代对象
for match in it:
	print (match.group())                  	# 打印数字

15. fullmatch()方法，对整个字符串进行匹配

语法参考

fullmatch() 方法用于对整个字符串进行匹配，如果整个字符串匹配到正则表达式样式，就返回一个相应的匹配对象，否则就返回一个 None。语法格式如下：

re.fullmatch(pattern,string,flags=0)

参数说明：

• pattern ：表示模式字符串，由要匹配的正则表达式转换而来。

• string ：表示要匹配的字符串。

• flags ：可选参数，表示标志位，用于控制匹配方式，如是否区分字母大小写。

• 返回值：如果整个 string 匹配到正则表达式样式，就返回一个相应的 。

锦囊1 匹配整个字符串

使用 fullmatch() 方法实现匹配整个字符串，代码如下：

import re                                      		# 导入正则表达式re模块
string1 = “mr00soft”                             	# 需要匹配的字符串

# 匹配包括下划线在内的任何字符，并匹配前面的子表达式一次或多次
match1 = re.fullmatch(‘\w+’, string1)

# 单个字符匹配任意次，贪婪匹配
match2 = re.fullmatch(‘.*’, string1)decimal

# 匹配多个数字
match3 = re.fullmatch(‘\d+’, string1)
print(match1)
print(match2)
print(match3)

程序运行结果如下：

<re.Match object; span=(0, 8), match='mr00soft'>
<re.Match object; span=(0, 8), match='mr00soft'>
None

16. match()方法，从字符开始处进行匹配

语法参考

match() 方法用于从字符串的开始处进行匹配，如果在起始位置匹配成功，则返回 Match 对象，否则返回 None。语法格式如下：

re.match(pattern,string,flags=0)

参数说明：

• pattern ：表示模式字符串，由要匹配的正则表达式转换而来。

• string ：表示要匹配的字符串。

• flags ：可选参数，表示标志位，用于控制匹配方式，如是否区分字母大小写。

• 返回值：如果 string 的开始处有 0 或多个字符匹配到了正则表达式样式，就返回一个相应的 。

锦囊1 判断匹配字符串是否以“mr_”开头

使用 match() 方法判断匹配字符串是否以“mr_”开头，不区分字母大小写，代码如下：

import re                                		# 导入正则表达式re模块

pattern = r’mr_\w+’                        		# 模式字符串
string = ‘MR_SHOP mr_shop’                		# 要匹配的字符串
match = re.match(pattern,string,re.I)           # 匹配字符串，不区分大小写
print(match)                             		# 打印匹配结果

string = ‘项目名称MR_SHOP mr_shop’
match = re.match(pattern,string,re.I)           # 匹配字符串，不区分大小写
print(match)                             		# 打印匹配结果

程序运行结果如下：

<re.Match object; span=(0, 7), match='MR_SHOP'>
None

17. search()方法，搜索第一个匹配位置

语法参考

search() 方法用于在整个字符串中搜索第一个匹配的值，如果匹配成功，则返回 Match 对象，否则返回 None。语法格式如下：

re.search(pattern,string,flags=0)

参数说明：

• pattern ：表示模式字符串，由要匹配的正则表达式转换而来。

• string ：表示要匹配的字符串。

• flags ：可选参数，表示标志位，用于控制匹配方式，如是否区分字母大小写。

• 返回值：扫描整个字符串找到匹配样式的第一个位置，并返回一个相应的匹配对象。如果没有匹配，就返回一个 None。注意，这和找到一个零长度匹配是不同的。

锦囊1 搜索第一个以“mr_”开头的字符串

使用 search() 方法搜索第一个以“mr_”开头的字符串，不区分字母大小写，代码如下：

import re                                  		# 导入正则表达式re模块

pattern = r’mr_\w+’                          	# 模式字符串
string = ‘MR_SHOP mr_shop’                  	# 要匹配的字符串
match = re.search(pattern,string,re.I)          # 搜索字符串，不区分大小写
print(match)                                	# 打印匹配结果

string = ‘项目名称MR_SHOP mr_shop’
match = re.search(pattern,string,re.I)         	# 搜索字符串，不区分大小写
print(match)                                	# 打印匹配结果

程序运行结果如下：

<re.Match object; span=(0, 7), match='MR_SHOP'>
<re.Match object; span=(4, 11), match='MR_SHOP'>

18. split()方法，根据正则表达式分割字符串

语法参考

split() 方法用于实现根据正则表达式分割字符串，并以列表的形式返回。其作用同字符串对象的 split() 方法类似，所不同的就是分割字符由模式字符串指定。语法格式如下：

re.split(pattern,string,maxsplit=0,flags=0)

参数说明：

• pattern ：表示模式字符串，由要匹配的正则表达式转换而来。

• string ：表示要匹配的字符串。

• maxsplit ：可选参数，表示最大的拆分次数。

• flags ：可选参数，表示标志位，用于控制匹配方式，如是否区分字母大小写。

• 返回值：返回一个分割后的字符串列表。

锦囊1 从给定的 URL 地址中提取出请求地址和各个参数

使用split()方法实现从给定的 URL 地址中提取出请求地址和各个参数的功能，代码如下：

import re                               		# 导入正则表达式re模块

pattern = r’[?|&]’                         		# 定义分割符
url = ‘http://www.888.com/login.jsp?username=”mr”&pwd=”mrsoft”’
result = re.split(pattern,url)                 	# 分割字符串
print(result)

程序运行结果如下：

['http://www.888.com/login.jsp','username="mr"','pwd="mrsoft"']

19. sub()方法，字符串替换

语法参考

sub() 方法用于实现字符串替换。语法格式如下：

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

参数说明：

• pattern ：表示模式字符串，由要匹配的正则表达式转换而来。

• repl ：表示替换的字符串。

• string ：表示要被查找替换的原始字符串。

• count ：可选参数，表示模式匹配后替换的最大次数，默认值为 0，表示替换所有的匹配。

• flags ：可选参数，表示标志位，用于控制匹配方式，如是否区分字母大小写。

• 返回值：返回替换后的字符串。

锦囊1 隐藏中奖信息中的手机号码

使用 sub() 方法实现隐藏中奖信息中的手机号码的功能，代码如下：

import re                                      			# 导入正则表达式re模块
pattern = r’1[34578]\d{9}’                         		# 定义要替换的模式字符串
string = ‘中奖号码为：84978981 联系电话为：13611111111’
result = re.sub(pattern,’1XXXXXXXXXX’,string)       	# 替换字符串
print(result)

程序运行结果如下：

中奖号码为：84978981 联系电话为：1XXXXXXXXXX

锦囊2 排除字符串中的汉字、字母与数字

使用 sub() 方法排除字符串中的汉字、字母与数字，代码如下：

import re

# 定义需要筛选的字符串
string = ‘abcdefghijklmnopqrstuvwxyz我爱Python0123456789!#$%&*+-.^_`|~’
result = re.sub(“[A-Za-z0-9\u4e00-\u9fa5]”, ““, string) 		# 替换字符串
print(result)                                 					# 打印替换结果

程序运行结果如下：

!#$%&*+-.^_`|~

20. subn()方法，字符串替换 （含替换次数）

语法参考

subn() 方法与 sub() 方法相同，都是用于实现字符串的替换。但 subn() 方法返回一个元组，其中包含新字符串和替换次数。语法格式如下：

re.subn(pattern,repl,string,count=0,flags=0)

参数说明：

• pattern ：表示模式字符串，由要匹配的正则表达式转换而来。

• repl ：表示替换的字符串。

• string ：表示要被查找替换的原始字符串。

• count ：可选参数，表示模式匹配后替换的最大次数，默认值为 0，表示替换所有的匹配。

• flags ：可选参数，表示标志位，用于控制匹配方式，如是否区分字母大小写。

• 返回值：返回一个包含替换后字符串与替换次数的元组。

锦囊1 替换字符串中的指定内容

使用 subn() 方法实现替换字符串中的指定内容的功能，代码如下：

import re                             						# 导入正则表达式re模块

print(re.subn(‘[1-2]’,’A’,’123456abcdef’))    				# 打印元组，包含新字符串与替换次数
print(re.sub(‘g.t’,’have’,’I get A, I got B ,I gut C’)) 	# 打印新字符串
print(re.subn(‘g.t’,’have’,’I get A, I got B ,I gut C’))	# 打印元组，包含新字符串与替换次数

21. Pattern.flags属性，获取正则匹配标记

语法参考

Pattern.flags 属性用于获取正则表达式中匹配模式对应的标记。语法格式如下：

Pattern.flags

锦囊1 获取常见匹配模式对应的标记

使用 Pattern.flags 属性获取常见匹配模式对应的标记，代码如下：

import re                         				# 导入正则表达式re模块

pattern_I = re.compile(‘\w+’,flags=re.I)  		# 匹配模式，忽略大小写
pattern_M= re.compile(‘\w+’,flags=re.M) 		# 匹配模式，多行
pattern_S = re.compile(‘\w+’,flags=re.S) 		# 匹配模式，使用“.”字符匹配所有字符，包括换行符
pattern_X = re.compile(‘\w+’,flags=re.X)		# 匹配模式，忽略模式字符串中未转义的空格和注释

print(‘匹配模式I的标记为：',pattern_I.flags)
print(‘匹配模式M的标记为：',pattern_M.flags)
print(‘匹配模式S的标记为：',pattern_S.flags)
print(‘匹配模式X的标记为：',pattern_X.flags)

22. Pattern.groups属性，捕获组合的数量

语法参考

Pattern.groups 属性用于获取正则表达式中组合的数量。语法格式如下：

Pattern.groups

锦囊1 获取正则表达式中组合的数量

使用 Pattern.groups 属性获取正则表达式中组合的数量，代码如下：

import re                            			# 导入正则表达式re模块
pattern = re.compile(‘(\w+) (\w+)’)        		# 组合表达式
print(‘组合数量为：',pattern.groups)

23. Pattern.groupindex属性，获取分组名称与对应的分组编号

语法参考

Pattern.groupindex 属性用于获取正则表达式中分组名称与对应的分组编号。语法格式如下：

Pattern.groupindex

锦囊1 获取表达式中分组名称与对应的分组编号

使用 Pattern.groupindex 属性获取表达式中分组名称与对应的分组编号，代码如下：

import re                                         				# 导入正则表达式re模块
pattern = re.compile(‘(?P<group_1>\w+) (?P<group_2>\w+)’) 		# 分组表达式
print(‘分组名称与对应的编号为：',pattern.groupindex)

程序运行结果如下：

分组名称与对应的编号为： {'group_1': 1, 'group_2': 2}

24. Pattern.pattern属性，获取模式字符串

语法参考

Pattern.pattern 属性用于获取正则表达式中的模式字符串。语法格式如下：

Pattern.pattern

锦囊1 获取表达式中的模式字符串

使用 Pattern.pattern 属性获取表达式中的模式字符串，代码如下：

import re                                         				# 导入正则表达式re模块
pattern = re.compile(‘(?P<group_1>\w+) (?P<group_2>\w+)’) 		# 分组表达式
print(pattern.pattern)

程序运行结果如下：

(?P<group_1>\w+) (?P<group_2>\w+)

25. Pattern.f indall()方法，搜索所有符合正则表达式的字符串

语法参考

Pattern.findall() 方法用于在整个字符串中搜索所有符合正则表达式的字符串，并以列表的形式返回。如果匹配成功，则返回包含匹配结构的列表，否则返回空列表。该方法可以指定匹配字符串的范围。语法格式如下：

Pattern.findall(string[,pos[,endpos]])

参数说明：

• string ：表示需要匹配的字符串。

• pos ：表示匹配的起始位置，该参数为可选参数，默认值为 0。

• endpos ：表示匹配的结束位置，该参数为可选参数，默认为需要匹配字符串的长度，所以只有从 pos 到 endpos-1 的字符会被匹配。

• 返回值：返回一个符合表达式匹配结果的列表。

锦囊1 搜索字符串中以“mr_”开头的字符串

使用 Pattern.findall() 方法搜索字符串中以“mr_”开头的字符串，代码如下：

import re                                                      	# 导入正则表达式re模块

pattern = re.compile(‘mr_\w+’)                             		# 正则表达式对象
string = ‘mr_SHOP mr_shop’                               		# 要匹配的字符串
match = pattern.findall(string)                             	# 搜索字符串

print(match)                                                   	# 打印匹配结果
print(pattern.findall(string,0,5))                         		# 打印下标0~5的结果

程序运行结果如下：

['mr_SHOP', 'mr_shop']
['mr_SH']

26. Pattern.f inditer()方法，搜索所匹配的所有子串

语法参考

Pattern.finditer() 方法用于在字符串中找到正则表达式所匹配的所有子串，把它们作为一个迭代器返回。该方法可以指定匹配字符串的范围。语法格式如下：

Pattern.finditer(string[,pos[,endpos]])

参数说明：

• string ：表示需要匹配的字符串。

• pos ：表示匹配的起始位置，该参数为可选参数，默认值为 0。

• endpos ：表示匹配的结束位置，该参数为可选参数，默认为需要匹配字符串的长度，所以只有从 pos 到 endpos-1 的字符会被匹配。

• 返回值：返回一个符合表达式匹配结果的迭代器。

锦囊1 获取字符串中指定范围的所有数字

使用 Pattern.finditer() 方法获取字符串中指定范围的所有数字，代码如下：

import re                      			# 导入正则表达式re模块

pattern = re.compile(‘\d+’)         	# 正则表达式对象
string = ‘12a32bc43jf3’           		# 要匹配的字符串
it = pattern.finditer(string,2,8)

# 遍历获取后的迭代对象
for match in it:
	print (match.group())          		# 打印数字

27. Pattern.fullmatch()方法，对整个字符串匹配

语法参考

Pattern.fullmatch() 方法用于对整个字符串匹配。从 pos 下标位置开始逐个对字符串进行匹配直到 endpos 下标位置，如果匹配成功则返回匹配成功的 Match 对象；如果没有匹配成功，就返回None。语法格式如下：

Pattern.fullmatch(string[,pos[,endpos]])

参数说明：

• string ：表示需要匹配的字符串。

• pos ：表示匹配的起始位置，该参数为可选参数，默认值为 0。

• endpos ：表示匹配的结束位置，该参数为可选参数，默认为需要匹配字符串的长度，所以只有从 pos 到 endpos-1 的字符会被匹配。

• 返回值：如果整个 string 匹配到正则表达式样式，就返回一个相应的 Match 对象。

锦囊1 获取字符串中开始处符合表达式的值

使用 Pattern.fullmatch() 方法获取字符串中开始处符合表达式的值，代码如下：

import re                        			# 导入正则表达式re模块
pattern = re.compile(‘[a-z]+’)        		# 定义匹配字母的表达式
string = ‘abcskd123jaw123’         			# 需要匹配的字符串
print(pattern.fullmatch(string,0,5))    	# 打印匹配结果，匹配范围0~5

程序运行结果如下：

<re.Match object; span=(0, 5), match='abcsk'>

28. Pattern.match()方法，从字符开始处匹配字符串的值

语法参考

Pattern.match() 方法用于从字符开始处匹配字符串的值，从 pos 下标位置开始逐个对字符串进行匹配直到 endpos 下标位置，如果匹配成功则返回匹配成功的 Match 对象；如果没有匹配成功，就返回 None。语法格式如下：

Pattern.match(string[,pos[,endpos]])

参数说明：

• string ：表示需要匹配的字符串。

• pos ：表示匹配的起始位置，该参数为可选参数，默认值为 0。

• endpos ：表示匹配的结束位置，该参数为可选参数，默认为需要匹配字符串的长度，所以只有从 pos 到 endpos-1 的字符会被匹配。

• 返回值：如果 string 开始的位置可以匹配到正则表达式样式，就返回一个相应的 Match 对象。

锦囊 获取字符串中开始处符合表达式的值

使用 Pattern.match() 方法获取字符串中开始处符合表达式的值，代码如下：

import re                                 		# 导入正则表达式re模块

pattern = re.compile(‘[a-z]+’)                 	# 定义匹配字母的表达式
string = ‘12312abc1234546lskdj’              	# 需要匹配的字符串
print(pattern.match(string,5,10))              	# 打印匹配结果，匹配范围5~10

程序运行结果如下：

<re.Match object; span=(5, 8), match='abc'>

29. Pattern.search()方法，搜索第一个匹配的位置

语法参考

Pattern.search() 方法用于搜索第一个匹配的位置，从 pos 下标位置开始逐个对字符串进行匹配直到 endpos 下标位置，如果匹配成功，则返回匹配成功的 Match 对象，否则返回 None。语法格式如下：

Pattern.search(string[,pos[,endpos]])

参数说明：

• string ：表示需要匹配的字符串。

• pos ：表示匹配的起始位置，该参数为可选参数，默认值为 0。

• endpos ：表示匹配的结束位置，该参数为可选参数，默认为需要匹配字符串的长度，所以只有从 pos 到 endpos-1 的字符会被匹配。

• 返回值：扫描整个字符串找到匹配样式的第一个位置，并返回一个相应的匹配对象。

锦囊1 获取字符串中第一个匹配值与位置

使用 Pattern.search() 方法获取字符串中第一个匹配值与位置，代码如下：

import re                       			# 导入正则表达式re模块

pattern = re.compile(‘[0-9]+’)          	# 定义匹配数字的表达式
string = ‘12312abc1234546lskdj’     		# 需要匹配的字符串
print(pattern.search(string,0,10))     		# 打印匹配结果，匹配范围0~10

程序运行结果如下：

<re.Match object; span=(0, 5), match='12312'>

30. Pattern.split()方法，同split()方法

语法参考

Pattern.split() 方法与 re.split() 方法相同，用于实现根据正则表达式分割字符串，并以列表的形式返回。其作用同字符串对象的 split() 方法类似，所不同的是分割字符由模式字符串指定。语法格式如下：

Pattern.split(string,maxsplit=0)

参数说明：

• string ：表示需要匹配的字符串。

• maxsplit ：可选参数，表示最大的拆分次数。

• 返回值：返回一个分割后的字符串列表。

锦囊1 从给定的 URL 地址中提取出请求地址和各个参数

使用 Pattern.split() 方法实现从给定的 URL 地址中提取出请求地址和各个参数，代码如下：

import re                                            	# 导入正则表达式re模块
pattern = re.compile(‘[?|&]’)                  			# 定义分割符
url = ‘http://www.888.com/login.jsp?username=”mr”&pwd=”999”’
result = pattern.split(url)                      		# 分割字符串
print(result)

['http://www.888.com/login.jsp', 'username="mr"', 'pwd="999"']

31. Pattern.sub()方法，字符串替换

语法参考

Pattern.sub() 方法与 re.sub() 方法相同，用于实现字符串替换。语法格式如下：

Pattern.sub(repl,string,count=0)

参数说明：

• repl ：表示替换的字符串。

• string ：表示要被查找替换的原始字符串。

• count ：可选参数，表示模式匹配后替换的最大次数，默认值为 0，表示替换所有的匹配。

• 返回值：返回替换后的字符串。

锦囊1 隐藏中奖信息中的手机号码

使用 Pattern.sub() 方法实现隐藏中奖信息中的手机号码的功能，代码如下：

import re                                                     	# 导入正则表达式re模块

pattern = re.compile(‘1[34578]\d{9}’)                         	# 定义要替换的模式字符串
string = ‘中奖号码为：84978981 联系电话为：13611111111’
result = pattern.sub(‘1XXXXXXXXXX’,string)             			# 替换字符串
print(result)

32. Pattern.subn()方法，字符串替换（含替换次数）

语法参考

Pattern.subn() 方法与 re.subn() 方法相同，都是用于实现字符串的替换并返回一个元组，其中包含新字符串和替换次数。语法格式如下：

Pattern.subn(repl,string,count=0)

参数说明：

• repl ：表示替换的字符串。

• string ：表示要被查找替换的原始字符串。

• count ：可选参数，表示模式匹配后替换的最大次数，默认值为 0，表示替换所有的匹配。

• 返回值：返回一个包含替换后字符串与替换次数的元组。

锦囊 替换字符串中的指定内容

使用 Pattern.subn() 方法实现替换字符串中的指定内容的功能，代码如下：

import re                           		# 导入正则表达式re模块

pattern = re.compile(‘[1-2]’)  				# 数值替换表达式，替换字符串中的1-2
pattern2 = re.compile(‘g.t’)   				# 字幕替换表达式，替换字符串中的get、got、gut

# 需要匹配的字符串
string = ‘123456abcdef’
string2 = ‘I get A, I got B ,I gut C’
print(pattern.subn(‘A’,string)) 			# 打印元组，包含新字符串与替换次数
print(pattern2.sub(‘have’,string2))   		# 打印新字符串
print(pattern2.subn(‘have’,string2)) 		# 打印元组，包含新字符串与替换次数

33. Match.endpos属性，结束匹配的索引位置

语法参考

Match.endpos 属性用于获取正则表达式在字符串结束匹配的索引位置。语法格式如下：

Match.endposdecimal

锦囊1 获取正则表达式在字符串结束匹配的索引位置

使用 Match.endpos 属性获取正则表达式在字符串结束匹配的索引位置，代码如下：

import re                                      	# 导入正则表达式re模块

pattern = re.compile(‘mr_\w+’)          		# 分组表达式
string = ‘MR_SHOP mr_shop’             			# 要匹配的字符串
match=re.search(pattern,string)           		# 匹配结果Match对象

print(match)                                	# 打印匹配的Match对象
print(match.endpos)                         	# 打印匹配的结束位置

程序运行结果如下：

<re.Match object; span=(8, 15), match='mr_shop'>
15

34. Match.pos属性，开始匹配的索引位置

语法参考

Match.pos 属性用于获取正则表达式在字符串开始匹配的索引位置。语法格式如下：

Match.pos

锦囊1 获取正则表达式在字符串开始匹配的索引位置

使用 Match.pos 属性获取正则表达式在字符串开始匹配的索引位置，代码如下：

import re                                       	# 导入正则表达式re模块

pattern = re.compile(‘mr_\w+’)             			# 分组表达式
string = ‘MR_SHOP mr_shop’             				# 要匹配的字符串
match=re.search(pattern,string)           			# 匹配结果Match对象
print(match)                                    	# 打印匹配的Match对象
print(match.pos)                               		# 打印匹配的起始位置

程序运行结果如下：

<re.Match object; span=(8, 15), match='mr_shop'>
0

35. Match.lastindex属性，捕获组的最后一个匹配的索引值

语法参考

Match.lastindex 属性用于捕获组的最后一个匹配的索引值。语法格式如下：

Match.lastindex

锦囊1 获取最后一个匹配到的组所对应的索引值

使用 Match.lastindex 属性获取最后一个匹配到的组所对应的索引值，代码如下：

import re                                      						# 导入正则表达式re模块
pattern = re.compile(‘(?P<group_1>\w+) (?P<group_2>\w+)’,re.I)   	# 分组表达式
string = ‘MR_SHOP mr_shop’             								# 要匹配的字符串
match=re.match(pattern,string)            							# 匹配结果Match对象
print(match.lastindex)                       						# 打印最后一个匹配到的组所对应的索引值

36. Match.lastgroup属性，获取最后一个匹配组的名称

语法参考

Match.lastgroup 属性用于获取最后一个匹配组的名称，如果匹配的组没有名字或者没有产生匹配的情况下，则返回 None。语法格式如下：

Match.lastgroup

锦囊1 获取最后一个匹配组的名称

使用 Match.lastgroup 属性获取最后一个匹配组的名称，代码如下：decimal

import re                                                       	# 导入正则表达式re模块
pattern = re.compile(‘(?P<group_1>\w+) (?P<group_2>\w+)‘,re.I)		# 分组表达式
string = ‘MR_SHOP mr_shop‘                              			# 要匹配的字符串
match=re.match(pattern,string)                             			# 匹配结果Match对象
print(match.lastgroup)                                       		# 打印最后一个匹配组的名称

37. Match.re属性，返回正则表达式对象

语法参考

Match.re 属性用于获取产生 Match 实例的正则表达式对象。语法格式如下：

Match.re

锦囊1 获取产生 Match 实例的正则表达式对象

使用 Match.re 属性获取产生 Match 实例的正则表达式对象，代码如下：

import re                                                               	# 导入正则表达式re模块
pattern = re.compile(‘(?P<group_1>\w+) (?P<group_2>\w+)‘,re.I)				# 分组表达式
string = ‘MR_SHOP mr_shop‘                                      			# 要匹配的字符串
match=re.match(pattern,string)                                    			# 匹配结果Match对象
print(match.re)                                                        		# 打印获取的表达式对象

程序运行结果如下：

re.compile('(?P<group_1>\\w+) (?P<group_2>\\w+)', re.IGNORECASE)

38. Match.string属性，获取需要匹配的字符串

语法参考

Match.string 属性用于获取 Match 对象中需要匹配的字符串。语法格式如下：

Match.string

锦囊1 获取 Match 对象中需要匹配的字符串

使用 Match.string 属性获取 Match 对象中需要匹配的字符串，代码如下：

import re                                            				# 导入正则表达式re模块

pattern = re.compile(‘(?P<group_1>\w+) (?P<group_2>\w+)‘,re.I)   	# 分组表达式
string = ‘MR_SHOP mr_shop‘                   						# 要匹配的字符串
match=re.match(pattern,string)                 						# 匹配结果Match对象
print(match.string)                                 				# 打印Match对象中需要匹配的字符串

39. Match.__getitem__()方法，返回一个匹配的分组信息

语法参考

Match.__getitem__() 方法与 Match.group() 方法相似，只是 __getitem__() 方法每次只能获取一个分组的信息。语法格式如下：

Match.__getitem__(g)

参数说明：

• g ：表示分组对应的编号或分组名称。

• 返回值：返回一个匹配的分组信息。

锦囊1 获取指定分组对应的信息

使用 Match.getitem() 方法获取指定分组对应的信息，代码如下：

import re                                                       	# 导入正则表达式re模块

pattern = re.compile(‘(?P<group_1>\w+) (?P<group_2>\w+)‘,re.I)		# 分组表达式
string = ‘MR_SHOP mr_shop‘                              			# 要匹配的字符串
match=re.match(pattern,string)                             			# 匹配结果Match对象
print(match.__getitem__(1))                             			# 打印指定分组编号对应内容
print(match.__getitem__(‘group_2’))                      			# 打印指定分组名对应内容

40. Match.end()方法，返回分组匹配字符串对应的结束标记

语法参考

Match.end() 方法用于获取分组匹配字符串对应的结束标记。语法格式如下：

Match.end([group])

参数说明：

• group ：表示分组名或者分组名对应的编号。

• 返回值：返回分组匹配字符串对应的结束标记。

锦囊1 获取分组匹配字符串对应的开始、结束标记

使用 Match.start() 方法与 Match.end() 方法获取分组匹配字符串对应的开始、结束标记，代码如下：

import re                         									# 导入正则表达式re模块

pattern = re.compile(‘(?P<group_1>\w+) (?P<group_2>\w+)’,re.I)   	# 分组表达式
string = ‘MR_SHOP mr_shop’ 											# 要匹配的字符串
match=re.match(pattern,string) 										# 匹配结果Match对象
print(match.start(),match.end()) 									# 打印全部分组的匹配字符串对应的开始、结束标记
print(match.start(1),match.end(1))									# 打印编号1分组的匹配字符串对应的开始、结束标记
print(match.start(2),match.end(2))									# 打印编号2分组的匹配字符串对应的开始、结束标记

# 打印分组名的匹配字符串对应的开始、结束标记
print(match.start(‘group_1’),match.end(‘group_2’))

41. Match.expand()方法，对“\”进行转义替换并返回

语法参考

Match.expand() 方法用于实现把字符串中用反斜杠“\”表示的数字或组名替换为相应分组中的值的功能。语法格式如下：

Match.expand(template)

参数说明：

• template ：表示需要替换的字符串。

• 返回值：返回对“\”进行转义替换的结果。

锦囊1 在字符串中指定位置替换对应分组中的值

使用 Match.expand() 方法，在字符串中指定位置替换对应分组中的值，代码如下：

import re                                                             	# 导入正则表达式re模块

pattern = re.compile(‘(?P<group_1>\w+) (?P<group_2>\w+)‘,re.I)   		# 分组表达式
string = ‘MR_SHOP mr_shop‘                      						# 要匹配的字符串
match=re.match(pattern,string)                      					# 匹配结果Match对象
print(match[1])                                  						# 打印分组1内容
print(match[2                                   						# 打印分组2内容

# 第一种替换方式，\1、\2替换分组1和2的内容
print(match.expand(r‘first_ \1 \2‘))

# 第二种替换方式，\g<1>、\g<2>替换分组1和2的内容
print(match.expand(‘second_ \g<1> \g<2>‘))

# 第三种替换方式，\g<group_1>、\g<group_2>替换分组1和2的内容
print(match.expand(‘third_ \g<group_1> \g<group_2>‘))

42. Match.groups()方法，以元组形式返回所有子组中内容

语法参考

Match.groups() 方法用于获取以元组形式返回所有子组中内容。语法格式如下：

Match.groups(default=None)

参数说明：

• default ：用于不参与匹配的情况，默认为 None。

• 返回值：以元组形式返回所有子组中内容。

锦囊1 获取所有分组对应的内容

使用 Match.groups() 方法获取所有分组对应的内容，代码如下：

import re                                                             	# 导入正则表达式re模块

pattern = re.compile(‘(?P<group_1>\w+) (?P<group_2>\w+)’,re.I) 			# 分组表达式
string = ‘MR_SHOP mr_shop’                                   			# 要匹配的字符串
match=re.match(pattern,string)                      					# 匹配结果Match对象
print(match.groups())                             						# 打印所有分组对应的内容

43. Match.group()方法，返回一个或者多个匹配的子组

语法参考

Match.group() 方法用于获取 Match 对象中一个或多个匹配的子组。如果只有一个（0~99）参数，结果就是一个字符串；如果有多个参数，结果就是一个元组（每个参数对应一个项）；如果没有参数，组 1 默认到 0（整个匹配都被返回）。如果一个组 N 参数值为 0，相应的返回值就是整个匹配字符串；如果一个组号是负数或超出组的最大长度，则给出越界错误；如果正则表达式中的一个组匹配了多个值，则相应的组只保存最后匹配的值。语法格式如下：

Match.group([group1, ...])

参数说明：

• group1 ：表示分组对应的编号或分组名称。

• 返回值：返回一个或者多个匹配的子组。

锦囊 获取指定分组对应的信息

使用 Match.group() 方法获取指定分组对应的信息，代码如下：

import re                                                       	# 导入正则表达式re模块

pattern = re.compile(‘(?P<group_1>\w+) (?P<group_2>\w+)’,re.I) 		# 分组表达式
string = ‘MR_SHOP mr_shop’                              			# 要匹配的字符串
match=re.match(pattern,string)                             			# 匹配结果Match对象

print(match.group())                                       			# 无参数打印全部内容
print(match.group(1))                                     			# 打印指定分组编号对应内容
print(match.group(‘group_2’))                           			# 打印指定分组名对应内容

44. Match.groupdict()方法，返回包含所有匹配值分组的字典

语法参考

Match.groupdict()方法用于获取以字典形式返回包含所有匹配值分组的信息，其中key就是组名，value 就是分组匹配的信息内容。语法格式如下：

Match.groupdict(default=None)

参数说明：

• default ：用于不参与匹配的情况，默认为 None。

• 返回值：以字典形式返回包含所有匹配值分组的信息。

锦囊1 获取字典形式的分组信息

使用 Match.groupdict() 方法获取字典形式的分组信息，代码如下：

import re                                                       	# 导入正则表达式re模块

pattern = re.compile(‘(?P<group_1>\w+) (?P<group_2>\w+)’,re.I)		# 分组表达式
string = ‘MR_SHOP mr_shop’                              			# 要匹配的字符串
match=re.match(pattern,string)                           			# 匹配结果Match对象
print(match.groupdict())                                   			# 打印字典形式的分组信息

45. Match.span()方法，返回包含开始和结束位置的二元组

语法参考

Match.span() 方法用于获取指定分组匹配字符串的开始和结束位置。语法格式如下：

Match.span([group])

参数说明：

• group ：表示分组名或者分组名对应的编号。

• 返回值：返回一个包含开始和结束位置的二元组。

锦囊1 获取指定分组匹配字符串的开始和结束位置

使用 Match.span() 方法获取指定分组匹配字符串的开始和结束位置，代码如下：

import re                         									# 导入正则表达式re模块

pattern = re.compile(‘(?P<group_1>\w+) (?P<group_2>\w+)’,re.I)		# 分组表达式
string = ‘MR_SHOP mr_shop’ 											# 要匹配的字符串
match=re.match(pattern,string)										# 匹配结果Match对象
print(match.span(1))           										# 打印分组编号1匹配字符串对应的开始、结束标记
print(match.span(‘group_2’)) 										# 打印分组名group_2匹配字符串对应的开始、结束标记

46. Match.start()方法，返回分组匹配字符串对应的开始标记

语法参考

Match.start() 方法用于获取分组匹配字符串对应的开始标记。语法格式如下：

Match.start([group])

参数说明：

• group ：表示分组名或者分组名对应的编号。

• 返回值：返回分组匹配字符串对应的开始标记。

锦囊1 获取分组匹配字符串对应的开始、结束标记

使用 Match.start() 方法与 Match.end() 方法获取分组匹配字符串对应的开始、结束标记，代码如下：

import re                           								# 导入正则表达式re模块

pattern = re.compile(‘(?P<group_1>\w+) (?P<group_2>\w+)’,re.I)		# 分组表达式
string = ‘MR_SHOP mr_shop’ 											# 要匹配的字符串
match=re.match(pattern,string) 										# 匹配结果Match对象
print(match.start(),match.end())									# 打印全部分组的匹配字符串对应的开始、结束标记
print(match.start(1),match.end(1))									# 打印编号1分组的匹配字符串对应的开始、结束标记
print(match.start(2),match.end(2))									# 打印编号2分组的匹配字符串对应的开始、结束标记

# 打印分组名的匹配字符串对应的开始、结束标记
print(match.start(‘group_1’),match.end(‘group_2’))