day15正则表达式

正则表达式的符号

正则表达式：用来做字符串查找、匹配、切割用的一种工具

python对正则表达式的支持：提供了re模块（python内置的模块）,包含字符串匹配、查找、切割等相关的方法

fllmatch(正则表达式，字符串)：用正则表达式和字符串进行匹配，看是否能够匹配成功
正则表达式：是一个符合正则规范的字符串

import re

if __name__ == '__main__':
    # 注意：正则表达式的字符串，前面一般要加r来阻止转义。
    # 因为正则表达式的符号中有很多到'\'的符号，其功能不是转义，而是表示特殊的意义。

1. .：匹配一个任意的字符

    re_str ='.'
    print(re.fullmatch(re_str, 'a')) 
    # <_sre.SRE_Match object; span=(0, 1), match='a'>
    print(re.fullmatch(re_str,'ab'))
    # None
    """匹配两个任意字符的字符串"""
    # re_str = '..'
    """匹配第一个字符是a，第二个字符是b的字符串"""
    re_str = 'ab'
    print(re.fullmatch(re_str,'ab')) 
    # <_sre.SRE_Match object; span=(0, 2), match='ab'>
    """匹配第一个字符是a,第二个字符是任意字符的字符串"""
    re_str=r'a.'
    print(re.fullmatch(re_str,'ab')) 
    # <_sre.SRE_Match object; span=(0, 2), match='ab'>

2. \w:匹配一个字符是字母、数字或者下划线

    re_str = r'\w'
    print(re.fullmatch(re_str, '@')) 
    # None
    print(re.fullmatch(re_str, 'a')) 
    # <_sre.SRE_Match object; span=(0, 1), match='a'>
    print(re.fullmatch(re_str, 'ab')) 
    # None
    """匹配第一个字符是字母、数字或下划线，第二个字符是字母、数字或下划线的字符串"""
    re_str = r'\w\w'
    print(re.fullmatch(re_str,'ab')) 
    # <_sre.SRE_Match object; span=(0, 2), match='ab'>

    re_str = r'\w.\w'
    print(re.fullmatch(re_str,'u(9')) 
    # <_sre.SRE_Match object; span=(0, 3), match='u(9'>

3. \s 匹配一个空白字符（空格，换行，制表符）

    """匹配第一个字符是a，第二个字符是空白，最后一个字符是b的字符串"""
    re_str = 'a\sb'
    print(re.fullmatch(re_str,'a b')) 
    # <_sre.SRE_Match object; span=(0, 3), match='a b'>
    print(re.fullmatch(re_str, 'a\tb')) 
    # <_sre.SRE_Match object; span=(0, 3), match='a\tb'>
    print(re.fullmatch(re_str, 'a\nb')) 
    # <_sre.SRE_Match object; span=(0, 3), match='a\nb'>

4. \d匹配一个数字字符

    re_str = r'\d\d\d'
    print(re.fullmatch(re_str, '123')) # <_sre.SRE_Match object; span=(0, 3), match='123'>
    print(re.fullmatch(re_str, '1b3')) # None

    """匹配第一个字符是0，后面两个字符是数字的字符串"""
    re_str = r'0\d\d'

fullmatch 完全匹配

    print(re.fullmatch(re_str,'019')) 
    # <_sre.SRE_Match object; span=(0, 3), match='019'>

match 部分匹配

    print(re.match(re_str, '0190'))  
    # <_sre.SRE_Match object; span=(0, 3), match='019'>

5. \b 检测边界（单词边界 -- 一般的符号都可以作为单词边界）

边界：是单词的边界，边界可以是空格、逗号、问号都可以是边界，数字、字母不行。

    """三个任意字符的前面和后面都是边界的字符串"""
    re_str = r'\b...\b'
    print(re.match(re_str,'jsh')) 
    # <_sre.SRE_Match object; span=(0, 3), match='jsh'>
    print(re.match(re_str, 'jsh   ')) 
    # <_sre.SRE_Match object; span=(0, 3), match='jsh'>
    print(re.match(re_str, 'jsh,,,abc')) 
    # <_sre.SRE_Match object; span=(0, 3), match='jsh'>
    print(re.match(re_str, 'jshb')) 
    # None

