当前位置：Gxlcms > Python > python的正则表达式的操作--re模块

python的正则表达式的操作--re模块

时间：2021-07-01 10:21:17 帮助过：46人阅读

re模块

序言：

re模块用于对python的正则表达式的操作

  1. '.'     默认匹配除\n之外的任意一个字符，若指定flag DOTALL,则匹配任意字符，包括换行
  2. '^'     匹配字符开头，若指定flags MULTILINE,这种也可以匹配上(r"^a","\nabc\neee",flags=re.MULTILINE)
  3. '$'     匹配字符结尾，或e.search("foo$","bfoo\nsdfsf",flags=re.MULTILINE).group()也可以
  4. '*'     匹配*号前的字符0次或多次，re.findall("ab*","cabb3abcbbac")
结果为['abb', 'ab', 'a'] '+' 匹配前一个字符1次或多次，re.findall("ab+","ab+cd+abb+bba") 结果['ab', 'abb'] '?' 匹配前一个字符1次或0次 '{m}' 匹配前一个字符m次 '{n,m}' 匹配前一个字符n到m次，re.findall("ab{1,3}","abb abc abbcbbb") 结果'abb', 'ab', 'abb'] '|' 匹配|左或|右的字符，re.search("abc|ABC","ABCBabcCD").group() 结果'ABC' '(...)' 分组匹配，re.search("(abc){2}a(123|456)c", "abcabca456c").group() 结果 abcabca456c '[a-z]' 匹配a到z任意一个字符 '[^()]' 匹配除()以外的任意一个字符 r' ' 转义引号里的字符 针对\字符 详情查看⑦ '\A' 只从字符开头匹配，re.search("\Aabc","alexabc") 是匹配不到的 '\Z' 匹配字符结尾，同$ '\d' 匹配数字0-9 '\D' 匹配非数字 '\w' 匹配[A-Za-z0-9] '\W' 匹配非[A-Za-z0-9] '\s' 匹配空白字符、\t、\n、\r , re.search("\s+","ab\tc1\n3").group() 结果 '\t' '(?P<name>...)' 分组匹配 re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birthday>[0-9]{4})","371481199306143242").groupdict("city") 结果{'province': '3714', 'city': '81', 'birthday': '1993'} re.IGNORECASE 忽略大小写 re.search('(\A|\s)red(\s+|$)',i,re.IGNORECASE)

标志位即模式修正符，不改变正则表达式的情况下，通过模式修正符改变正则表达式的含义，从而实现一些匹配结果的调整等功能：　

  1. # flags
  2. I = IGNORECASE = sre_compile.SRE_FLAG_IGNORECASE # ignore case　　匹配时忽略大小写
  3. L = LOCALE = sre_compile.SRE_FLAG_LOCALE # assume current 8-bit locale   做本地化识别匹配
  4. U = UNICODE = sre_compile.SRE_FLAG_UNICODE # assume unicode locale       根据Unicode字符及解析字符
  5. M = MULTILINE = sre_compile.SRE_FLAG_MULTILINE # make anchors look for newline   多行匹配
  6. S = DOTALL = sre_compile.SRE_FLAG_DOTALL # make dot match newline      让.匹配包括换行符，即用了该模式修正后，"."匹配就可以匹配任意的字符了
  7. X = VERBOSE = sre_compile.SRE_FLAG_VERBOSE # ignore whitespace and comments

贪婪模式、懒惰模式：

  1. import re
  2. result1 =  re.search("p.*y","abcdfphp435pythony_py")   # 贪婪模式
  3. print(result1)
  4. # <_sre.SRE_Match object; span=(5, 21), match='php435pythony_py'>
  5. result2 =  re.search("p.*?y","abcdfphp435pythony_py")   # 懒惰模式
  6. print(result2)
  7. # <_sre.SRE_Match object; span=(5, 13), match='php435py'>

　　

match：

