re模块

查找:  findall()   search()  match()

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

　　语法: findall(正则表达式, 待匹配的字符串, flag)

import re
ret = re.findall('\d+','sjkhk172按实际花费928') 
print(ret)
ret = re.findall('\d','sjkhk172按实际花费928') 
print(ret)
结果:
['172', '928']
['1', '7', '2', '9', '2', '8']

　　search:　　　　只匹配从左到右的第一个,得到的不是直接的结果,而是一个变量,通过这个变量的group方法获取结果. 如果没有匹配到,会返回None,使用group会报错.

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

ret = re.search('\d+','sjkhk172按实际花费928')
print(ret)  # 内存地址,这是一个正则匹配的结果
print(ret.group()) # 通过ret.group()获取真正的结果

结果:<re.Match object; span=(5, 8), match='172'>　　　　
#内存地址,span(5,8)表示匹配到的数据范围在第5位到第8位,match ='172'表示匹配到的数据为172
172

ret = re.search('\d','owghabDJLBNdgv')
print(ret)
# print(ret.group())

结果:None　　　　　　　　　　　　　　#没有匹配到,返回None
AttributeError: 'NoneType' object has no attribute 'group'#没有匹配到,使用group方法报错

ret = re.search('\d+','sjkhk172按实际花费928')
if ret :   # 内存地址,这是一个正则匹配的结果,先判断是否匹配到,再输出
    print(ret.group()) # 通过ret.group()获取真正的结果
结果:172

　　使用search对网页标签进行处理

import re
s = '<a>wahaha</a>'  # 标签语言 html 网页
ret = re.search('<(\w+)>(\w+)</(\w+)>',s)
print(ret.group())  # 所有的结果
print(ret.group(1)) # 数字参数代表的是取对应分组中的内容
print(ret.group(2))
print(ret.group(3))
结果:<a>wahaha</a>
a
wahaha
a

　　使用findall对网页标签进行处理

import re
s = '<a>wahaha</a>' 
ret = re.findall('(\w+)',s)         #查找所有的匹配项
print(ret)
ret = re.findall('>(\w+)<',s)    #使用优先显示分组的内容,使用> < 对标签内的内容进行限定
print(ret)
结果:['a', 'wahaha', 'a']
['wahaha']

　　取消分组优先: (?:正则表达式)

ret = re.findall('\d+(\.\d+)?','1.234*4')
print(ret)
结果:['.234', '']
ret = re.findall('\d+(\.\d+)','1.234*4')
print(ret)
结果:['.234']

　　关于分组:对于正则表达式而言,有时我们需要进行分组,来整体约束某一组字符出现的次数

(\.[\w]+)?

　　对于python而言,分组可以帮助我们更好更精准的找到我们真正需要的内容.

<(\w+)>(\w+)</(\w+)>

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

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

ret = re.match('\d+','172sjkhk按实际花费928')
print(ret.group())
结果: 172
ret = re.match('\d+','sjkhk172按实际花费928')
print(ret)        #待匹配字符串不是以数字开头的,所以没有匹配到
print(ret.group())
结果: None
AttributeError: 'NoneType' object has no attribute 'group'
ret = re.match('\d+$','172sjkhk按实际花费928')
print(ret)    #没有匹配到
print(ret.group())
结果:None
AttributeError: 'NoneType' object has no attribute 'group'

　　match与search的区别:

　　re.match只匹配字符串的开始,如果字符串的开始不符合正则表达式,则匹配失败,函数返回None,而re.search匹配整个字符串,直到找到一个匹配的.

　　split():　　按照指定的字符切割

import re

s = 'alex|taibai|egon|'
print(s.split('|'))            #字符串的切割
结果:['alex', 'taibai', 'egon', '']
s = 'alex83taibai40egon25'
ret = re.split('\d+',s)    #使用正则表达式切割字符串   语法: re.split(正则表达式,待切割字符串)
print(ret)
结果:['alex', 'taibai', 'egon', '']

s = 'alex83taibai40egon'
ret = re.split('\d+',s)
print(ret)
结果:['alex', 'taibai', 'egon']

　　注意:如果待切割的字符是在字符串的两边,则切割得到的字符串两边带有空字符串.

　　使用分组进行切割

import re
ret = re.split('\d+','alex83taibai40egon25')
print(ret)
ret = re.split('(\d+)','alex83taibai40egon25aa')　#使用分组,返回所有的元素
print(ret)
结果:['alex', 'taibai', 'egon', '']
['alex', '83', 'taibai', '40', 'egon', '25', 'aa']

　　分组命名  ('?P<分组名字>正则表达式')

import re
s = '<a>wahaha</a>'
ret = re.search('>(?P<con>\w+)<',s)    #分组名为'con'
print(ret.group(1))            #分组1, 根据分组序号打印(分组序号从1开始)
print(ret.group('con'))        #根据分组名打印

　　使用分组得到需要的内容

