python：正则表达式_re模块
Python 正则表达式
简介
1、正则表达式是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配。从而达到快速检索或替换符合某个模式、规则的文本。
2、Python自1.5版本起增加了re 模块，re模块使Python语言拥有全部的正则表达式功能。
3、这种匹配是根据一个字符一个字符来匹配的
re模块
re.search( )方法
作用：
1、re.search( )方法用于扫描整个字符串并返回第一个成功的匹配的字符
2、如果匹配成功，re.search( )就返回一个匹配的对象，否则返回None
函数语法：
re.search(pattern, string, flags=0)
参数说明：
pattern：匹配的正则表达式
string：要匹配的字符串。
flags：标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。(参数flags用于编译pattern时指定匹配模式)
返回值：
匹配成功re.search方法返回一个匹配的对象，否则返回None。例1：
import re
string = "In me The tiger sniffs the rose"
expression = r" the" #r表示后面为正则表达式
result = re.search(expression,string,re.I)
result_1 = re.search(expression,string)
print("区分大小写时的匹配:",result)
print("不区分大小写时的匹配:",result_1)
"""
区分大小写时的匹配: <_sre.SRE_Match object; span=(5, 9), match=' The'>
不区分大小写时的匹配: <_sre.SRE_Match object; span=(22, 26), match=' the'>
"""备注：
1、search( )方法返回的是一个匹配对象(_sre.SRE_Match object)，返回结果中span表示匹配到的字符串所在的位置，使用的是索引(从0开始，包左不包右)，match表示匹配到的字符串
2、第一个参数是正则表达式模式，也就是你要描述的搜索规则，可以使用原始字符串来写，因为这样可以避免很多不必要的麻烦(也可以使用具体的正则表达式，如pattern = r" (\w+) (\w+)")
search对象的方法
作用：返回由search()方法返回的对象的中词组(search()方法返回的是一个对象，但是没有返回具体匹配到的字符串，因此需要使用这些方法来获得具体匹配的字符串)
| 匹配对象方法 | 描述 |
| end([group=0]) | 返回指定分组的结束位置，默认返回正则表达式所匹配到的最后一个字符的索引 |
| expand(template) | 根据模版返回相应的字符串，类似与 sub 函数里面的 repl， 可使用 \1 或者 \g |
| group([group1, ...]) | 根据提供的索引或名字返回响应分组的内容，默认返回 start() 到 end() 之间的字符串， 提供多个参数将返回一个元组 |
| groupdict([default=None]) | 返回 返回一个包含所有匹配到的命名分组的字典，没有命名的分组不包含在内，key 为组名， value 为匹配到的内容，参数 default 为没有参与本次匹配的命名分组提供默认值 |
| groups([default=None]) | 以元组形式返回每一个分组匹配到的字符串，包括没有参与匹配的分组，其值为 default |
| span([group]) | 返回指定分组的起止位置组成的元组，默认返回由 start() 和 end() 组成的元组 |
| start([group]) | 返回指定分组的开始位置，默认返回正则表达式所匹配到的第一个字符的索引 |
例1_1:
import re
string = "In me The tiger sniffs the rose"
pattern = r" (?P\w+) (\w+) tiger"
result = re.search(pattern,string)
print("不区分大小写时的匹配:",result)
# 根据提供的索引或名字返回响应分组的内容，默认返回start()到end()之间的字符串，提供多个参数将返回一个元组
#若提供的索引超出了元组实际的长度，则会报错
print(result.group(1),type(result.group(1,2)))
print(result.group(2),type(result.group(2)))
#以元组形式返回每一个分组匹配到的字符串，包括没有参与匹配的分组，其值为default
print(result.groups(),type(result.groups()))
# 返回指定分组的结束位置，默认返回正则表达式所匹配到的最后一个字符的索引
print(result.end())
# 返回指定分组的起止未知组成的元组，默认返回由start()和end()组成的元组
print(result.span())
# 返回 返回一个包含所有匹配到的命名分组的字典，没有命名的分组不包含在内，key为组名，value为匹配到的内容，参数default为没有参与本次匹配的命名分组提供默认值
print(result.groupdict('default_string'))
"""
不区分大小写时的匹配: <_sre.SRE_Match object; span=(2, 15), match=' me The tiger'>
me
The
('me', 'The')
15
(2, 15)
{'name': 'me'}
""" 备注：
1、(…) 用来匹配符合条件的字符串。并且将此部分，打包放在一起，看做成一个组：group
2、组是通过 "(" 和 ")" 元字符来标识的，如果不引起括号的话，匹配出来的字符串就是一个组(索引只能是0)，引入括号后可以将匹配到的字符串分组
例1_2：
import re
s = '1102231990xxxxxxxx'
res = re.search('(?P\d{3})(?P\d{3})(?P\d{4})',s)
print(res.groupdict())
#{'province': '110', 'city': '223', 'born_year': '1990'}
re.match()函数
1、一般使用re模块的步骤是先将正则表达式的字符串形式编译为Pattern实例，然后使用Pattern实例处理文本并获得匹配结果(一个match()函数)，最后使用match()函数获得信息，进行其他操作
2、re.match()函数尝试从字符串的起始位置匹配一个模式，如果在起始位置匹配成功的话，就返回匹配结果对象；如果不是起始位置匹配成功的话，match()就返回none。
函数语法：
re.match(pattern, string, flags=0)
参数说明：
pattern：匹配的正则表达式
string：要匹配的字符串。
flags：标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。例2：
import re
print(re.match('www', 'www.baidu.com')) # 在起始位置匹配
print(re.match('com', 'www.baidu.com')) # 不在起始位置匹配
"""
<_sre.SRE_Match object; span=(0, 3), match='www'>
None
"""
re.match()与re.search()的区别
1、re.match只匹配字符串的开始，如果字符串开始的字符不符合正则表达式，则匹配失败，函数返回None
2、re.search匹配整个字符串，直到找到一个匹配的对象，匹配结束也没找到匹配值才返回None
例3：
import re
line = "Cats are smarter than dogs"
matchObj = re.match(r'dogs', line, re.M | re.I)
if matchObj:
print("match --> matchObj.group() : ", matchObj.group())
else:
print("No match!!")
matchObj = re.search(r'dogs', line, re.M | re.I)
if matchObj:
print("search --> matchObj.group() : ", matchObj.group())
else:
print("No match!!")
"""
No match!!
search --> matchObj.group() : dogs
"""
编译正则表达式
语法如下：
re.compile(strPattern[, flag])
参数：
strPattern：需要编译的正则表达式
flag：匹配模式1、这个方法是Pattern类的工厂方法，用于将字符串形式的正则表达式编译为Pattern对象。 第二个参数flag是匹配模式，取值可以使用按位或运算符'|'表示同时生效，比如re.I | re.M。另外，你也可以在regex字符串中指定模式，比如re.compile('pattern', re.I | re.M)与re.compile('(?im)pattern')是等价的。
2、如果需要重复使用某个正则表达式，那么可以先将该正则表达式编译成模式对象。使用re.compile()方法来进行编译
3、re提供了众多模块方法用于完成正则表达式的功能。这些方法可以使用Pattern实例的相应方法替代，唯一的好处是少写一行re.compile()代码，但同时也无法复用编译后的Pattern对象。
4、re模块还提供了一个方法escape(string)，用于将string中的正则表达式元字符如*/+/?等之前加上转义符再返回，在需要大量匹配元字符时有那么一点用。
例4：
import re
string = "In Me The Tiger Sniffs The Rose"
string_1 ="hello,world"
pattern = re.compile(r"[a-z]")
word = re.search(pattern,string)
word_1 = re.search(pattern,string_1)
print(word)
print(word_1)
#如果不编译的话，就需要每次都在search()方法中加上正则表达式
"""
<_sre.SRE_Match object; span=(1, 2), match='n'>
<_sre.SRE_Match object; span=(0, 1), match='h'>
"""
编译标志
通过编译标志，可以修改正则表达式的工作方式，可以使用的编译标志如下：
| re.A(ASCII) | 使得转义符号如\w,\b,\s和\d只能匹配ASCII字符而不匹配完整的Unicode字符(括号内是完整写法，下同） re.I(re.IGNORECASE): 匹配时忽略大小写 |
| re.M(MULTILINE) | 多行模式，改变'^'和'$'的行为 |
| re.S(DOTALL) | 点任意匹配模式，包括换行符，改变'.'的行为 |
| re.L(LOCALE) | 使预定字符类 \w \W \b \B \s \S 取决于当前区域设定 |
| re.U(UNICODE) | 使预定字符类 \w \W \b \B \s \S \d \D 取决于unicode定义的字符属性 |
| re.X(VERBOSE) | 详细模式。这个模式下正则表达式可以是多行，忽略空白字符，并可以加入注释。 |
以下两个正则表达式是等价的：
a = re.compile(r"""\d + # the integral part
\. # the decimal point
\d * # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")例5：
import re
string = "In me The tiger sniffs the rose"
pattern = re.compile(r" the",re.I) #将字符串形式的正则表达式编译为Pattern对象
result_1 = re.search(pattern,string)
print("不区分大小写时的匹配:",result_1)
#不区分大小写时的匹配: <_sre.SRE_Match object; span=(5, 9), match=' The'>如以上例子可以简写为：
例5_1：
import re
string = "In me The tiger sniffs the rose"
pattern = r" the"
result_1 = re.search(pattern,string,re.I)
print("不区分大小写时的匹配:",result_1)
#不区分大小写时的匹配: <_sre.SRE_Match object; span=(5, 9), match=' The'>
#即就是上面说的：可以使用Pattern实例的相应方法替代，唯一的好处是少写一行re.compile()代码注：编译正则表达式时使用了编译标志(re.I等)，在search()等方法中就不能再次使用编译标志了
split( )方法
语法如下：
split(string[, maxsplit]) | re.split(pattern, string[, maxsplit])
参数
pattern 匹配的正则表达式
string 要匹配的字符串。
maxsplit 分隔次数，maxsplit=1 分隔一次，默认为 0，不限制次数。
flags 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见：正则表达式修饰符 - 可选标志
返回值：
按照能够匹配的子串将string分割后返回列表。maxsplit用于指定最大分割次数，不指定将全部分割。 例6：
import re
string = "one1two2three3four4"
pattern = re.compile(r"\d+")
word = re.split(pattern,string)
word_1 = re.split(pattern,string,2)
print(word)
print(word_1)
"""
['one', 'two', 'three', 'four', '']
['one', 'two', 'three3four4']
"""
findall( )方法
语法如下：
findall(string[, pos[, endpos]]) | re.findall(pattern, string[, flags])
参数：
string : 待匹配的字符串。
pos : 可选参数，指定字符串的起始位置，默认为 0。
endpos : 可选参数，指定字符串的结束位置，默认为字符串的长度。
作用：
搜索string，以列表形式返回全部能匹配的子串：返回一个由所有匹配结果组成的列表例7：
import re
string = "one1two2three3four4"
pattern = re.compile(r"\d+")
word = re.findall(pattern,string)
print(word)
print(type(word))
for n in word:
print(n)
"""
['1', '2', '3', '4']
1
2
3
4
""" finditer( )方法
语法如下：
finditer(string[, pos[, endpos]]) | re.finditer(pattern, string[, flags])
作用：
搜索string，返回一个顺序访问每一个匹配结果（Match对象）的迭代器。 例8：
import re
string = "one1two2three3four4"
pattern = re.compile(r"\d+")
word = re.finditer(pattern,string)
print(word)
print(type(word))
for n in word:
print(n.group())
print(n)
"""
1
2
3
4
<_sre.SRE_Match object; span=(18, 19), match='4'>
"""
拓展：
检索和替换
Python的re模块提供了re.sub用于替换字符串中的匹配项。
语法：
re.sub(pattern, repl, string, count=0, flags=0)
参数：
pattern : 正则中的模式字符串。
repl : 替换的字符串，也可为一个函数。
string : 要被查找替换的原始字符串。
count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。例9：
import re
phone = "2004-959-559 # 这是一个国外电话号码"
# 删除字符串中的 Python注释
word = print(re.findall(r'#.*$',phone))
num = re.sub(r'#.*$', "", phone)
print("电话号码是: ", num)
# 删除非数字(-)的字符串
num = re.sub(r'\D', "", phone)
word_2 = print(re.findall(r'\D',phone))
print("电话号码是 : ", num)
"""
['# 这是一个国外电话号码']
电话号码是: 2004-959-559
['-', '-', ' ', '#', ' ', '这', '是', '一', '个', '国', '外', '电', '话', '号', '码']
电话号码是 : 2004959559
"""