从起始位置开始根据模型去字符串中匹配指定内容：

  1. #match
  2. import re                               
  3. obj = re.match('\d+', '123uua123sf')       #从第一个字符开始匹配一个到多个数字
  4. print(obj)                                
  5. #<_sre.SRE_Match object; span=(0, 3), match='123'>
  6. if obj:                                   #如果有匹配到字符则执行，为空不执行
  7.     print(obj.group())                    #打印匹配到的内容
  8. #123

匹配ip地址：

  1. import re
  2. ip = '255.255.255.253'
  3. result=re.match(r'^([1-9]?\d|1\d\d|2[0-4]\d|25[0-5])\.([1-9]?\d|1\d\d|2[0-4]\d|25[0-5])\.'
  4.                 r'([1-9]?\d|1\d\d|2[0-4]\d|25[0-5])\.([1-9]?\d|1\d\d|2[0-4]\d|25[0-5])$',ip)
  5. print(result)
  6. # <_sre.SRE_Match object; span=(0, 15), match='255.255.255.253'>

search：

根据模型去字符串中匹配指定内容（不一定是最开始位置），匹配最前

  1. #search
  2. import  re
  3. obj = re.search('\d+', 'a123uu234asf')     #从数字开始匹配一个到多个数字
  4. print(obj)
  5. #<_sre.SRE_Match object; span=(1, 4), match='123'>
  6. if obj:                                   #如果有匹配到字符则执行，为空不执行
  7.     print(obj.group())                    #打印匹配到的内容
  8. #123
  9. import  re
  10. obj = re.search('\([^()]+\)', 'sdds(a1fwewe2(3uusfdsf2)34as)f')     #匹配最里面（）的内容
  11. print(obj)
  12. #<_sre.SRE_Match object; span=(13, 24), match='(3uusfdsf2)'>
  13. if obj:                                   #如果有匹配到字符则执行，为空不执行
  14.     print(obj.group())                    #打印匹配到的内容
  15. #(3uusfdsf2)

group与groups的区别：

  1. #group与groups的区别
  2. import  re
  3. a = "123abc456"
  4. b = re.search("([0-9]*)([a-z]*)([0-9]*)", a)
  5. print(b)
  6. #<_sre.SRE_Match object; span=(0, 9), match='123abc456'>
  7. print(b.group())
  8. #123abc456
  9. print(b.group(0))
  10. #123abc456
  11. print(b.group(1))
  12. #123
  13. print(b.group(2))
  14. #abc
  15. print(b.group(3))
  16. #456
  17. print(b.groups())
  18. #('123', 'abc', '456')

findall：

上述两中方式均用于匹配单值，即：只能匹配字符串中的一个，如果想要匹配到字符串中所有符合条件的元素，则需要使用 findall；findall没有group用法

  1. #findall
  2. import  re
  3. obj = re.findall('\d+', 'a123uu234asf')     #匹配多个
  4. if obj:                                   #如果有匹配到字符则执行，为空不执行
  5.     print(obj)                             #生成的内容为列表
  6. #['123', '234']

sub：

用于替换匹配的字符串(pattern, repl, string, count=0, flags=0)

  1. #sub
  2. import  re
  3. content = "123abc456"
  4. new_content = re.sub('\d+', 'ABC', content)
  5. print(new_content)
  6. #ABCabcABC

split：

