Python教程

四、python学习-正则表达式

本文主要是介绍四、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"
这篇关于四、python学习-正则表达式的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!