Python-正则re模块

Python正则表达式

Python使用re模块提供了正则表达式处理的能力。 

常量

常量　　　　　　　　　　　　说明

re.M　　　　　　　　　　　　多行模式

re.MULTILINE

re.S　　　　　　　　　　　　单行模式

re.DOTALL

re.I　　　　　　　　　　　　忽略大小写

re.IGNORECASE

re.X　　　　　　　　　　　  忽略表达式中的空白字符

re.RERBOSE

 

使用 | 位或运算开启多种选项

方法

编译

re.compile(pattern,flags=0):设定flags，编译模式，返回正则表达对象的regex。

pattern就是正则表达式字符串，flags是选项，正则表达式需要被编译，为了提高效率，这些编译后的结果被保存，下次使用同样的pattern的时候，就不需要再次编译。 

 

re的其他方法为了提高效率都调用了编译方法，就是为了提速。  

 

单次匹配

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

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

match匹配从字符串的开头匹配，regex对象match方法可以重设定开始位置和结束位置，返回match对象。  

 

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

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

从头搜索直到第一个匹配，regex对象search方法可以重设定开始位置和结束位置，返回match对象

 

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

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

整个字符串和正则表达式匹配

import re

s = '''bottle\nbag\nbig\napple'''
print(s)

for i,c in enumerate(s,1):
    print((i-1,c),end='\n' if i % 10  ==0 else ' ')
print()

#match方法
print('---match---')
result = re.match('bottle',s)
print(type(result))
print(1,result)
result = re.match('a',s)
print(2,result)
result = re.match('^a',s,re.M)
print(3,result)
result = re.match('^a',s,re.S)
print(4,result)

#先编译然后使用正则表达式对象
regex = re.compile('a')
result = regex.match(s)
print(5,result)

result = regex.match(s,15)
print(6,result)
print('-' * 30)

#search方法

print('---search---')
result = re.search('a',s)
print(7,result)

regex = re.compile('b')
result = regex.search(s)
print(8.1,result)

result = regex.search(s,1)
print(8.2,result)

regex = re.compile('^b',re.M)
result = regex.search(s)
print(8.3,result)
result = regex.search(s,8)
print(9,result)

#fullmatch方法
result = re.fullmatch('bag',s)
print(10,result)

regex = re.compile('bag')
result = regex.fullmatch(s)
print(11,result)
result = regex.fullmatch(s,7)
print(12,result)

result = regex.fullmatch(s,7,10)
print(13,result)


#输出
bottle
bag
big
apple
(0, 'b') (1, 'o') (2, 't') (3, 't') (4, 'l') (5, 'e') (6, '\n') (7, 'b') (8, 'a') (9, 'g')
(10, '\n') (11, 'b') (12, 'i') (13, 'g') (14, '\n') (15, 'a') (16, 'p') (17, 'p') (18, 'l') (19, 'e')

---match---
<class '_sre.SRE_Match'>
1 <_sre.SRE_Match object; span=(0, 6), match='bottle'>
2 None
3 None
4 None
5 None
6 <_sre.SRE_Match object; span=(15, 16), match='a'>
------------------------------
---search---
7 <_sre.SRE_Match object; span=(8, 9), match='a'>
8.1 <_sre.SRE_Match object; span=(0, 1), match='b'>
8.2 <_sre.SRE_Match object; span=(7, 8), match='b'>
8.3 <_sre.SRE_Match object; span=(0, 1), match='b'>
9 <_sre.SRE_Match object; span=(11, 12), match='b'>
10 None
11 None
12 None
13 <_sre.SRE_Match object; span=(7, 10), match='bag'>

 

全文搜索

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

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

对整个字符串，从左到右匹配，返回所有项的列表  

 

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

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

 对整个字符串，从左到右匹配，返回所有匹配项，返回迭代器

注意每次返回的是match对象

import re

s = '''bottle\nbag\nbig\nable'''
print(s)

for i,c in enumerate(s,1):
    print((i-1,c),end='\n' if i % 10  ==0 else ' ')
print()

#findall方法
result = re.findall('b',s)
print(1,result)

regex = re.compile('^b')
result = regex.findall(s)
print(2,result)

regex = re.compile('^b',re.M)
result = regex.findall(s,7)
print(3,result)

regex = re.compile('^b',re.S)
result = regex.findall(s)
print(4,result)

regex = re.compile('^b',re.M)
result = regex.findall(s,7,10)
print(5,result)


#输出
bottle
bag
big
able
(0, 'b') (1, 'o') (2, 't') (3, 't') (4, 'l') (5, 'e') (6, '\n') (7, 'b') (8, 'a') (9, 'g')
(10, '\n') (11, 'b') (12, 'i') (13, 'g') (14, '\n') (15, 'a') (16, 'b') (17, 'l') (18, 'e') 
1 ['b', 'b', 'b', 'b']
2 ['b']
3 ['b', 'b']
4 ['b']
5 ['b']

