文章目录
search函数
search在一个字符串中搜索满足文本模式的字符串。语法格式如下：
re.search(pattern, string, flags=0)
函数参数与match意义相同
| 参数 | 描述 |
|---|---|
pattern | 匹配的正则表达式 |
string | 要匹配的字符串。 |
flags | 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。如下表列出正则表达式修饰符 - 可选标志 |
示例
import re
m=re.search('abc','abcdefg')
print(m)
print(m.group())
## 输出结果
'''
<re.Match object; span=(0, 3), match='abc'>
abc
'''
match与search的区别re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。
match方法与search方法的使用对比
import re
#进行文本模式匹配，匹配失败，match方法返回None
m=re.match('love','I love you')
if m is not None:
print(m.group())
print('match运行结果：',m)
#进行文本模式搜索，
m=re.search('love','I love you')
if m is not None:
print(m.group())
print('search的运行结果：',m)
'''运行结果
love
search的运行结果： <re.Match object; span=(2, 6), match='love'>
'''
| 选择其一进行匹配
search方法搜索一个字符串，要想搜索多个字符串，如搜索aa、bb和cc，最简单的方法是在文本模式字符串中使用择一匹配符号（|)。择一匹配符号和逻辑或类似，只要满足任何一个，就算匹配成功。
import re
s='aa|bb|cc'
#match进行匹配
m=re.match(s,'aa') #aa满足要求，匹配成功
print(m.group())
m=re.match(s,'bb') #bb满足要求，匹配成功
print(m.group())
#search查找
m=re.search(s,'Where is cc')
print(m.group())
如果待匹配的字符串中，某些字符可以有多个选择，就需要使用字符集（[]），也就是一对中括号括起来的字符串。例如，[xyz]表示x、y、z三个字符可以取其中任何一个，相当于“x|y|z”，所以对单个字符使用或关系时，字符集和择一匹配符的效果是一样的。示例如下：
import re
m=re.match('[xyz]','x') #匹配成功
print(m.group())
m=re.match('x|y|z','x') #匹配成功
print(m.group())
字符集（[]）和择一匹配符(|)的用法，及它们的差异
import re
#匹配以第1个字母是a或者b，第2个字母是c或者d，如ac、bc、ad、bd
m=re.match('[ab][cd]','aceg')
print(m)
#匹配以ab开头，第3个字母是c或者d，如abc、abd
m=re.match('ab[cd]','abcd')
print(m)
#匹配ab或者cd
m=re.match('ab|cd','cd')
print(m)
'''输出结果
<re.Match object; span=(0, 2), match='ac'>
<re.Match object; span=(0, 3), match='abc'>
<re.Match object; span=(0, 2), match='cd'>
'''
分组
| 字符 | 功能 |
|---|---|
(ab) | 将括号中的字符作为一个分组 |
\num | 引用分组num匹配到的字符串 |
(?p<name>) | 分别起组名 |
(?p=name) | 引用别名为name分组匹配到的字符串 |
如果一个模式字符串中有用一对圆括号括起来的部分，那么这部分就会作为一组，可以通过group方法的参数获取指定的组匹配的字符串。当然，如果模式字符串中没有任何用圆括号括起来的部分，那么就不会对待匹配的字符串进行分组。
【示例】匹配座机号码
pattern = r'(\d+)-(\d{5,8}$)'
v = re.match(pattern,'010-66668888')
print(v)
print(v.group())
print(v.group(1))
print(v.group(2))
print(v.groups())
print(v.groups()[0])
print(v.groups()[1])
'''输出结果
<re.Match object; span=(0, 12), match='010-66668888'>
010-66668888
010
66668888
('010', '66668888')
010
66668888
'''
【示例】\num 的使用
import re
#匹配合法的网页标签
s = '<html><title>我是标题</title></html>'
#匹配不合法的网页标签
ss = '<html><title>我是标题</html></title>'
#优化前
pattern = r'<.+><.+>.+</.+></.+>'
print(re.match(pattern,s))
print(re.match(pattern,ss))
#优化后 可以使用分组 \2 表示引用第2个分组 \1表示引用第1个分组
pattern = r'<(.+)><(.+)>.+</\2></\1>'
print(re.match(pattern,s))
print(re.match(pattern,ss))
'''输出结果
<re.Match object; span=(0, 32), match='<html><title>我是标题</title></html>'>
<re.Match object; span=(0, 32), match='<html><title>我是标题</html></title>'>
<re.Match object; span=(0, 32), match='<html><title>我是标题</title></html>'>
None
'''
使用分组要了解如下几点：
1 只有圆括号括起来的部分才算一组，如果模式字符串中既有圆括号括起来的部分，也有没有被圆括号括起来的部分，那么只会将被圆括号 括起来的部分算作一组，其它的部分忽略。
2 用group方法获取指定组的值时，组从1开始，也就是说，group(1)获取第1组的值，group(2)获取第2组的值，以此类推。
3 groups方法用于获取所有组的值，以元组形式返回。所以除了使用group(1)获取第1组的值外，还可以使用groups()[0]获取第1组的值。获取第2组以及其它组的值的方式类似。
re模块中的其他常用函数
sub和subn函数
sub函数和subn函数用于实现搜索和替换功能。这两个函数的功能几乎完全相同，都是将某个字符串中所有匹配正则表达式的部分替
换成其他字符串。用来替换的部分可能是一个字符串，也可以是一个函数，该函数返回一个用来替换的字符串。sub函数返回替换后
的结果，subn函数返回一个元组，元组的第1个元素是替换后的结果，第2个元素是替换的总数。语法格式如下：
re.sub(pattern, repl, string, count=0,flags=0)
| 参数 | 描述 |
|---|---|
pattern | 匹配的正则表达式 |
repl | 替换的字符串，也可为一个函数 |
string | 要被查找替换的原始字符串。 |
count | 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配 |
【示例】sub和subn方法的使用
import re
phone = "2004-959-559 # 这是一个国外电话号码"
# 删除字符串中的 Python注释
num = re.sub(r'#.*$', "", phone)
print("电话号码是: ", num)
# 删除非数字(-)的字符串
num = re.sub(r'\D', "", phone)
print("电话号码是 : ", num)
#subn函数的使用
result=re.subn(r'\D', "", phone)
print(result)
print('替换的结果：',result[0])
print('替换的次数：',result[1])
'''输出结果
电话号码是: 2004-959-559
电话号码是 : 2004959559
('2004959559', 15)
替换的结果： 2004959559
替换的次数： 15
'''
compile 函数
compile 函数用于编译正则表达式，生成一个正则表达式（Pattern ）对象，供 match() 和 search() 这两个函数使用。语法格式为:
re.compile(pattern[, flags])
| 参数 | 描述 |
|---|---|
pattern | 一个字符串形式的正则表达式 |
flags | 可选，表示匹配模式，比如忽略大小写，多行模式等 |
import re
s='first123 line'
regex=re.compile(r'\w+') #匹配至少一个字母或数字
print(regex)
m=regex.match(s)
print(m.group())
# s 的开头是 "f", 但正则中限制了开始为 i 所以匹配失败
regex = re.compile("^i\w+")
print(regex.match(s))
'''输出结果
re.compile('\\w+')
first123
None
'''
findall 函数
在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表。语法格式如下：
findall(pattern, string, flags=0)
import re
pattern=r'\w+' #匹配至少一个字母或数字
s='first 1 second 2 third 3'
o=re.findall(pattern,s)
print(o)
'''输出结果
['first', '1', 'second', '2', 'third', '3']
'''
finditer函数
和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。
import re
pattern=r'\w+'
s='first 1 second 2 third 3'
o=re.finditer(pattern,s)
print(o)
for i in o:
print(i.group())
'''输出结果
<callable_iterator object at 0x000001959C06DB70>
first
1
second
2
third
3
'''
split函数
split函数用于根据正则表达式分隔字符串，也就是说，将字符串与模式匹配的子字符串都作为分隔符来分隔这个字符串。split函数返回一个列表形式的分隔结果，每一个列表元素都是分隔的子字符串。语法格式如下：
re.split(pattern, string[, maxsplit=0,flags=0])
import re
s='first 11 second 22 third 33'
#按数字切分
print(re.split(r'\d+',s))
# maxsplit 参数限定分隔的次数，这里限定为1，也就是只分隔一次
print(re.split(r'\d+',s,1))
'''输出结果
['first ', ' second ', ' third ', '']
['first ', ' second 22 third 33']
'''
贪婪模式和非贪婪模式
贪婪模式指Python里数量词默认是贪婪的，总是尝试匹配尽可能多的字符。非贪婪模式与贪婪相反，总是尝试匹配尽可能少的字符，可以使用"*“，”?“，”+“，”{m,n}"后面加上？，使贪婪变成非贪婪。
import re
v = re.match(r'(.+)(\d+-\d+-\d+)','This is my tel:133-1234-1234')
print('----------贪婪模式---------')
print(v.group(1))
print(v.group(2))
print('----------非贪婪模式---------')
v = re.match(r'(.+?)(\d+-\d+-\d+)','This is my tel:133-1234-1234')
print(v.group(1))
print(v.group(2))
'''输出结果
----------贪婪模式---------
This is my tel:13
3-1234-1234
----------非贪婪模式---------
This is my tel:
133-1234-1234
'''
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