6. ^{检测字符串开始（}The --> 匹配以The开头的字符串）

    re_str = r'^The'
    print(re.fullmatch(re_str,'The'))
    print(re.findall(r'The','abc hThekl')) # ['The']
    print(re.findall(r'^The', 'abc hThekl')) # []
    print(re.findall(r'^The', 'The abc hThekl')) # ['The']

7.$ 检测字符串结束

    re_str = r'abc$'
    print(re.findall(re_str,'hah abc')) 
    # ['abc']
    print(re.findall(re_str, 'hah abc-')) 
    # []
    print(re.findall(re_str, 'hah abc   ')) 
    # []

8. \W 匹配非字母、数字、下划线

    """匹配第一个字符是非字母、数字、下划线的字符，第二个字符是字母、数字、下划线的字符串"""
    re_str = r'\W\w'
    print(re.fullmatch(re_str,'&k')) 
    # <_sre.SRE_Match object; span=(0, 2), match='&k'>

9. \S 匹配非空白字符

   re_str = r'\S\d'
   print(re.fullmatch(re_str,'p8')) 
   # <_sre.SRE_Match object; span=(0, 2), match='p8'>

10. \D 匹配非数字字符

    """匹配第一个字符是非数字字符，第二个字符是字母、数字、下划线"""
    re_str = r'\D\w'

11. \B 检测非边界

    """匹配前面两个字符是a和b,第三个字符是c。并且检测b的后面是一个非边界"""
    re_str = r'ab\Bc'
    print(re.fullmatch(re_str, 'abc'))  
    # <_sre.SRE_Match object; span=(0, 3), match='abc'>
    print(re.match(re_str, 'abc0'))  
    # <_sre.SRE_Match object; span=(0, 3), match='abc'>

正则表达式符号组合

import re

if __name__ == '__main__':

1.[]匹配[]中出现的任意'一个字符'

    """匹配一个字符串，前三位是abc，第四位是字符1或者字符a"""
    re_str = r'abc[1a]'
    print(re.fullmatch(re_str, 'abca')) 
    # <_sre.SRE_Match object; span=(0, 4), match='abca'>
    print(re.fullmatch(re_str, 'abc1')) 
    # <_sre.SRE_Match object; span=(0, 4), match='abc1'>
    print(re.fullmatch(re_str,'abc1a')) 
    # None

    """第一位是数字或者下划线，后面是abc"""
    re_str = r'[\d_]abc'
    print(re.fullmatch(re_str,'1abc')) 
    # <_sre.SRE_Match object; span=(0, 4), match='1abc'>
    print(re.fullmatch(re_str, '_abc')) 
    # <_sre.SRE_Match object; span=(0, 4), match='_abc'>
    print(re.fullmatch(re_str, 'aabc')) 
    # None

2.[^]匹配不在[]出现的任意一个字符

    """匹配一个字符串，前三位是abc，第四位不是数字字符也不是字符a"""
    re_str = r'abc[^\da]'
    print(re.fullmatch(re_str,'abc1')) 
    # None
    print(re.fullmatch(re_str, 'abca')) 
    # None
    print(re.fullmatch(re_str, 'abcw')) 
    # <_sre.SRE_Match object; span=(0, 4), match='abcw'>

3. * 匹配0次或者多次

    """匹配一个字符串，前面是0个或者多个数字字符，然后是abc"""
    re_str = r'\d*abc'
    print(re.fullmatch(re_str,'abc')) 
    # <_sre.SRE_Match object; span=(0, 3), match='abc'>
    print(re.fullmatch(re_str, '1abc')) 
    # <_sre.SRE_Match object; span=(0, 4), match='1abc'>
    print(re.fullmatch(re_str, '321abc')) 
    # <_sre.SRE_Match object; span=(0, 6), match='321abc'>
    print(re.fullmatch(re_str,'12a34abc')) 
    # None

