re 模块

正则表达式,给字符串进行模糊匹配

r => raw string 原始字符串  加上r 就是指里面的任何内容都不做转译了

1. 常用的元字符

.

元字符	元字符的用法说明
.	同配符， 是指什么都可以代表
^	以...开头， 在字符集里面是非的意思
$	以...结尾
*	按紧挨着的字符去重复（0 到无穷次）
+	是匹配（1到无穷次）
?	（0，1） 只能匹配这两次
{}	可以自己看重复几次{0,} == *, {1,} == + {0,1}==? {6} 匹配6次 {n,m} 重复n到m次
[]	字符集
|	或
()	用来进行分组的
\	转译

 

代码	代码的用法说明
\w \W	匹配字母或数字或下划线或汉字 相当于 [a-zA-Z0-9_] 匹配任何非字母数字字符；它相当于类 [^a-zA-Z0-9_]
\s \S	匹配任意的空白符，相当于  [ \t\n\r\f\v] 匹配任何非空白字符， 相当于  [^ \t\n\r\f\v]
\d \D	匹配数字 相当于【0-9】  \d+ 是指匹配多位数字 匹配任何非数字字符相当于 [^0-9]
\b \B	匹配单词的开始或结束 https://blog.csdn.net/uvyoaa/article/details/80854459 匹配一个特殊字符边界，比如空格 ，&，＃等 因为\b 在python 本身就有意义，所以用\\b

\D	匹配任何非数字字符相当于 [^0-9]
\S	匹配任何非空白字符， 相当于  [^ \t\n\r\f\v]

 

2. 常用的函数

re.findall()  　  ： 　

进行匹配 ， 把所有能拿到的结果放在一个列表里面

print(re.findall('a..x','asaxfassxejfalex'))  # ['asax', 'assx', 'alex']
# ^  即以什么开头的意思
print(re.findall('^a..x','asaxfassxejfalex'))  #['asax']
# $  即以什么结尾
print(re.findall('a..x$','asaxfassxejfalex'))  # ['alex']

print(re.findall('d*','asdddalex'))  # 0次也是匹配上的意思  ['', '', 'ddd', '', '', '', '', '']

print(re.findall('alex*','asdddale'))  # ['ale']
print(re.findall('alex+','asdddale'))  # []
print(re.findall('alex?','asdddalex'))  # ['alex']
print(re.findall('alex{6}','asdddalexxxxxxxxxx'))  # ['alexxxxxx']
print(re.findall('alex{1,6}','asdddalexxx'))  # ['alexxx']
print(re.findall('alex*?','asdddalexxxxxxxxx'))  # ['ale'] 变成惰性匹配，按最少来匹配
# 按照最多的去匹配 叫他难匹配

print(re.findall('www[oldboy baidu]','wwwbaiducom'))  # wwwo / wwwl /wwwb 所以 匹配结果为 ['wwwb']
print(re.findall('x[yz]p','xypuuxzpuu'))  # 是或的意思  ['xyp', 'xzp']
# 元字符里面没有特殊符号   有特殊意义的 为  -  ^ \
print(re.findall('[a-z]','x1234y5436puuxzpuu'))  # ['x', 'y', 'p', 'u', 'u', 'x', 'z', 'p', 'u', 'u']
print(re.findall('[a-z]*','x1234y5436puuxzpuu'))  # ['x', '', '', '', '', 'y', '', '', '', '', 'puuxzpuu', '']
print(re.findall('^[a-z]','x1234y5436puuxzpuu'))  # ['x']

print(re.findall('[^a-z]','x1234y5436puuxzpuu'))  # ['1', '2', '3', '4', '5', '4', '3', '6']  即与字符集中的相反

print(re.findall('\([^( )]*\)','12+(34*6+2-5*(2-1-(3+1))'))  # 是指括号里面不在有括号了

print(re.findall('I\\b', 'hello I am LIST'))  #['I'] 因为第一个I 旁边都是特殊字符， 所以可以被匹配出来

print(re.findall(r'ka|b','sdjkabsf'))  # ['ka', 'b']   ka 或者 b

