Python re模块与正则表达式的运用

re模块

永远不要起一个py文件的名字,这个名字和你已知的模块同名

查找

findall():     匹配所有   每一项都是列表中的一个元素

语法 :   findall(正则判断条件,要判断字符串)

返回值:  是一个列表

1 import re
2 ret = re.findall("\d+","dadqbwhebq26548dadwd151")  #
3 print(ret)
4 ret1 = re.findall("\d","dadqbwhebq26548dadwd151")
5 print(ret1)
6 
7 结果
8 ['26548', '151']
9 ['2', '6', '5', '4', '8', '1', '5', '1']

search():    只匹配从左到右的第一个,得到的不是直接的结果,而是一个变量,通过变量的group方法来获取结果

如果没有匹配到,会返回None,使用group会报错

语法:    search(正则表达式,待匹配字符)

返回值:  返回的是一个内存地址

 1 import re
 2 ret = re.search("\d+","dadqbwhebq26548dadwd151")
 3 print(ret)  # 打印的是内存地址
 4 print(ret.group())  #  用group获取真正的结果
 5 
 6 
 7 # 结果
 8 <_sre.SRE_Match object; span=(10, 15), match='26548'>
 9 26548
10 
11 # 因为查不到的时候用group会报错
12 # 一般都会这样写
13 ret = re.search("\d+","dadqbwhebqdadwd")
14 print(ret)  # 查不到返回None
15 if ret :  #  如果查不到就不会被执行
16     print(ret.group())
17 
18 # 结果
19 None

match()  从头开始匹配,相当于search 中的正则表达式加上一个  ^

语法 : match(正则表达式,待匹配字符)

返回值 :  是一个内存地址

 1 import re
 2 ret = re.match("\d+","1321dajdd1615")
 3 print(ret)  #返回值是一个内存地址
 4 print(ret.group())
 5 
 6 
 7 结果
 8 <_sre.SRE_Match object; span=(0, 4), match='1321'>
 9 1321
10 
11 
12 
13 
14 ret1 = re.match("\d+","dajdd1615")
15 print(ret1)
16 if ret1:
17     print(ret1.group())
18 
19 结果
20 None

字符串的处理     切割  替换

split()    切割     与字符串一样的切割

1 import re
2 s = "dadwd1adwjkd54dwqd12315da0"
3 ret = re.split("\d+",s)
4 print(ret)
5 
6 结果
7 ['dadwd', 'adwjkd', 'dwqd', 'da', '']

sub   替换    和  replice()   一样

语法:   sub(正则判断,旧的,新的,次数)

 1 import re
 2 ret = re.sub("\d+","SB","dabbwqibd15dawn155dwjdn")
 3 print(ret)
 4 
 5 结果
 6 dabbwqibdSBdawnSBdwjdn
 7 
 8 ret = re.sub("\d+","SB","dabbwqibd15dawn155dwjdn",1)
 9 print(ret)
10 
11 结果
12 dabbwqibdSBdawn155dwjdn

subn()    替换   可以显示出替换了几次

语法:   subn(正则判断,旧的,新的)

返回值:  是一个元组,  第一项是结果 , 第二项是次数

import re
ret = re.subn("\d+","SB","dabbwqibd15dawn155dwjdn")
print(ret)

结果
('dabbwqibdSBdawnSBdwjdn', 2)

re模块的进阶   空间 / 时间

compile()      节省你使用正则表达式解决问题的时间

用途:  编译  ,    正则表达式  编译成字节码     再多次使用的过程中    不会被多次编译

 语法:   complic(正则表达式)

返回值 :   编译后的正则表达式的内存地址

ret = re.compile("\d+")
print(ret)
res = ret.findall("dwbahbfaj255dwafafdw12dwa")
print(res)
res1 = ret.search("dwbahbfaj255dwafafdw12dwa")
print(res1.group())
res2 = ret.split("dwbahbfaj255dwafafdw12dwa")
print(res2)
res3 = ret.finditer("dwbahbfaj255dwafafdw12dwa")
for i in res3:
    print(i.group())


结果
re.compile('\\d+')
['255', '12']
255
['dwbahbfaj', 'dwafafdw', 'dwa']
255
12

编译后的结果都可以与re模块中的函数使用

finditer()  节省你使用正则表达式解决问题的空间/内存

语法:  finditer(正则表达式,待匹配字符)

返回值:   返回一个可迭代对象的一个内存地址

ret = re.finditer("\d+","dwbahbfaj255dwafafdw12dwa")
for i in ret:
    print(i.group())

结果
255
12

分组在re模块中的使用

 1 s = '<a>wahaha</a>'  # 标签语言 html 网页
 2 ret = re.search(">(\w*)<",s)
 3 print(ret.group(1))
 4 ret = re.findall(">(\w*)<",s)  # 优先级
 5 print(ret)
 6 s1 = "515.64123165"
 7 ret2 = re.findall("\d+(?:.\d+)?",s1)  # 取消优先级
 8 print(ret2)
 9 
10 ret1 = re.search("<(\w+)>(\w+)</(\w+)>",s)  #可以根据分组的位置标号提取
11 print(ret1.group())
12 print(ret1.group(1))
13 print(ret1.group(2))
14 print(ret1.group(3))
15 
16 ret1 = re.search("<(?P<con>\w+)>(?P<con1>\w+)</(?P<con2>\w+)>",s)  # 可以根据分组的名字提取
17 print(ret1.group())
18 print(ret1.group('con'))
19 print(ret1.group('con1'))
20 print(ret1.group('con2'))