python常用模块----re模块

正则表达式就是匹配字符串内容的一种规则。

字符组：

　　[0123456789] 表示0-9这个范围内的任意一个数字都可以与之匹配，简写为[0-9]

　　[a-z] 表示匹配所有的小写字母

　　[A-Z] 表示匹配所有的大写字母

　　[0-9a-zA-Z]  表示可以匹配数字和大小写字母

字符：

　　.       匹配除换行符以外的任意字符

　　\w    匹配字母或数字或下划线

\W    匹配非字母或数字或下划线

　　\s     匹配任意的空白符

　　\S     匹配非空白符

　　\d　  匹配数字

　　\D     匹配非数字

　　\n      匹配一个换行符

　　\t　　匹配一个制表符

　　\b　　匹配一个单词的结尾

　　^　　匹配字符串的开始

　　$　　匹配字符串的结尾

　　a|b　匹配字符a或字符b

　　()　　匹配括号内的表达式，也表示一个组

　　[^...]　匹配除了字符组中字符的所有字符

量词：

　　*　　  重复零次或更多次

　　+　　  重复一次或更多次

　　？　　重复零次或一次

　　{n}　　重复n次

　　{n,}　　重复n次或更多次

　　{n,m}　重复n到m次

转义符\：

　　在正则表达式中，有很多有特殊意义的是元字符，比如\d和\s等，如果要在正则中匹配正常的"\d"而不是"数字"就需要对"\"进行转义，变成'\\'。

　　在python中，无论是正则表达式，还是待匹配的内容，都是以字符串的形式出现的，在字符串中\也有特殊的含义，本身还需要转义。所以如果匹配一次"\d",字符串中要写成'\\d'，那么正则里就要写成"\\\\d",这样就太麻烦了。这个时候我们就用到了r'\d'这个概念，此时的正则是r'\\d'就可以了。

贪婪匹配：　

贪婪匹配：在满足匹配时，匹配尽可能长的字符串，默认情况下，采用贪婪匹配

　　*? 重复任意次，但尽可能少重复

　　+? 重复1次或更多次，但尽可能少重复

　　?? 重复0次或1次，但尽可能少重复

　　{n,m}? 重复n到m次，但尽可能少重复

　　{n,}? 重复n次以上，但尽可能少重复

re模块下的常用方法：

findall : 返回所有满足匹配条件的结果，放在列表里

import re
ret = re.findall('e','nice to meet you')
print(ret)  #  ['e', 'e', 'e']

search : 函数会在字符串内查找模式匹配,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以 通过调用group()方法得到匹配的字符串,如果字符串没有匹配，则返回None。

import re
ret = re.search('e','nice to meet you')
print(ret.group()) # e
ret = re.search('a','nice to meet you')
print(ret) # None

match : 同search，不过仅仅只是在字符串开始处进行匹配

import re
ret = re.match('n','nice to meet you')
print(ret.group()) # n
ret = re.match('t','nice to meet you')
print(ret) # None

split :分割

ret = re.split('[ab]','abcd')
print(ret)  # ['', '', 'cd']   先按'a'分割得到''和'bcd',在对''和'bcd'分别按'b'分割
ret = re.split('ab','abcd')
print(ret)  # ['', 'cd']        按ab整体进行切割，左边'',右边'cd'

ret = re.split('b','abcd')
print(ret)  # ['a', 'cd']

ret = re.split('[bc]','abcd')
print(ret)  # ['a', '', 'd']
ret = re.split('[d]','abcd')
print(ret)  # ['abc', '']

split

sub : 替换

ret = re.sub('\d','L','gh2cj4df89ab')
print(ret)   # ghLcjLdfLLab   将数字替换成'L'  ，最后那个参数不写，则默认全部替换
ret = re.sub('\d','L','gh2cj4df89ab',1)
print(ret)  # ghLcj4df89ab  最后那个参数是1表示只替换1个，从左边开始找
ret = re.sub('h','L','gh2cjh4df89ab')
print(ret)   # gL2cjL4df89ab

sub

subn :  替换，返回元组

ret = re.subn('\d','L','gh2cj4df89ab')
print(ret)   # ('ghLcjLdfLLab', 4)   将数字替换成'L'  ，返回元组 （替换后的字符串，替换了多少次） 最后那个参数不写，则默认全部替换
ret = re.subn('\d','L','gh2cj4df89ab',3)
print(ret)  # ('ghLcjLdfL9ab', 3)  只替换了3次

subn

compile : 编译

import re
obj = re.compile('\d{3}')   #将正则表达式编译成为一个 正则表达式对象，规则要匹配的是3个数字
re = obj.findall('ab125djj5671sjjk')  #正则表达式对象调用findall，参数为待匹配的字符串
print(re)  # ['125', '567']

finditer : 返回一个存放匹配结果的迭代器

import re
ret = re.finditer('\d','hgd2dff6s4av1')
print(ret)  # <callable_iterator object at 0x000001FC67470160>
print(next(ret).group())  # 2  查看第一个结果
print(ret.__next__().group())  # 6  查看第二个结果
print([i.group() for i in ret])  # ['4', '1']  查看剩余的结果

finditer

findall的优先级查询：

import re
ret = re.findall('www.(baidu|cnblogs).com','www.cnblogs.com')
print(ret)  # ['cnblogs']   这是因为findall会优先把匹配结果组里内容返回,如果想要匹配结果,取消权限即可
ret = re.findall('www.(?:baidu|cnblogs).com','www.cnblogs.com')
print(ret)   # ['www.cnblogs.com']

split的优先级查询：

import re
ret = re.split('\d+','lucy2lilei3jim4lily')
print(ret)   # ['lucy', 'lilei', 'jim', 'lily']
ret = re.split('(\d+)','lucy2lilei3jim4lily')
print(ret)   # ['lucy', '2', 'lilei', '3', 'jim', '4', 'lily']
#在匹配部分加上（）之后所切出的结果是不同的，
#没有（）的没有保留所匹配的项，但是有（）的却能够保留了匹配的项，
#这个在某些需要保留匹配部分的使用过程是非常重要的。