[0-9]:匹配0，1，2，3，4，5，6，7，8，9中的任意一个字符
[1-8]:匹配1，2，3，4，5，6，7，8
[a-z]:匹配任意一个小写字母
[A-Z]:匹配任意一个大写字母
[a-zA-Z]:匹配所有的字母

    print(re.fullmatch(r'[0-9]','8')) 
    # <_sre.SRE_Match object; span=(0, 1), match='8'>
    print(re.fullmatch(r'[1-9]', '0')) 
    # None

写一个正则表达式，判断一个字符串是数字字符串{不能空串}

    re_str = r'\d\d*'
    re_str = r'[0-9][0-9]*'

写一个正则表达式，检测一个字符串是否是合格的标识符（字母、数字、下划线组成，数字不能开头）

    re_str = r'[a-zA-Z_]\w*'

4. +:匹配一次或者多次

    """匹配一个字符串开头出现一次或者多个数字字符，然后再有0次或者多次数字、字母、下划线"""
    re_str = r'\d+\w*'

5. ?:匹配0次或者1次

    re_str = r'[a-z]?123'

判断一个字符串是否是正整数字符串(除0开头)

    re_str = r'[+]?[1-9][0-9]*'
    print(re.fullmatch(re_str,'+120'))

6. {N}:匹配N次

    """前面5个数字，然后是abc"""
    re_str = r'\d{5}abc'
    """前面3位是12ab中任意数字，然后是abc"""
    re_str = r'[12ab]{3}abc'
    print(re.fullmatch(re_str,'aaaabc')) 
    # <_sre.SRE_Match object; span=(0, 6), match='aaaabc'>
    print(re.fullmatch(re_str, '21babc')) 
    # <_sre.SRE_Match object; span=(0, 6), match='21babc'>

6. {N,}:匹配大于等于N次

    """字符串前面至少三位数字，后面多少随意"""
    re_str = r'\d{3,}.*'

7. {M,N}:匹配至少M次最多N次

    """密码要求：数字、字母组成8-16位"""
    re_str = r'[\da-zA-Z]{8-16}'

8. | 分之

    """匹配一个字符串，是三个数字字符或者是三个小写字符"""
    re_str = r'\d{3}|[a-z]{3}'
    print(re.fullmatch(re_str,'wba'))

9.()匹配的时候是分组，让括号中的正则条件变成一个整体

    """匹配一个字符串，abc整体重复三次"""
    re_str=r'(abc){3}'
    print(re.fullmatch(re_str,('abcabcabc')))

    re_str=r'(\d\w[0-3]){2}'
    print(re.fullmatch(re_str,('3a3'))) 
    # None
    print(re.fullmatch(re_str, ('3a37b1'))) 
    # <_sre.SRE_Match object; span=(0, 6), match='3a37b1'>

    """了解"""
    # 尽可能少：在能够匹配到的前提下尽可能少
    # 10. *? :重复任意次，尽可能少的重复
    re_str = r'ba*?b'
    print(re.match(re_str,'baaaaab')) 
    # <_sre.SRE_Match object; span=(0, 7), match='baaaaab'>

    # 11. +?:重复一次或多次，尽可能少的重复
    re_str = r'ba+?'
    print(re.match(re_str,'baaaa')) 
    # <_sre.SRE_Match object; span=(0, 2), match='ba'>

    # 12. ??重复0次或者1次，尽可能的少重复
    re_str = r'b??'

    # 13. {N,}? 重复至少N次，尽可能少的重复
    # 14. {N,M}? 重复N到M次，尽可能少的重复

正则表达式

1.特殊符号转义

正则中：. \ [] {} () * + ? | $ ^ 这些字符有特殊意义，所以在正则表达式中，
如果想要单纯表达这些字符，需要在前面加''

注意：1. - ,[],^,\在[]中能是特殊的符号,需要加
2. .{} () * + ? $ | 在中括号中可以不用加\，来表示字符

import re

if __name__ == '__main__':
    re_str = r'\d+.\d'
    print(re.fullmatch(re_str,'1299')) 
    # <_sre.SRE_Match object; span=(0, 4), match='1299'>
    print(re.fullmatch(re_str,'12.9')) 
    # <_sre.SRE_Match object; span=(0, 4), match='12.9'>

    re_str = r'\d+\.\d'
    print(re.fullmatch(re_str, '1299')) 
    # None
    print(re.fullmatch(re_str,'12.9')) 
    # <_sre.SRE_Match object; span=(0, 4), match='12.9'>