根据指定匹配进行分组(pattern, string, maxsplit=0, flags=0)

  1. #split
  2. import  re
  3. content = "1 - 2 * ((60-30+1*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2) )"
  4. new_content = re.split('\*', content)       #用*进行分割，分割为列表
  5. print(new_content)
  6. #['1 - 2 ', ' ((60-30+1', '(9-2', '5/3+7/3', '99/4', '2998+10', '568/14))-(-4', '3)/(16-3', '2) )']
  7. content = "'1 - 2 * ((60-30+1*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2) )'"
  8. new_content = re.split('[\+\-\*\/]+', content)
  9. # new_content = re.split('\*', content, 1)
  10. print(new_content)
  11. #["'1 ", ' 2 ', ' ((60', '30', '1', '(9', '2', '5', '3', '7', '3', '99', '4', '2998', '10', '568', '14))',
  12. #  '(', '4', '3)', '(16', '3', "2) )'"]
  13. inpp = '1-2*((60-30 +(-40-5)*(9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2))'
  14. inpp = re.sub('\s*','',inpp)                #把空白字符去掉
  15. print(inpp)
  16. new_content = re.split('\(([\+\-\*\/]?\d+[\+\-\*\/]?\d+){1}\)', inpp, 1)
  17. print(new_content)
  18. #['1-2*((60-30+', '-40-5', '*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2))']

补充r' ' 转义：

  1. fdfdsfds\fds
  2. sfdsfds& @$
lzl.py

首先要清楚，程序读取文件里的\字符时，添加到列表里面的是\\：

  1. import re,sys
  2. li = []
  3. with open('lzl.txt','r',encoding="utf-8") as file:
  4.     for line in file:
  5.         li.append(line)
  6. print(li)                   # 注意：文件中的单斜杠，读出来后会变成双斜杠
  7. # ['fdfdsfds\\fds\n', 'sfdsfds& @$']
  8. print(li[0])                # print打印的时候还是单斜杠
  9. # fdfdsfds\fds

r字符的意义，对字符\进行转义，\只做为字符出现：

  1. import re,sys
  2. li = []
  3. with open('lzl.txt','r',encoding="utf-8") as file:
  4.     for line in file:
  5.         print(re.findall(r's\\f', line))  #第一种方式匹配
  6.         # print(re.findall('\\\\', line))  #第二种方式匹配
  7.         li.append(line)
  8. print(li)                   # 注意：文件中的单斜杠，读出来后会变成双斜杠
  9. # ['s\\f']
  10. # []
  11. # ['fdfdsfds\\fds\n', 'sfdsfds& @$']

补充：看完下面的代码你可能更懵了

  1. import re
  2. re.findall(r'\\', line)  # 正则中只能这样写 不能写成 r'\' 这样
  3. print(r'\\')            # 只能这样写 不能写成r'\' \只能是双数
  4. # \\        结果
  5. # 如果想值打印单个\ 写成如下
  6. print('\\')             # 只能是双数
  7. # \         结果

总结：文件中的单斜杠\，读出到程序中时是双斜杠\\，print打印出来是单斜杠\；正则匹配文件但斜杠\时,用r'\\'双斜杠去匹配，或者不用r直接用'\\\\'四个斜杠去匹配

compile函数：

说明：

  1. Python通过re模块提供对正则表达式的支持。使用re的一般步骤是先使用re.compile()函数，将正则表达式的字符串形式编译为Pattern实例，
  2. 然后使用Pattern实例处理文本并获得匹配结果（一个Match实例），最后使用Match实例获得信息，进行其他的操作

举一个简单的例子，在寻找一个字符串中所有的英文字符：

  1. import re
  2. pattern = re.compile('[a-zA-Z]')
  3. result = pattern.findall('as3SiOPdj#@23awe')
  4. print(result)
  5. # ['a', 's', 'S', 'i', 'O', 'P', 'd', 'j', 'a', 'w', 'e']

匹配IP地址（255.255.255.255）：　　

  1. import re
  2. pattern = re.compile(r'^(([1-9]?\d|1\d\d|2[0-4]\d|25[0-5])\.){3}([1-9]?\d|1\d\d|2[0-4]\d|25[0-5])$')
  3. result = pattern.match('255.255.255.255')
  4. print(result)
  5. # <_sre.SRE_Match object; span=(0, 15), match='255.255.255.255'>

以上就是python的正则表达式的操作--re模块的详细内容，更多请关注Gxl网其它相关文章！

人气教程排行

本站所有资源全部来源于网络，若本站发布的内容侵害到您的隐私或者利益，请联系我们删除！