四、python学习-正则表达式

2021-04-16 11:04:13 阅读：306 来源： 互联网

标签：good 匹配 re python pattern 学习正则表达式 strvar findall

正则表达式

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"

标签：good,匹配,re,python,pattern,学习,正则表达式,strvar,findall
来源： https://www.cnblogs.com/g-woniu/p/14665912.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9