美文网首页
day17-正则表达式

day17-正则表达式

作者: 2333_11f6 | 来源:发表于2018-11-27 17:28 被阅读0次

    17.1 正则基本符号

    • 1.什么是正则表达式

    正则表达式就是字符匹配的工具,用来做正则匹配;是由正则符号和普通字符组成,来匹配不同规律的字符串。

    • 2.python对正则表达式的支持

    python中提供了一个re模块,用来支持正则表达式。

    fullmatch(正则表达式,字符串) - 用正则表达式去完全匹配字符串,如果匹配成功返回一个结果,失败返回None。

    python中的正则表达式的写法:将正则内容写在字符串中,一般这个字符串的最前面会加r或R用来阻止转义。

    import re
    
    str1 = 'dhsuwqy82r21r372cuefy12fgy1983r1y283781382g1f382321382r3g21'
    str2 = '18408266183'
    str3 = 'zh@qq.com'
    

    1.普通字符
    普通字符在正则表达式中,代表字符本身。

    # 匹配一个字符串,第一个字符是a,第二个字符是b,第三个字符也是最后一个字符是c。
    re_str = r'abc'
    result = re.fullmatch(re_str, 'abc')
    print(result)            # <_sre.SRE_Match object; span=(0, 3), match='abc'>
    
    result1 = re.fullmatch(re_str, 'abcd')
    print(result1)           # None
    
    1. . 匹配任意字符
      在正则表达式中,. 出现的位置可以匹配一个任意字符(char)
      注意:一个.只能匹配一个字符
    # 匹配一个长度为3的字符串。且第一个字符是a,最后一个字符是c,中间一个字符是任意一个字符。
    re_str = r'a.c'
    result = re.fullmatch(re_str, 'a$c')
    print(result)           # <_sre.SRE_Match object; span=(0, 3), match='a%c'>
    
    1. \w 匹配字母数字或下划线的符号
      在正则表达式中,\w出现的位置,可以匹配一个任意的字母数字或下划线的符号(其实也可以匹配Unicode编码中除了Ascii码剩下的部分。)
      中文也能匹配
    # 匹配一个长度是5的字符串,并且字符串前两位是任意的字母数字或下划线符号,后3位是任意字符
    re_str = r'\w\w...'
    result = re.fullmatch(re_str, '小白a$c')
    print(result)          # <_sre.SRE_Match object; span=(0, 5), match='小白a$c'>
    
    1. \s 匹配一个空白字符
      空白字符:包括空格、制表符、换行符(空格,\t,\r,\n)
    # 匹配一个长度是4的字符串,并且前两位是字母数字下划线或中文,中间一个空白符,最后
    # 以一个字母数字下划线或中文结尾。
    re_str = r'\w\w\s\w'
    result = re.fullmatch(re_str, '小白\ne')
    print(result)         # <_sre.SRE_Match object; span=(0, 4), match='小白\ne'>
    
    1. \d 匹配数字字符
    # 匹配一个长度是5的字符串,字符串的前三位是数字字符,后两位是任意字符
    re_str = r'\d\d\d..'
    result = re.fullmatch(re_str, '123小白')
    print(result)            # <_sre.SRE_Match object; span=(0, 5), match='123小白'>
    
    1. \b 检测单词边界
      注意:\b位置不会被用于匹配,只是检测该位置是否是单词边界,不会对字符进行匹配,不会记入字符串长度。当正则表达式中出现了\b,匹配时去掉\b匹配成功后再看\b出现的位置是否是单词边界。

    单词边界:字符串开头、字符串结尾、标点符号、空白符号等只要能将单词区分开的符号都属于单词边界。
    匹配前先把\b去掉,再去匹配,匹配时再找满足条件的。

    # 下句既要求helloworld又要求两单词分开
    re_str = r'hello\bworld'  # 没有任何一个字符串能和它匹配
    
    
    re_str1 = r'\bhello,\bworld'  # 没有任何一个字符串能和它匹配
    result = re.fullmatch(re_str1, 'hello,world')
    print(result)    # <_sre.SRE_Match object; span=(0, 11), match='hello,world'>
    
    1. ^ 检测字符串开头
      在math和fullmatch中没有意义,在search、findall等中有意义。
    # 匹配一个字符串前3个是The,后面俩个是任意字符
    re_str = r'^The..'
    result = re.fullmatch(re_str, 'The')
    print(result)
    
    1. $ 检测字符串结尾
      在math和fullmatch中没有意义,在search、findall等中有意义。
    # 匹配一个字符串只要3位,分别是The,并且e后结尾。所以在这无意义
    re_str = r'^The$'
    result = re.fullmatch(re_str, 'The')
    print(result)         # <_sre.SRE_Match object; span=(0, 3), match='The'>
    
    1. \W 匹配一个非字母数字下划线中文的字符
      \大写字母 对应的功能是 \小写字母 功能取反
      \W 匹配一个非字母数字下划线中文的字符
      \D 匹配一个非数字字符
      \S 匹配一个非空白字符
      \B 检测非单词边界
    # 匹配一个字符串,第一个是数字,第二个非数字,第三个是空白,第四个是数字字母下划线,最后
    # 一个是a,并且要求最后一个a前不是单词边界。
    re_str = r'\d\D\s\w\Ba'
    result = re.fullmatch(re_str, '9H\tAa')
    print(result)     # <_sre.SRE_Match object; span=(0, 5), match='9H\tAa'>
    
    1. [字符集] 匹配中括号中出现的任意一个字符
    1. [普通字符集] 匹配中括号中出现的任意一个字符
      [abc] - 匹配一个字符是a或b或c

    注意:
    a.一个中括号只能匹配一个字符
    b.正则中有特殊功能的单个符号例如:. $ ^ + * ? | 等。
    c.匹配字符的组合符号在中括号中保持原来的功能:如\w \d \s \W \D \S

    # 匹配一个长度是2的字符串,第一个字符是数字,第二个字符是b或c或d
    re_str = r'\d[bcd\d]'
    result = re.fullmatch(re_str, '22')
    print(result)      # <_sre.SRE_Match object; span=(0, 2), match='22'>
    

    2.[字符1-字符2] - 表示字符1到字符2(注意:要求字符1的编码值要小于字符2)

    [a-z] - 表示匹配所有的小写字母
    [A-Z] - 表示匹配所有的大写字母
    [a-zA-Z] - 表示匹配所有的字母

    [1-7] - 表示数字字符1到7
    [\u4e00-\u9fa5] - 匹配所有的中文

    [字符1字符2-] - 这儿的-表示减号本身

    # 匹配一个长度是3的字符串,第一个字符是数字字符1到7的一个,第二个字符是a、b、c、-
    # 中的一个,第三个是小写字母
    re_str = r'[1-7][abc-][a-z]'
    result = re.fullmatch(re_str, '3-z')
    print(result)      # <_sre.SRE_Match object; span=(0, 3), match='3-z'>
    
    1. [^字符集] 匹配不在字符集中的任何一个字符,^ 要放在字符集前

    [^abc] - 匹配除了abc以外的任意一个字符
    [^\d] - 匹配除了数字字符以外的任意一个字符
    [^a-z] - 匹配除了小写字母以外的任意一个字符

    [abc^d] - 匹配abcd或^中的任意一个字符。

    re_str = r'[^abc]'
    result = re.fullmatch(re_str, '3')
    print(result)      # <_sre.SRE_Match object; span=(0, 1), match='3'>
    

    17.2 正则控制匹配次数

    import re
    
    1. * 匹配0次或多次
      a* - a连续出现0次或多次;'','a','aaa', ' '
      \d* - 任意数字连续出现0次或多次。'','1','12','245432542354'都可以匹配
      [abc]* - a或b或c连续出现0次或多次。
      [A-F]* - A到F中任意字符出现0次或多次。

    注意:在[]外面的*的前面需要一个字符或者一个匹配字符的符号

    # <_sre.SRE_Match object; span=(0, 10), match='aaaaaaaaab'>
    print(re.fullmatch(r'a*b', 'aaaaaaaaab'))
    
    1. + 至少匹配1次

    a+ - a至少匹配一次
    \d+ - 数字至少1次

    print(re.fullmatch(r'a+b', 'aaab'))
    # <_sre.SRE_Match object; span=(0, 4), match='aaab'>
    
    1. ? 出现0次或1次

    a? - a出现0次或1次,''和'a'可以匹配

    # 写一个正则匹配一个整数(正负整数都行), 123 10 +100 -100
    re_str = r'[+-]?[1-9]\d*'
    print(re.fullmatch(re_str, '-100'))
    
    1. {}

    {N} - 匹配N次,如a{3} - 匹配3个’a‘
    {M,N} - 匹配M到N次,如a{3,5} - 'aaa' 'aaaa' 'aaaaa'
    {,N} - 最多匹配N次,即0到N次。如a{,3} - '','a','aa','aaa'
    {M,} - 至少匹配M次,如a{3,} - 'aaa','aaaa'...

    print(re.fullmatch(r'a{,3}', ' '))
    
    # 密码由字母数字组成数字不开头,6-12位,给出提示
    password = input('密码:')
    re_str = r'[a-zA-Z]{1}[a-zA-Z0-9]{5, 11}'
    re_str = r'[a-zA-Z][a-zA-Z0-9]{5, 11}'
    if not re.fullmatch(re_str, password):
        print('错误。')
    

    17.3 分支、捕获和贪婪

    import re
    

    1.分支
    条件1 | 条件2 - 匹配条件1或者条件2
    \d{2} | [a-z] - 匹配俩个数字字符,或者一个小写字母
    a\d{2}|\w{2} - 匹配1个a后面2个数字,或者两个数字字母下划线。

    注意:正则中分支也会短路,当条件1可以匹配,就不会再使用条件2匹配

    # <_sre.SRE_Match object; span=(0, 2), match='33'>
    print(re.fullmatch(r'\d{2}|[a-z]', '33'))
    
    # <_sre.SRE_Match object; span=(0, 1), match='a'>
    print(re.fullmatch(r'\d{2}|[a-z]', 'a'))
    
    # <_sre.SRE_Match object; span=(0, 3), match='a33'>
    print(re.fullmatch(r'a\d{2}|\w{2}', 'a33'))
    # <_sre.SRE_Match object; span=(0, 2), match='a3'>
    print(re.fullmatch(r'a\d{2}|\w{2}', 'a3'))
    
    # 匹配所有的数字 100 -100 12.5 -12.5 0 0.012
    """
    12,12.34
    0.123
    0
    """
    re_str = r'[+-]?[1-9][0-9]*|[+-]?[0-9]*[.][0-9]*|0'
    # re_str = r'[+-]?[1-9][0-9]*[.]?\d*|[+-]?0[.]?[0-9]+|0'  老师
    print(re.fullmatch(re_str, '-12.5'))
    print(re.fullmatch(re_str, '-0.5989'))
    print(re.fullmatch(re_str, '0123'))
    print(re.fullmatch(re_str, '123'))
    print(re.fullmatch(re_str, '+123'))
    print(re.fullmatch(re_str, '0.012'))
    print(re.fullmatch(re_str, '+0.012'))
    print(re.fullmatch(re_str, '-0.012'))
    print(re.fullmatch(re_str, '0'))
    print(re.fullmatch(re_str, '-0.3'))
    

    2.捕获和分组

    a.分组 - 将括号中的内容作为一个整体
    r'abc\d{3}|abc[A-Z]{3}' = r'abc(\d{3}|[A-Z]{3})'

    # 匹配一个字符串,前3位是abc,后3位是数字或者大写字母
    # r'abc\d{3}|abc[A-Z]{3}' = r'abc(\d{3}|[A-Z]{3})'
    
    # 匹配一个字符串,以‘数字小写字母’的形式出现3次
    re_str = r'(\d[a-z]){3}'
    # <_sre.SRE_Match object; span=(0, 6), match='1a2s3d'>
    print(re.fullmatch(re_str, '1a2s3d'))
    

    b.捕获
    通过正则获取符合条件的子串时,可以在正则表达式中加括号,匹配后只获取括号里面匹配到的内容。例1:
    re.findall(正则表达式,字符串) - 在字符串中去获取符合正则表达式条件的所有子串,返回一个列表。

    str1 = '32e23i1hr32hru392r3hu21re3u21hre32h1iufe3h2r'
    # ['32', '23', '1', '32', '392', '3', '21', '3', '21', '32', '1', '3', '2']
    print(re.findall(r'\d+', str1))
    
    # 例1:
    # ['e23', 'e3', 'e32', 'e3']
    print(re.findall(r'e\d+', str1))
    # ['23', '3', '32', '3']
    print(re.findall(r'e(\d+)', str1))
    

    c.重复匹配
    写一个带多个分组的正则表达式,可以在分组后面通过添加 \数字 来重复前面第几个分组中匹配到的内容。

    说明:\数字 - 这里的数字代表前面第几个分组;\1代表第一个分组,\2代表第2个组

    re_str = r'\d{3}([a-z]{2})a\1'
    # <_sre.SRE_Match object; span=(0, 8), match='222sdasd'>
    print(re.fullmatch(re_str, '222sdasd'))
    
    re_str = r'(\d{3})([a-z]{2})a\1\2'
    print(re.fullmatch(re_str, '222sda222sd'))
    

    3.贪婪
    匹配次数后加?就是贪婪匹配:*? +? ?? {M,N}? {M,}? 表示尽可能少的重复

    re_str = r'a.+b'
    str1 = 'xxxahdjbnnkbsssammmb'
    print(re.findall(re_str, str1))  # ['ahdjbnnkbsssammmb']
    
    re_str = r'a.+?b'
    print(re.findall(re_str, str1))  # ['ahdjb', 'ammmb']
    
    1. 转义字符
      在正则表达式中可以在有特殊意义或者特殊功能的符号前加\来取消其特殊功能

    \w - 代表两个字符分别为反斜杠和w
    + - 代表加号字符
    * - 代表*
    ? - 代表?
    () - 表示(),类推[]及{}

    注意:
    在中括号中,\必须加\表示反斜杠本身。
    ^在最前面时,必须加\表示^本身
    -在两个字符之间并在中括号里面时,必须加\表示-本身

    re_str = r'\w-\d{3}'
    

    17.4 re模块

    import re
    

    1.compile
    compile(正则表达式) - 将正则表达式转换成正则表达式对象

    re_str = r'\d{3}'
    re_obj = re.compile(re_str)
    
    # 调用模块中函数
    print(re.fullmatch(re_str, '338'))
    
    # 调用对象方法
    print(re_obj.fullmatch('338'))
    

    2.match和fullmatch

    a.fullmattch(正则表达式,字符串) - 完全匹配,从字符串开头一直到结尾
    b.mattch(正则表达式,字符串) - 不完全匹配,只匹配字符串开头。

    re_str = r'\d[A-Z]{2}'
    
    # 完全匹配 <_sre.SRE_Match object; span=(0, 3), match='6AD'>
    print(re.fullmatch(re_str, '6AD'))
    
    # 不完全匹配 <_sre.SRE_Match object; span=(0, 3), match='6AD'>
    print(re.match(re_str, '6AD2签位尔特3ytuytjytj'))
    

    匹配对象
    1.获取span - 匹配到内容在字符串中的范围(开始下标,结束下标),结束下标取不到
    匹配对象.span() - 获取整个正则表达式匹配到的范围
    匹配对象.span(n) - 获取正则表达式中第n个分组匹配到的范围,前提是有分组。

    # (0, 3)
    print(re.match(re_str, '6AD2签位尔特3ytuytjytj').span())
    
    # (0, 1)
    print(re.match(r'(\d)[A-Z]{2}', '6AD2签位尔特3ytuytjytj').span(1))
    
    # (1,3)
    print(re.match(r'(\d)([A-Z]{2})', '6AD2签位尔特3ytuytjytj').span(2))
    

    2.start和end - 获取匹配结果的开始下标和结束下标。
    匹配对象.start()/匹配对象.end() - 获取整个正则表达式匹配到的的开始下标和结束下标。
    匹配对象.start(n)/匹配对象.end(n) - 获取整个正则表达式第n个分组,匹配到的的开始下标和结束下标。

    3.group - 获取匹配到的内容
    匹配对象.group() - 获取整个正则表达式匹配到的内容
    匹配对象.group(n) - 获取正则表达式第n个分组匹配到的内容

    4.string - 获取用来匹配的原字符串
    匹配对象.string()

    3.search
    search(正则表达式,字符串) - 匹配字符串中第一个满足正则表达式的子串,如果匹配成功,返回匹配对象,否则返回None

    str1 = r'abc123hkcajsa121df'
    result = re.search(r'\d{3}[a-z]{2}', str1)
    print(result)  # <_sre.SRE_Match object; span=(3, 8), match='123hk'>
    

    4.spilt
    split(正则表达式,字符串) - 在字符串中按照满足正则表达式条件的子串对字符串进行切割。返回一个列表

    str1 = 'ab+c7wewfwefewff79wfqe9fwq9qw0e*f'
    
    # ['ab+c', 'wewfwefewff', 'wfqe', 'fwq', 'qw', 'e*f']
    print(re.split(r'\d+', str1))
    
    # ['ab', 'c', 'wewfwefewff', 'wfqe', 'fwq', 'qw', 'e', 'f']
    print(re.split(r'\d+|[+*-]+', str1))
    

    5.sub
    sub(正则表达式,新子串,字符串) - 用新子串替换字符串中满足正则表达式的子串,返回一个替换后的字符串

    str1 = 'i32h1e32jirh32iu1ej321eji'
    print(re.sub(r'\d+', '$', str1))  # i$h$e$jirh$iu$ej$eji
    

    6.findall
    findall(正则表达式,字符串) - 在字符串中获取满足正则表达式的所有的字符,返回一个列表,列表元素就是字符串。

    注意:如果此处正则表达式中有一个分组,结果是列表中只取括号中匹配到的字符串,如果分组大于1,结果是一个列表,列表元素是元组,元组中元素为每个括号中匹配到的字符串。(先匹配整个再取括号中内容!)

    str1 = 'sdad434w2rsdvsvds34==='
    print(re.findall(r'\d+', str1))  # ['434', '2', '34']
    
    str1 = 'sdad434w2rsdvsvds34==='
    print(re.findall(r'(\d+)(\w)', str1))  
    # [('434', 'w'), ('2', 'r'), ('3', '4')]
    

    7.finditer
    finditer(正则表达式,字符串) - 在字符串中获取满足正则表达式的内容,返回一个迭代器,迭代器元素是匹配对象。

    str1 = 'sdad434w2rsdvsvds34==='
    print(re.finditer(r'\d+', str1))
    
    # 写一个自己的finditer
    
    
    def my_finditer(pattern, string):
        re1 = re.search(pattern, string)
        while re1:
            yield re1
            string = string[re1.end():]
            # 考虑对正则取反(think)
            re1 = re.search(pattern, string)
    

    相关文章

      网友评论

          本文标题:day17-正则表达式

          本文链接:https://www.haomeiwen.com/subject/clcnqqtx.html