zoukankan      html  css  js  c++  java
  • python --> 正则表达式

    在python中使用正则表达式,需要导入 re 模块

    一、 元字符,包括 []  {} | ? * +  .  ^ $   ()

      . 号:通配符,一个点号就代表一个字符,一般情况下不能通配换行符

      * 号:控制前面的一个字符或是组,重复出现0至n次

      +号:控制前面的一个字符或是组,重复出现1至n次

      ?号:控制前面的一个字符或是组,重复出现0或1次

      {}号:内部加数字参数,固定重复次数,也可以写为 {3,5} 代表重复3/4/5次都ok

      ()号:把内部封装一起作为一组,一个整体

      ^号:控制开头

      $号:控制结尾,

      号:后面跟元字符,去掉元字符的特殊含义,后面跟普通字符,赋予普通字符特殊意义,跟数字,引用序号对应的组所匹配到的字符串

        d:匹配任何十进制数字,相当于类[0-9]

        D:匹配任何非数字字符,相当于类[^0-9]

        s:匹配任何空白字符,相当于类[ fv]

        S:匹配任何非空字符,相当于类[^ fv]

        w:匹配任何字母数字字符,相当于类[0-9a-zA-Z]

        W:匹配任何非字母数字字符,相当于类[^0-9a-zA-Z]

        :匹配一个单词边界,也就是指单词与空格间的位置   

      []号:字符集,中括号里的内容之间存在或者的关系,取其一;放在字符集里的元字符失去意义,变为普通字符,^放在字符集里表示‘非’的意思;d等在字符集里意义不变

      | 号:代表‘或’,选其一

    二、函数

      re.match(pattern,string,flag = 0):从字符串的开头进行匹配

        flag = 0 参数,可修改为 re.I 使匹配对大小写不敏感;re.S 使可以匹配出任意字符,包括换行符 ;re.M 多行匹配,会影响^ $

      re.search(pattern,string,flag):浏览全部字符串,逐个字符匹配,匹配第一个符合规则的字符串

      match 和 search 匹配的结果都是一个对象,对匹配到的对象进行处理,有如下方法

        .group() 返回匹配到的字符串整体,括号内默认参数为0,如设置为1,则代表返回匹配到的第一组的结果

        .groups() 获取匹配到的分组结果,只匹配pattern里组里的内容,以元组形式显示

        .groupdict() 获取匹配到的结果,以字典形式显示,对于格式有要求,固定格式为 (?P<key名字>value)

    1 origin = 'hey everybody,say hello to the wonderful world!'
    2 res = re.search('(?P<key1>h).+(lo)',origin)
    3 print(res.group(2))
    4 print(res.group())
    5 print(res.groups())
    6 print(res.groupdict())
    View Code

        .start()返回匹配开始的位置

        .end()返回匹配结束的位置

        .span()返回包含匹配(开始,结束)的位置

    origin = 'hey everybody,say hello to the wonderful world!'
    res = re.search('(?P<key1>h).+(lo)',origin)
    print(res.group(2))
    print(res.group())
    print(res.groups())
    print(res.groupdict())
    print(res.start())
    print(res.end())
    print(res.span())
    # 会涉及到正则表达式的贪婪模式,下文讲述

      re.findall(pattern,string,flag) 将匹配到的所有内容以字符串形式作为元素,放到一个列表中;如果pattern中出现了组,即(),那么就按照所有的限制条件去匹配,但是仅将组里匹配出的内容返回给列表;如果规则里只有1个组,那么得到的列表里元素就是字符串,如果存在多个组,那得到的列表的元素为元组,每个元组的元素是字符串

     1 import re
     2 origin = 'hello alex,again alex,bye acd'
     3 res = re.findall('a(w*)',origin)
     4 print(res)
     5 res = re.findall('a(w*)x',origin)
     6 print(res)
     7 res = re.findall('(a)(w*)(x)',origin)
     8 print(res)
     9 
    10 # 结果如下
    11 ['lex', 'gain', 'lex', 'cd']
    12 ['le', 'le']
    13 [('a', 'le', 'x'), ('a', 'le', 'x')]

        几种特别注意情况

        ① 嵌套分组括号,执行完一遍外层,再执行一边内层,结果都返回

    1 import re
    2 origin = 'ethan'
    3 res = re.findall('(e)(w*(a))(n)',origin)
    4 print(res)
    5 
    6 #结果如下
    7 
    8 [('e', 'tha', 'a', 'n')]

        ②判断字符串中空元素个数,得到结果列表元素为空,个数比字符串长度多1

    import re
    origin = 'ethan'
    res = re.findall('',origin)
    print(res)
    
    # 结果如下
    
    ['', '', '', '', '', ''] 

        ③其他特殊情况,涉及分组个数与重复次数

    import re
    origin = 'ethan'
    res = re.findall('(w)*',origin)
    print(res)
    n =re.findall('(dasd)*','1asd2asdp3asd98k3f')
    print(n)
    
    # 虽然可以重复0-n次,但是实际分组只有1组,默认返回贪婪模式下最后一组结果
    
    ['n', '']
    ['2asd', '', '3asd', '', '', '', '', '', '']

      re.sub(pattern,repl,string,max=0) 替换掉字符串内容

      re.subn() 最后会显示替换掉的次数,结果为元组形式,替换后的字符串为元素

     1 import re
     2 origin = 'goodday,goodbye,good morning,oh my god'
     3 res = re.sub('gw+d','have',origin)
     4 print(res)
     5 res = re.sub('gw+d','have',origin,3)
     6 print(res)
     7 res = re.subn('gw+d','have',origin)
     8 print(res)
     9 
    10 #结果如下
    11 
    12 haveay,havebye,have morning,oh my have
    13 haveay,havebye,have morning,oh my god
    14 ('haveay,havebye,have morning,oh my have', 4)

      re.split(pattern,string,maxsplit,flag) 按规则分割字符串

        ①分割规则里不包含组,那么分割出的结果里不包含分割规则 ②分割规则里包含组,那么分割出来的结果会包含组内容 ③如果分割规则处在string末尾或开始,那么会包含空内容成为元素

     1 import re
     2 origin = 'one1two2three3'
     3 res = re.split('d+',origin)
     4 print(res)
     5 
     6 stri = 'nice to meet you ethan,but goodbye now'
     7 res = re.split('e(w+)an',stri)
     8 print(res)
     9 res = re.split('ethan',stri)
    10 print(res)
    11 
    12 #结果如下
    13 
    14 ['one', 'two', 'three', '']
    15 ['nice to meet you ', 'th', ',but goodbye now']
    16 ['nice to meet you ', ',but goodbye now']

      re.compile(pattern,flags) 将规则编译到obj里,下次再使用此规则时直接调用obj的方法,适用于重复多次使用的规则

     1 import re
     2 obj = re.compile('e(w+)n')
     3 origin = 'nice to see you ethan,but byebye now'
     4 res = obj.findall(origin)
     5 print(res)
     6 res = obj.split(origin)
     7 print(res)
     8 
     9 #结果如下
    10 
    11 ['tha']
    12 ['nice to see you ', 'tha', ',but byebye now']

      re.finditer(pattern,string,flags) 生成迭代对象,需要进行for循环,才能得到对象,需要对象的.group(),.groups(),.groupdict()的方法得到具体值

     1 import re
     2 rigin = 'alex,goodday'
     3 res = re.finditer('a(w*)(?P<key1>x)',origin)
     4 print(res)
     5 for i in res:
     6     print(i,i.group(),i.groups(),i.groupdict())
     7 
     8 # 结果如下
     9 <callable_iterator object at 0x000000DA49F7CB38>
    10 <_sre.SRE_Match object; span=(0, 4), match='alex'> alex ('le', 'x') {'key1': 'x'}

    三、贪婪模式与非贪婪模式
      默认情况下,所有匹配均为贪婪模式,除非对匹配方式进行了设置,例如

     1 import re
     2 origin = 'a23018319cdnk'
     3 res = re.search('a(d+)',origin).group()
     4 print(res)
     5 res = re.search('a(d+?)',origin).group()
     6 print(res)
     7 
     8 #显示结果如下
     9 a23018319
    10 a2

      但是在组两边都有限制条件的时候,非贪婪模式也会失效,例如

    import re
    res = re.search('a(d+?)',origin).group()
    print(res)
    res = re.search('a(d+?)c',origin).group()
    print(res)
    
    #结果如下
    
    a2
    a23018319c

    四、原生字符r ,使用时表示在python中存在特殊意义的字符,失去特殊意义,只体现其普通意义,而re模块中的则不受影响 

  • 相关阅读:
    io学习
    asp.net文件上传进度条研究
    asp.net页面中的Console.WriteLine结果如何查看
    谨慎跟随初始目的不被关联问题带偏
    android 按钮特效 波纹 Android button effects ripple
    安卓工作室 日志设置
    安卓工作室 文件浏览器 android studio File browser
    一个新的Android Studio 2.3.3可以在稳定的频道中使用。A new Android Studio 2.3.3 is available in the stable channel.
    新巴巴运动网上商城 项目 快速搭建 教程 The new babar sports online mall project quickly builds a tutorial
    码云,git使用 教程-便签
  • 原文地址:https://www.cnblogs.com/ethancui/p/5582446.html
Copyright © 2011-2022 走看看