四、python学习-正则表达式

正则表达式

import re
lst = re.findall(正则表达式，需要匹配的字符串)

findall     把所有匹配到的字符串都搜出来，返回列表
            不能把分组内容和匹配内容同时显示出来
search      只把搜索到一个结果就返回，返回对象
            可以把分组内容和匹配的内容同时显示出来
group       对象.group()  直接获取匹配到的内容
groups      对象.groups() 直接获取分组里边的内容

1.预定义字符集

str = "caca/#%^*!~cac'cac123"

• .匹配任意字符，除了换行符\n
• \d 匹配数字
• \D 匹配非数字
• \w 匹配字母 数字 下划线(正则函数中，支持中文的匹配)
• \W 匹配非字符 数字 下划线
• \s 匹配任意的空白符：、n \t \r " " ' '
• \S 匹配非任意的空白符
• \n 匹配换行符：re.findall(r"\n",str)
• \t 匹配空格：re.findall(r"\t",str)
• [] 匹配[]中列举的字符（^在字符组中，代表除了）

    lst = re.findall("[abc]","jnjnnjnunun")=>None

    re.finadll("a[abc]c","aac abb")=>aac

    re.findall("a[0-9]b","a1b acb")=>a1b

    re.findall("a[a-g]b","a1b acb")=>acb

    re.findall("a[A-G]b","a1b acb aCb aYb")=>aCb

    re.findall("a[0-9a-zA-z]b","a-b a1b  aYb aqbalb")=>a1b aYb aqb alb

    re.finadll("a[0-9][*#/]b","a1/b a2b a29b a56b")=>a1/b

    # ^在字符组中，代表除了
    re.findall('a[^-+*/]','a%b ccaa*bda&bd')=>a%b a&b

    # 如果想要匹配^ 或者 -,在原来的字符加上\
    re.findall(r'e[\^\-]f',"e^f e-f")=>e^F e-f

    re.findall(r'a\\n','a\n')=>a\n

2.多个字符匹配

量词在那个字符后面就是谁的量词

• ? 匹配0个或者1个字符
• + 匹配1个或者多个
• * 匹配0个或者多个
• {m,n} 匹配m到n字符

import re
# 1<=x<=2
re.findall('a{1,3}b','aaab ab aab  abbb aaz aabb')=>aaab ab aab  ab aab
# x=2 前面修饰的a必须是两个字符
re.findall('a{2}b','aaab ab aab  abbb aaz aabb')=>aab aab  aab
# x>=2 至少是两个字符
re.findall('a{2,}b','aaab ab aab  abbb aaz aabb')=>aaab aab aab

3.贪婪模式 与 非贪婪模式

贪婪模式 与 非贪婪模式：
    贪婪模式：默认向更多次匹配，底层用的是回溯算法
    非贪婪模式：默认向更少次匹配，用一个？来进行修饰（修饰在两次的身后）

    回溯算法：从左向右进行匹配，一直到最后，直接最后再也匹配不到了，回头，寻找最后一个

strvar = "张三李四王五张四张五子acaca子443232"
re.findall("张.",strvar)=>张三 张四 张五

# 贪婪模式
re.findall("张.?",strvar)=>张三 张四 张五
re.findall("张.+",strvar)=>张三李四王五张四张五子acaca子443232
re.findall("张.*",strvar)=>张三李四王五张四张五子acaca子443232
re.findall("张.{1,21}",strvar)=>张三李四王五张四张五子acaca子443232
re.findall("张.*子",strvar)=>张三李四王五张四张五子acaca子

# 非贪婪模式
re.findall("张.??",strvar)=>张 张 张
re.findall("张.+?",strvar)=>张三 张四 张五
re.findall("张.*",strvar)=>张 张 张
re.findall("张.{1,21}?",strvar)=>张三 张四 张五
re.findall("张.*?子",strvar)=>张三李四王五张四张五子

4.边界符

# \b backspace 本身就是一个转义字符

边界符 卡单词word
    卡住左边界 \bw
    卡住右边界 d\b

import re
strvar = "word pwd scf"
re.findall(r".*d\b",strvar) 'word pwd'
re.findall(r".*?d\b",strvar) word,pwd
re.findall(r"\bw",strvar)    'w'
re.findall(r"\bw.*?",strvar) 'w'
# 正则表达式中写字符时，要谨慎，下面例子必须匹配到第一个空格时，才结束
re.findall(r"\bw.*? ",strvar) 'word '

re.findall(r"\bw\S",strvar) 'wo'
re.findall(r"\bw\S*",strvar) 'word'

^ 、 $

^ 必须以...开头
$ 必须以...结尾
 如果出现了^ $,要把这个字符串看成一个整体

5.正则表达式-分组

• 正常分组

import re
strvar = "wu_good alex_good secret_good"
# 1.分组练习
re.findall('.*?_good',strvar) =>"wu_good" "alex_good" "secret_good"
# () 显示括号里边匹配到的内容
re.findall('(.*?)_good',strvar) =>"wu" "alex" "secret"
# ?: 不显示括号里边的内容
re.findall('(?:.*?)_good',strvar) =>"wu_good" "alex_good" "secret_good"