\N ---> 匹配前面第N个组中匹配到的内容

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

re模块方法

import re

if __name__ == '__main__':

1.compile（正则字符串）将正则表达式字符串转换成正则表达式对象

转换成正则表达式对象后，可以通过对象用相关的方法

    re_object = re.compile(r'\w{6,12}')
    print(re_object.fullmatch('ahjhhs')) 
    # <_sre.SRE_Match object; span=(0, 6), match='ahjhhs'>

    print(re.fullmatch(r'\w{6,12}','ahjhhs')) 
    # <_sre.SRE_Match object; span=(0, 6), match='ahjhhs'>

2.fullmatch(正则表达式，字符串) 完全匹配，从字符串开头匹配到结尾

    # 返回值是匹配对象,如果匹配失败返回None
    match = re.fullmatch('\w{3}','hks')
    print(match)
    # a.获取匹配到的结果
    print(match.group()) # hks
    # b.获取匹配到范围
    print(match.span()) # (0, 3)
    # c.获取匹配到的开始下标和结束下标
    print(match.start(),match.end()) # 0 3
    # d.获取被匹配的字符串（原字符串）
    print(match.string) # hks
    # 应用：判断一个字符串是否是某种字符串（判断账号、密码是否符合要求等）

3.match(正则表达式，字符串)不完全匹配，从字符串开头开始匹配，匹配到正则表达式对应的范围为止

    # 返回值是匹配对象,如果匹配失败返回None
    match = re.match(r'\w{3}','h3shhhhsbs')
    print(match)
    print(match.group()) # h3s
    print(match.string) # h3shhhhsbs
    # 应用：判断一个字符串是否以某种字符串开头

4.search(正则表达式，字符串)在指定的字符串中查找某种字符串（以正则表达式来描述）,如果有多个满足条件的，只匹配第一个

    # 返回值是匹配对象，如果找不到要求的返回None
    print(re.search(r'\d{2,}[a-z]','sha23n--877m0899'))
    # 应用：判断一个字符串中是否包含某种字符串

5.findall(正则表达式，字符串)去获取指定字符串中满足正则条件的所有的子串

    # 返回值是列表，列表中是符合要求的字符串.没有满足要求的子串就返回[]
    result = re.findall(r'[a-zA-Z](\d+)','12a123buy=236ok98s')
    print(result) # ['123', '98']
    # 注意：在通过正则表达式获取子串的时候，可以通过在正则表达式中添加括号，来约束获取的内容（值获取括号的匹配到的内容）
    #       匹配的时候还是按原正则表达式去查找
    # 应用：字符串提取

6.finditer(正则表达式，字符串)用法的findall一样，只是返回值的类型不一样

    # 返回一个迭代器，迭代器中的内容是匹配对象
    # 注意：（）语法捕获部分无效
    result = re.finditer(r'[a-zA-Z](\d+)','12a123buy=236ok98s')
    for match in result:
        print(match)
        #<_sre.SRE_Match object; span=(2, 6), match='a123'>
        #<_sre.SRE_Match object; span=(14, 17), match='k98'>

7.split(正则表达式，字符串)按正则表达式匹配到的字符串进行切割

    # 返回值是列表，列表元素就切割后被分段的字符串
    result = re.split(r'\d+','ahsj27jk1kaj8js00jsj')
    print(result) # ['ahsj', 'jk', 'kaj', 'js', 'jsj']
    # print('ahsj27jkkajjsjsj'.split('sj')) # ['ah', '27jkkajj', '', '']

8.sub(要替换的字符串，替换后的字符串，原字符串变量名（或原字符串）) 在原字符串中查找符合正则的子串，替换成新的字符串

    # 返回值是替换后的字符串
    """将指定字符串中所有'sb'替换成*"""
    str1 = '你好sb,你全家都是sb，大，傻，叉!'
    result = re.sub(r'sb|傻|叉','*',str1)
    print(str1)
    print(result)