August 3-day 16-Python正则表达式

正则表达式的符号

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

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

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

import re

if __name__ == '__main__':
    # 注意：正则表达式的字符串，前面一般要加r来阻止转义。
    # 因为正则表达式的符号中有很多带‘\’的符号，其功能不是转义，而是表示特殊的意义
    # 1. .：匹配一个任意的字符
    """匹配两个任意字符的字符串"""
    re_str = r'..'
    """匹配第一个字符是a第二个字符是b的字符串"""
    re_str = r'ab'
    """匹配第一个字符是a第二个字符是任意字符的字符串"""
    re_str = r'a.'
    print(re.fullmatch(re_str,'ah'))

    # 2. \w 匹配字母、数组、下划线
    re_str = r'\w\w\w'
    print(re.fullmatch(re_str, '_4d'))

    # 3. \s 匹配一个空白字符（空格、换行、制表符）
    """匹配第一个字符是a，第二个字符是空白，最后一个字符是b的字符串"""
    re_str = r'a\sb'
    print(re.fullmatch(re_str,'a\nb'))

    # 4. \d 匹配一个数字字符
    re_str = r'\d\d\d'
    print(re.fullmatch(re_str, '120'))

    """匹配第一个字符是0，后面两个字符都是数字的字符串"""
    re_str = r'0\d\d'
    print(re.fullmatch(re_str, '019'))

    # 5. \b 检测边界（单词边界--一般的符号都可以作为单词边界）
    print(re.match(re_str,'01956'))

    """匹配三个任意字符的前面和后面都是单词边界的字符串"""
    re_str = r'\b...\b'
    print(re.match(re_str,'sds，sdasd'))

    # 6. ^ 匹配字符串开始（^The -- 匹配以The开头的字符串）
    # re_str = r'^The'
    # print(re.fullmatch(re_str, 'The'))
    # print(re.findall())

    # 7. $ 匹配字符串结束
    re_str = r'abc$'
    print(re.fullmatch(re_str,'abc'))
    print(re.findall(re_str,'asasf sda asd, abc-'))

    # 8. \W 匹配非字母、数组、下划线
    re_str = r'\W\w'
    print(re.fullmatch(re_str,'@s'))

    # 9. \S匹配非空白符
    re_str = r'\S\d'
    print(re.fullmatch(re_str,'#5'))

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

结果：
<_sre.SRE_Match object; span=(0, 2), match='ah'>
<_sre.SRE_Match object; span=(0, 3), match='_4d'>
<_sre.SRE_Match object; span=(0, 3), match='a\nb'>
<_sre.SRE_Match object; span=(0, 3), match='120'>
<_sre.SRE_Match object; span=(0, 3), match='019'>
<_sre.SRE_Match object; span=(0, 3), match='019'>
<_sre.SRE_Match object; span=(0, 3), match='sds'>
<_sre.SRE_Match object; span=(0, 3), match='abc'>
[]
<_sre.SRE_Match object; span=(0, 2), match='@s'>
<_sre.SRE_Match object; span=(0, 2), match='#5'>

正则表达式符号组合