print(re.findall(r'(?:abc)+','abcabcabc'))  
#  ?: at the start, e.g. (?: ) and that left paren will not count as a group result.)
print(re.findall(r'(?P\w+)*','abcabcabc'))  
#  有名分组 真正要匹配的内容只有\w+ , 其他的内容都是在做分组   ？P 是定死的

print(re.findall('www\.(baidu|163)\.com',"www.baidu.com"))  # 显示的是组里面匹配成功的东西['baidu'] ， 做了分组之后，优先把分组的东西拿出来
print(re.findall('www\.(baidu|163)\.com',"sdadasdasdwww.baidu.comasdasdas")) # ['baidu'] 能够匹配所有的，但是拿出来的是组里的
print(re.findall('www\.(?:baidu|163)\.com',"www.baidu.com"))  # 相当于把括号里的 优先级去掉，['www.baidu.com']
# ？： 去优先级

 

 

不懂的：

print(re.findall('c\\f','abc\f'))  #['c\x0c']  # \xoc是换页符
print('-----------l')
print(re.findall(r'\\L','hello I am \LIST'))  # ['\\L']  一个\是元字符的意思，第二个\是转译，一个\只能取消一个特殊意义，所以是4个（如果要输出两个\)
print(re.findall('\\\L','hello I am \LIST'))  # ['\\L']  结果是一个原始字符串，多以前面一个\是转译的意思

 

re.search(a,b)      　　+ .group()

a 寻找目标， b 被寻找字符串  只找到一个就不再往下找了

print(re.search('\d+','asdw343ffafas23sf3'))
#    返回一个对象，所有的信息在对象里面

print(re.search('\d(5)','asdw343ffafas23sf3'))
# 即匹配5个数字在一起   返回无内容

print(re.search('\d+','asdw343ffafas23sf3').group())
# 即把值取出来   .group 的作用是把值取出来

print(re.search(r'(?P[a-z]+)*','ab234cabcabc').group())  # ab  ?P 相当于 把内容做了一个分组
print(re.search(r'[a-z]+','ab234cabcabc').group())   # ab
print(re.search(r'(?P[a-z]+)\d+','ab234cabcabc').group())  # ab234
print(re.search(r'(?P[a-z]+)(?P\d+)','ab234cabcabc').group('name'))  # ab
print(re.search(r'(?P[a-z]+)(?P\d+)','ab234cabcabc').group('age'))  # 234

print(re.search('abc|bcd',"bcd").group())  # bcd
print(re.search('a(bc)|(ty)d','tyd').group())  # tyd

 

re.finditer()  

把所有的结果封装到一个迭代器里面迭代器

ret = re.finditer('\d', 'dasdaodh669adash8')  
print(next(ret))     #   第一个结果是一个对象
print(next(ret).group())  # 6
print(next(ret).group())  # 8
print(next(ret).group())  #9

 

re.match()

只会从开始进行匹配

print(re.match('\d+','797alex35sdqhd'))  # 
# 匹配成功  如果前面没有797 就是匹配不成功
print(re.match('\d+','797alex35sdqhd').group()) # 也是返回一个对象， 需要用.group 取出来

 

re.split ()

进行分割

print(re.split(' ','hello abc def'))  # 以空格来分割
print(re.split('[ |]','hello abc|def'))  # 以字符集的形式， 以空格或|来分割
print(re.split('[ab]','asdsabkbbogdytd'))  # 先按a分 再按b分
print(re.split('[ab]','abc'))  # ['', '', 'c']

re.sub()

进行替换

print(re.sub('\d+','A','fehowh877979'))  # 替换什么，   替换成什么  ，替换对象
print(re.sub('\d','A','fehowh877979',4))  # 替换4个
print(re.subn('\d ','A','fehowh877979',4))  #  把结果匹配成元祖  第一个是匹配的结果，第二个是匹配的次数

re.compile(）

编译，编译好 下次在用就不用编译了 接下来的所有方法都可以通过 com.xxx （com.findall())去带调取

好处是可以使用多次 

com = re.compile('\d+')