# 2. | 代表或，a|b代表 a 或 b
strvar = "abcddd"
re.findall("a|b",strvar) => a,b
# 注意事项:为啦避免优先匹配前面的字符串，导致字符串匹配不完整，把较难匹配到的字符串写在前面，容易匹配到的字符串放在后边
# 匹配abc 或者abcd
strvar = "abc121548112ddabcd21513"
re.findall("abc|abcd",strvar) => abc,abc
re.findall("abcd|abc",strvar) => abc,abcd

# 3.练习
# 匹配小数
re.findall(r"\d+\.\d+",str)
# 匹配小数和整数
re.findall(r"\d+\.\d+|\d+",strvar)
re.findall(r"\d+(?:\.\d+)?",strvar)
# 匹配135或者171的手机号
re.findall(r"(?:135|171)[0-9]{8}",strvar)
re.findall(r"^(?:135|171)[0-9]{8}$",strvar)
# 匹配www.baidu.com 或者 www.oldboy.com
re.findall(r"www.baidu.com|www.oldboy.com")
re.findall(r"www_(?:baidu|oldboy)_com")

# 获取第一个
obj = re.search(r"(?:www).(?:baidu|oldboy).(?:com)")
obj.group()  =>www.baidu.com
# 获取分组()里边的数据
obj.groups() =>['www','baidu','com']
# “5*6-7/3” 匹配5*6 或者 7/3
print(re.findall('(?:\d+[*/]\d)|(?:\d/\d)',"5*6-7/3"))

• 命名分组

import re
strvar = "<div>123456</div>"
lst = re.findall(r"<(.*?)>(.*?)<(.*?)>",strvar)=> ['div','123456','/div']

# 1.反向引用
# \1代表反向引用，将第一个括号匹配的字符串，在\1位置处再引用一次
lst = re.findall(r"<(.*?)>(.*?)<(/\1)>",strvar)=> ['div','123456','/div']

strvar = "a1b2cab"
re.search(r"(.*?)\d(.*?)\d(.*?)\1\2",strvar)

# 2.命名分组（给小组命名）
语法：(?P<组名>正则表达式)给这个组起一个名字
      (?P=组名) 引用之前组的名字，把该组名匹配到的内容放到当前位置

strvar = "a1b2cab"
re.search(r"(?P<tag1>.*?)\d(?P<tag2>.*?)\d(.*?)\1\2",strvar)
re.search(r"(?P<tag1>.*?)\d(?P<tag2>.*?)\d(.*?)(?P=tag1)(?P=tag2)",strvar)

6正则函数

• findall()
• search() 通过正则匹配出第一个对象就返回，通过group去除对象中的值,groups把括号里匹配到的内容丢到元组中返回
• match() search只要在正则表达式的前面加上^ 就和match一样
• split() 切割

import re
strvar = "alex|xboy&wusir-egon"
re.split("[|&-]",strvar)#alex xboy wusir egon
strvar = "alex242141xboy232523wusir1215egon"
re.split("[\d+]",strvar)#alex xboy wusir egon " "

• sub() 替换(正则表达式，替换的字符串，原字符串，[可选的替换次数})

import re
strvar = "alex|xboy&wusir-egon"
re.sub("[|&-]","%",strvar)# "alex%xboy%wusir%egon"
# 替换一次
re.sub("[|&-]","%",strvar)# re.sub("[|&-]","%",strvar,1)# "alex%xboy&wusir-egon"

• subn() 替换 与sub用法一样，区别在于返回值不同，返回的是元组

import re
strvar = "alex|xboy&wusir-egon"
re.sub("[|&-]","%",strvar)# "alex%xboy%wusir%egon",3
# 替换一次
re.sub("[|&-]","%",strvar)# re.sub("[|&-]","%",strvar,1)# "alex%xboy&wusir-egon",1

• finditer 匹配字符串中的相应内容，返回迭代器

from collections import Iterator
strvar = "safadsadsadas你好23342"
it = re.finditar(r"\d+",strvar)
isinstance(it,Iterabor)
for i in it:
    i.group()

• compile 指定一个统一的匹配规则

正常情况下，正则表达式执行一次，编译一次
如果反复使用，会浪费系统资源，比如内存,cpu

compile 可以使正则编译一次，无序反复编译

strvar = "safadsadsaddsad155as你好23342"
pattern = re.compile(r"\d+")# re.compile('\\d+')返回的是对象
obj = pattern.search(strvar)
obj.group()#155
lst = pattern.findall(strvar)# ["155","23342"]

正则表达式修饰符 配合compile使用

• re.I 使匹配对大小写不敏感

strvar = "<h1>123</H1>"
pattern = re.compile("<h1>.*?</h1>",flag=re.I)
pattern.search(strvar).group() # 123

• re.M 使每一行都能单独匹配（多行匹配），影响^ $的使用

strvar = """<h1>123</H1>
<p>123</p>
<div>123</div>
"""
pattern = re.compile("^<.*?>(.*?)<.*?>$")
# 因为
pattern.findall(strvar) # []
# 使用re.M
pattern = re.compile("^<.*?>(.*?)<.*?>$",flag=re.M)
pattern.findall(strvar) # 123 123 123

• re.S 使.匹配包含换行在内的所有内容

strvar ="""give
112233mefive
"""
pattern = recompile("(.*?)mefive")
# 因为.匹配不到\n换行符
pattern.search(strvar).group()# 112233mefive
# 使用re.S 完善.
pattern = recompile("(.*?)mefive",flags=re.S)
pattern.search(strvar).group()# "give \n 112233mefive"