import re
s = '<a>wahaha</a>'
pattern = '<(\w+)>(\w+)</(\w+)>'        #分为3组
ret = re.search(pattern,s)            #得到一个内存地址
print(ret)                                    
print(ret.group())                          #打印匹配到的所有的分组  
print(ret.group(2))                        # 打印分组2
print(ret.group(1) == ret.group(3))    #判断分组1与分组3是否相同
结果:<re.Match object; span=(0, 13), match='<a>wahaha</a>'>
<a>wahaha</a>
wahaha
True

　　使用前面的分组,要求使用这个名字的分组和前面同名分组的内容匹配的必须一致

pattern = '<(?P<tab>\w+)>(\w+)</(?P=tab)>'
ret = re.search(pattern,s)
print(ret.group())
结果:<a>wahaha</a>

　　匹配的内容没有特点,容易和不想匹配的内容混在一起

#精确的取到整数,过滤掉小数
import re
ret=re.findall(r"\d+\.\d+|\d+","1-2*(60+(-40.35/5)-(-4*3))")    #未使用分组
print(ret)
结果:['1', '2', '60', '40.35', '5', '4', '3']
ret=re.findall(r"\d+\.\d+|(\d+)","1-2*(60+(-40.35/5)-(-4*3))")    #使用一个分组
print(ret)
结果:['1', '2', '60', '', '5', '4', '3']
ret=re.findall(r"(\d+\.\d+)|(\d+)","1-2*(60+(-40.35/5)-(-4*3))")    #使用两个分组
print(ret)
结果:[('', '1'), ('', '2'), ('', '60'), ('40.35', ''), ('', '5'), ('', '4'), ('', '3')]

ret=re.findall(r"\d+\.\d+|(\d+)","1-2*(60+(-40.35/5)-(-4*3))")    #使用一个分组
ret.remove('')                    #使用remove去除空字符串
print(ret)
结果:['1', '2', '60', '5', '4', '3']　　#去掉小数,得到整数

　　sub()　　替换字符串中的匹配项(相当于字符串操作中的replace)

　　语法:re.sub(正则表达式, 替换的字符串(也可以是一个函数), 被替换的原始字符串, 替换次数(默认0,表示替换所有的匹配) )

ret = re.sub('\d+','H','alex83taibai40egon25')　　  #替换所有的匹配
print(ret)
结果:alexHtaibaiHegonH
ret = re.sub('\d+','H','alex83taibai40egon25',1)　　#替换1次
print(ret)
结果:alexHtaibai40egon25

　　subn()　　与sub方法一样,但是返回一个元组,元组的第一个元素是替换后的字符串,第二个元素是替换的次数.

ret = re.subn('\d+','H','alex83taibai40egon25')
print(ret)
结果:
('alexHtaibaiHegonH', 3)

ret = re.subn('\d+','H','alex83taibai40egon25',2)
print(ret)
结果:

('alexHtaibaiHegonH', 2)

　　re模块的进阶:compile, finditer

　　compile  节省使用正则表达式解决问题的时间.(将正则表达式编译成字节码,在多次使用中,不会多次编译)

ret = re.compile('\d+')   # 已经完成编译了
print(ret)
结果:re.compile('\\d+')
res = ret.findall('alex83taibai40egon25')    #使用编译完成的正则表达式去匹配字符串
print(res)
结果:['83', '40', '25']
res = ret.search('sjkhk172按实际花费928')
print(res.group())
结果:172

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

ret = re.finditer('\d+','alex83taibai40egon25')
print(ret)                   #得到一个迭代器 
for i in ret:
    print(i.group())       #每次取一个数据,节省内存空间
结果:<callable_iterator object at 0x05A2A4F0>
83
40
25

　　将compile与finditer结合使用,可以节省使用正则表达式的时间和空间.

ret = re.compile('\d+')   # 已经完成编译了
res = re.finditer(ret, 'alex83taibai40egon25')
for i in res:
    print(i.group())

　　小总结:

　　　　findall　　返回列表,找所有的匹配项

　　　　search　　匹配就返回一个变量,通过group取匹配到的第一个值,没有匹配到就返回None,没有匹配到使用group会报错.

　　　　match　　相当于search的正则表达式加了一个'^'.

　　　　split　　　返回列表,切割正则表达式匹配到的字符.

　　　　sub　　　替换,用指定的字符串替换正则表达式匹配到的字符,可以指定替换次数.默认替换所有匹配.

　　　　subn　　  替换,用指定的字符串替换正则表达式匹配到的字符,可以指定替换次数,默认替换所有匹配,返回一个元组,元组的第一个元素是替换后的字符串,第二个元素是替换的次数.

　　　　compile　  编译一个正则表达式,用这个结果去search,match,findall,finditer能够节省时间.

　　　　finditer　　返回一个迭代器,所有的结果都在这个迭代器中,需要通过for循环和group的形式取值,能够节省内存.