import re
if __name__ == '__main__':
    # 1. []匹配[]中出现的任意的一个字符
    """匹配一个字符串，前三位是abc，第四位是字符1或者字符a"""
    re_str = r'abc[1a,]'
    print('***',re.fullmatch(re_str, 'abc1'))

    """第一位是数字或者下划线，后面是abc"""
    re_str = r'[\d_ ]abc'
    print(re.fullmatch(re_str, '9abc'))

    # 2. [^] 匹配不在[]中出现的任意一个字符
    """匹配一个字符串，前三位是abc，第四位不是数字字符且不是字符a"""
    re_str = r'abc[^\da]'
    print(re.fullmatch(re_str,'abcb'))

    # 3. * 匹配0次或者多次
    """匹配一个字符串，前面是0个或者多个数字字符，然后是abc"""
    re_str = r'\d*abc'
    print(re.fullmatch(re_str, '12345555abc'))
    """
    [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'[a-zA-Z]','B'))

    # 写一个正则表达式，判断一个字符串是数字字符串（不能空串）
    re_str = r'\d\d*'
    re_str = r'[0-9][0-9]*'
    print(re.fullmatch(re_str,'12355'))

    # 写一个正则表达式，
    re_str = r'[a-zA-Z_]\w*'
    print(re.fullmatch(re_str, 'asd'))

    # 4. + :匹配一次或者多次
    """匹配一个字符串开头出现一次或者多个数字字符，然后再有0次或者多次数字、字母、下划线"""
    re_str = r'\d+\w*'
    print(re.fullmatch(re_str, '1sfasd'))

    # 5.? ：匹配0次或者1次
    re_str = r'[a-z]?123'
    print(re.fullmatch(re_str, 'z123'))

    # 判断是一个字符串是否是正整数字符串 '123' ->
    re_str = r'[+]?[1-9]\d*'
    if not re.fullmatch(re_str, '+0123'):
        print('匹配不成功')
    else:
        print('匹配成功')

    # 6.{N}匹配N次
    """前面5个数字，然后是abc"""
    re_str = r'\d{5}abc'

    re_str = r'[12ab]{3}abc'
    print(re.fullmatch(re_str, '1a1abc'))

    # 7. {N,}匹配大于等于N次
    """字符串前面至少三位是数字，后面随意"""
    re_str = r'\d{3,}.*'
    print(re.fullmatch(re_str, '1233218sdaf'))

    # 8. {M,N} 匹配至少M次，最多N次
    """密码要求：数字、字母组成，并且8-16位"""
    re_str = r'[\da-zA-Z]{8,16}'

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

    # 10.（）匹配的时候是分组，让括号中的正则条件变成一个整体
    """匹配一个字符串，abc整体重复3次"""
    re_str = r'(abc){3}'
    print(re.fullmatch(re_str, 'abcabcabc'))

    re_str = r'(\d\w[0-3]){2}'
    print(re.fullmatch(re_str, '3o37h1'))

    """=======以下了解======="""
    # 11. *? 重复任意次，尽可能少的重复
    re_str = r'a*?'
    print(re.match(re_str, ''))

    # 12. ?? 重复0次或者1次，尽可能少的重复
    re_str = r'b??'
结果：
*** <_sre.SRE_Match object; span=(0, 4), match='abc1'>
<_sre.SRE_Match object; span=(0, 4), match='9abc'>
<_sre.SRE_Match object; span=(0, 4), match='abcb'>
<_sre.SRE_Match object; span=(0, 11), match='12345555abc'>
<_sre.SRE_Match object; span=(0, 1), match='B'>
<_sre.SRE_Match object; span=(0, 5), match='12355'>
<_sre.SRE_Match object; span=(0, 3), match='asd'>
<_sre.SRE_Match object; span=(0, 6), match='1sfasd'>
<_sre.SRE_Match object; span=(0, 4), match='z123'>
匹配不成功
<_sre.SRE_Match object; span=(0, 6), match='1a1abc'>
<_sre.SRE_Match object; span=(0, 11), match='1233218sdaf'>
<_sre.SRE_Match object; span=(0, 3), match='asd'>
<_sre.SRE_Match object; span=(0, 9), match='abcabcabc'>
<_sre.SRE_Match object; span=(0, 6), match='3o37h1'>
<_sre.SRE_Match object; span=(0, 0), match=''>

正则表达式

正则表达式的运用

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

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

import re

if __name__ == '__main__':
    re_str = r'\d+[1\-3]\d+'
    print(re.fullmatch(re_str, '12-89'))

    re_str = r'[\^]'  # 匹配 字符^
    re_str = r'[\\]'  # 匹配 字符\
    re_str = r'[\$]'
    re_str = r'[{}]'
    print(re.fullmatch(re_str, '{'))

    # 1. \N --> 匹配前面第N个组中匹配到的内容
    re_str = r'([1-9][a-z]{2})n(\d)\1\2'
    print(re.fullmatch(re_str, '9hjn09hj0'))

结果：
<_sre.SRE_Match object; span=(0, 5), match='12-89'>
<_sre.SRE_Match object; span=(0, 1), match='{'>
<_sre.SRE_Match object; span=(0, 9), match='9hjn09hj0'>

练习

 # 用户名必须由字母、数字或下划线构成且长度在6~20个字符之间
    re_str = r'\w{6,20}'
    #QQ号是5~12的数字且首位不能为0
    re_str = r'[1-9]\d{4,11}'

    # 练习2：IP地址是合法
    """
    x.x.x.x
    x: 1-255
    写一个正则表达式判断一个字符串是否是：1-255
    1-9
    10-99
    100-199
    200-249
    250-255
    """
    re_str = r'(([1-9]|[1-9]\d|1\d{2}|2[0-4]\d|25[0-5])\.){3}([1-9]|[1-9]\d|1\d{2}|2[0-4]\d|25[0-5])'
    print(re.fullmatch(re_str, '10.7.1.249'))

结果：
<_sre.SRE_Match object; span=(0, 10), match='10.7.1.249'>

re模块方法

import re

if __name__ == '__main__':

    # 1.compile(正则字符串)将正则表达式字符串转换成正则表达式对象
    # 转换成正则表达式对象后，可以通过对象调用相关的方法
    re_object = re.compile(r'\w{6,12}')
    print(re_object.fullmatch('fsasfs'))
    print(re.fullmatch(r'\w{6,12}', 'fsasfs'))

    # 2.fullmatch(正则表达式，字符串)完全匹配，从字符串开始匹配到结尾
    # 返回值是匹配对象
    match = re.fullmatch('\w{3}', 'h3s')
    print(match)
    # a.获取匹配到的结果
    print(match.group())
    # b.获取匹配到的范围
    print(match.span())
    # c.获取匹配到的开始下标和结束下标
    print(match.start(), match.end())
    # d.获取被匹配的字符串（原字符串）
    print(match.string)
    # 应用：判断一个字符串是否是某种字符串（判断帐号、密码是否符合要求等）

    # 3.match（正则表达式，字符串）不完全破匹配，从字符串开头开始匹配，匹配到正则表达式对应的范围为止
    # 返回值是匹配对象，如果匹配失败返回NONE
    match = re.match('\w{3}', 'asfgasdasdasfgasdag')
    print(match)
    print(match.group())
    print(match.string)

    # 应用：判断一个字符串是否以某种字符串开头

    # 4.search（正则表达式，字符串） 在指定的字符串中查找某种字符串（以正则表达式来描述）
    # 如果有过个满足条件的，只匹配第一个，返回值是匹配对象；如果找不到符合要求的返回None
    print(re.search(r'\d{2,}[a-z]', 'sha456as4d5ffggasf4654as'))

    # 应用：判断一个字符串中是否包含某种字符串

    # 5.findall（正则表达式，字符串）去获取指定字符串中满足正则条件的所有的子串
    # 返回值是列表，列表中是符合要求的字符串。没有满足要求的子串就返回[]
    result = re.findall(r'\D(\d+)\D', 'a123211sadasf54a5s46d')
    print(result)

    # 注意：在通过正则表达式获取子串的时候，可以通过在正则表达式中添加括号，来约束获取的内容（只获取括号中匹配到的内容）
    #      匹配的时候还是按原正则表达式去查找

    # 应用：字符串提取

    # 6.finditer(正则表达式，字符串)用法和findall一样，只是返回值的类型不一样
    # 返回一个迭代器
    # 注意：（）捕获部分无效
    result = re.finditer(r'\D(\d+)\D', 'a123211sadasf54a5s46d')
    for match in result:
        print(match)

    # 7.split（正则表达式，字符串）按正则表达式匹配到的字符串进行切割
    # 返回值是列表，列表元素就切割后被分段的字符串
    result = re.split(r'[\[\]*\-]', 'as[dgjas]oi34*654s-f3h')
    print(result)

    # 8.sub（正则表达式，新字符串，原字符串）  在原字符串中查找符合正则的子串，替换成新的字符串
    """"""
    str1 = '你好sb，你们都是sb'
    result = re.sub(r'sb', '胖总',str1)
    print(str1, result)

结果：
<_sre.SRE_Match object; span=(0, 6), match='fsasfs'>
<_sre.SRE_Match object; span=(0, 6), match='fsasfs'>
<_sre.SRE_Match object; span=(0, 3), match='h3s'>
h3s
(0, 3)
0 3
h3s
<_sre.SRE_Match object; span=(0, 3), match='asf'>
asf
asfgasdasdasfgasdag
<_sre.SRE_Match object; span=(3, 7), match='456a'>
['123211', '54', '46']
<_sre.SRE_Match object; span=(0, 8), match='a123211s'>
<_sre.SRE_Match object; span=(12, 16), match='f54a'>
<_sre.SRE_Match object; span=(17, 21), match='s46d'>
['as', 'dgjas', 'oi34', '654s', 'f3h']
你好sb，你们都是sb 你好胖总，你们都是胖总