#finditer方法
regex = re.compile('^b',re.M)
result= regex.finditer(s)
print(type(result))
r = next(result)

print(type(r),r) #match对象
print(r.start(),r.end(),s[r.start():r.end()])

 

匹配替换

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

regex.sub(replacement,string,count=0)

使用pattern对字符串，string进行匹配，对匹配项使用replace替换。

replacement可以是string、bytes、function  

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

regex.subn(replacement,string,count=0)

同sub返回一个元组(new_string,number_of_subs_made)

 

import re

s = '''bottle\nbag\nbig\nable'''
print(s)

for i,c in enumerate(s,1):
    print((i-1,c),end='\n' if i % 10  ==0 else ' ')
print()

#替换方法
regex = re.compile('b\wg')
result = regex.sub('Python',s)
print(1,result)
print('-' * 30)

result = regex.sub('Python',s,1)
print(1,result)
print('-' * 30)

regex = re.compile('\s+')
result = regex.subn('\t',s) #返回替换后的字符串和替换了几次次数
print(3,result)


#输出
bottle
bag
big
able
(0, 'b') (1, 'o') (2, 't') (3, 't') (4, 'l') (5, 'e') (6, '\n') (7, 'b') (8, 'a') (9, 'g')
(10, '\n') (11, 'b') (12, 'i') (13, 'g') (14, '\n') (15, 'a') (16, 'b') (17, 'l') (18, 'e') 
1 bottle
Python
Python
able
------------------------------
1 bottle
Python
big
able
------------------------------
3 ('bottle\tbag\tbig\table', 3)

 

分组

使用小括号的pattern捕获的数据被放到了group组中 

match、search函数可以放回match对象，；findall返回字符串列表，finditer返回一个个match对象，迭代器。

如果pattern中使用了分组，如果匹配的结果会在match对象中：

1、使用group(N)方式返回对应的分组，1到N是对应的分组，0返回整个匹配的字符串，N不写缺省为0 

2、如果使用了命令分组，可使用group('name')的方式取分组

3、也可以使用groups()返回所有组

4、使用groupdict()返回所有命名分组

import re

s = '''bottle\nbag\nbig'''
print(s)

for i,c in enumerate(s,1):
    print((i-1,c),end='\n' if i % 10  ==0 else ' ')
print()

#分组
regex = re.compile('b\w+')
result = regex.match(s) #从头匹配一次
print(type(result))
print(1,'match',result.groups())


result = regex.search(s,1)
print(2,'match',result.groups())

#命名分组
regex = re.compile('(b\w+)\n(?P<name2>b\w+)\n(?P<name3>b\w+)')
result = regex.match(s)
print(3,'match',result)
print(4,result.group(1),result.group(2),result.group(3))
print(5,result.group(0).encode()) #返回整个匹配字符串
print(6,result.groups())
print(7,result.groupdict())

result = regex.findall(s)
for x in result:
    print(x)

regex = re.compile('(?P<head>b\w+)')
result = regex.finditer(s)
for x in result:
    print(x)

#输出
bottle
bag
big
(0, 'b') (1, 'o') (2, 't') (3, 't') (4, 'l') (5, 'e') (6, '\n') (7, 'b') (8, 'a') (9, 'g')
(10, '\n') (11, 'b') (12, 'i') (13, 'g') 
<class '_sre.SRE_Match'>
1 match ()
2 match ()
3 match <_sre.SRE_Match object; span=(0, 14), match='bottle\nbag\nbig'>
4 bottle bag big
5 b'bottle\nbag\nbig'
6 ('bottle', 'bag', 'big')
7 {'name2': 'bag', 'name3': 'big'}
('bottle', 'bag', 'big')
<_sre.SRE_Match object; span=(0, 6), match='bottle'>
<_sre.SRE_Match object; span=(7, 10), match='bag'>
<_sre.SRE_Match object; span=(11, 14), match='big'>

 如果有分组，findall返回的是分组的内容，而不是match匹配的字符串。 

有没有分组，都可以使用match对象的group(0),它总是为匹配的字符串。

 

分隔字符串

字符串的分隔函数split，不能指定多个字符进行分割。

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

re.split分割字符串

import re

s = """\
os.path.abspath(path)
normalpath(join(os.getcwd(),path)).
"""


print(s.split())  #无法把每行的单词提取出来，不指定切割符，则使用\n进行切['os.path.abspath(path)', 'normalpath(join(os.getcwd(),path)).']

print(re.split('[\.()\s]+',s))

#输出
['os.path.abspath(path)', 'normalpath(join(os.getcwd(),path)).']
['os', 'path', 'abspath', 'path', 'normalpath', 'join', 'os', 'getcwd', ',path', '']