一、正则表达式

1.什么是正则表达式

正则就是一个用来做字符串匹配的工具，通过不同的符号匹配不同的字符。

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

通过 re 模块，通过相应支持的正则表达式的方法

fullmatth（正则表达式， 字符串） -----用正则表达式来和指定字符串进行匹配，
如果匹配成功，就返回匹配对象；
如果匹配失败，就返回 None 。
python 中的正则表达式是写在字符串中间的，但是一般情况下，会在最前面加 r/R

例如:

from re import fullmatch


def main():
    # 0.普通字符（代表字符本身）
    re_str = r'adc'
    result = fullmatch(re_str, 'adc')
    print(result)

    # 1. . 匹配任意字符
    # 匹配一个字符串,只有三个字符,第一个字符是 a ,第二个字符是任意字符,第三个字符是 c
    re_str = r'a.c'  # 注意:一个点代表一个字符; 不能匹配 \n
    result = fullmatch(re_str, 'a&c')
    print(result)

    # 2.\w(匹配字母,数字,下划线)
    # 注意:也可以匹配中文(ASCLL表以外的字符);一个 \w 只能匹配一个字符
    # 匹配一个字符串,第一,二个字符是字母,数字,下划线或中文;第三个字符是任意字符,第五,六,七为字符'adc'
    re_str = r'\w\w..adc'
    result = fullmatch(re_str, '阿勒34adc')
    print(result)

    # 3.\s(匹配空白字符)
    # 所有能产生空白的字符,包括空格,制表符,换行
    # 匹配一个字符串,前两个字符是字母,数字,下划线或中文;第三个字符是空白;第五,六,七为字符'adc'
    re_str = r'\w\w\s\sadc'
    result = fullmatch(re_str, '啊嘞\t adc')
    print(result)

    # 4.\d(匹配数字字符)
    # 匹配一个字符串,前三个字符是数字字符,后两个字符为任意字符
    re_str = r'\d\d\d..'
    result = fullmatch(re_str, '123%^')
    print(result)

    # 5.\b(检查单词边界)
    # a.检查正则表达式中 \b 所在的位置是否是单词边界
    # b.单词边界:所有的可以将两个单词区分开的符号都是单词边界,例如;空格、缩进、标点符号(单词开头或者结尾)等
    # c.\b 不是匹配符号,就不会匹配出一个字符,只是检测所在的位置是否满足要求
    # 匹配一个字符串的内容是 'and are' 并且要求字符 'a' 的前面是单词边界
    re_str = r'and\b adc'
    result = fullmatch(re_str, 'and adc')
    print(result)

    # 6.^(检查字符串开头)
    # 匹配一个字符串是三个数字字符,并且字符所在位置是字符串开头
    re_str = r'^\d\d\d'
    result = fullmatch(re_str, '123')
    print(result)

    # 7.$(检查字符串结尾)
    # 匹配一个字符串是三个数字字符,并且字符所在位置是字符串结尾
    re_str = r'\d\d\d$'
    result = fullmatch(re_str, '123')
    print(result)

    # 8.\B(检查非单词边界)
    # 匹配一个字符串是四个数字字符,并且字符所在位置是字符串结尾
    re_str = r'\d\d\d\B.'
    result = fullmatch(re_str, '1234')
    print(result)

    # 9.\W(匹配非数字,字母,下划线,中文)
    # 10.\S(匹配非空白字符)
    # 11.\D(匹配非数字字符)

    # 12.[字符集](匹配字符集中的任意一个字符)
    # 注意:一个[]代表一个字符
    # a.普通用法:
    # [字符集]         -----匹配字符集中的任意一个字符
    # 匹配一个字符串,第一个字符是 adc 中的其中一个,后面的字符是 123
    re_str = r'[adc]123'
    result = fullmatch(re_str, 'a123')
    print(result)
    # b.表示范围
    # [字符1 - 字符2]       -----匹配 字符1 到 字符2 中所有的字符(要求 字符1 的编码值要小于 字符2 的编码值)
    # [1-9]             -----数字 1 到 9
    # [a-z]             -----小写字母
    # [A-Z]             -----大写字母
    # [a-zA-Z]          -----所有字母
    # [\da-zA-Z_]          -----数字,字母,下划线
    # 匹配一个字符串,第一个字符是数字 0 到 9 的其中一个,中间两个是任意数字,最后的字符是 a 到 z 的其中一个
    re_str = r'[0-9]\d\d[a-z]'
    result = fullmatch(re_str, '123a')
    print(result)

    # 13.[^字符集](匹配没在字符集中的其它任意字符)
    # 注意: ^ 放在[]的最前面才表示匹配不在字符集中的其它任意字符, ^ 不放在[]的最前面就不是字符本身
    # 匹配一个字符串,第一个字符只要不是 adc 中的任意一个,其它都行,后面是 123
    re_str = r'[^adc]123'
    result = fullmatch(re_str, 'b123')
    print(result)
    # 匹配一个字符串,第一个字符只要不是 1 到 9 中的任意一个,其它都行,后面是 123
    re_str = r'[^adc]123'
    result = fullmatch(re_str, 'b123')
    print(result)
    # 匹配一个字符串,第一个字符是 1 到 9 和 ^ 中的任意一个,后面是 123
    re_str = r'[adc^]123'
    result = fullmatch(re_str, '^123')
    print(result)

    # 14.转义符号
    # a.正则中也可以在特殊符号前,加 '\' 来对符号进行转义
    # b.除了在[]有特殊意义的符号,其它符号放在[]中也是不是符号本身
    #       - 在[]中的两个字符之间表示谁到谁,如果要表示它本身,就不要放在两个字符之间(放在两端)
    #       ^ 在[]中最前面有特殊意义,如果要表示它本身,就不要放在最前面
    #       ] 在[]中表示,如果要表示它本身,就在前面加 \
    # 注意:转义字符是字符串中的概念;转义符号是正则表达式里的概念
    # 匹配一个字符串,第一,二个字符
    re_str = r'^\d\d\.\s\s'
    result = fullmatch(re_str, '12. \t')
    print(result)
    print(fullmatch(r'[.]', 'k'))
    pass


if __name__ == '__main__':
    main()

运行结果:

<_sre.SRE_Match object; span=(0, 3), match='adc'>
<_sre.SRE_Match object; span=(0, 3), match='a&c'>
<_sre.SRE_Match object; span=(0, 7), match='阿勒34adc'>
<_sre.SRE_Match object; span=(0, 7), match='啊嘞\t adc'>
<_sre.SRE_Match object; span=(0, 5), match='123%^'>
<_sre.SRE_Match object; span=(0, 7), match='and adc'>
<_sre.SRE_Match object; span=(0, 3), match='123'>
<_sre.SRE_Match object; span=(0, 3), match='123'>
<_sre.SRE_Match object; span=(0, 4), match='1234'>
<_sre.SRE_Match object; span=(0, 4), match='a123'>
<_sre.SRE_Match object; span=(0, 4), match='123a'>
<_sre.SRE_Match object; span=(0, 4), match='b123'>
<_sre.SRE_Match object; span=(0, 4), match='b123'>
<_sre.SRE_Match object; span=(0, 4), match='^123'>
<_sre.SRE_Match object; span=(0, 5), match='12. \t'>
None

二、匹配次数

1. * (匹配 0 或 n 次)

字符* -----指定的字符出现 0 次或多次(这里的字符可以是正则符号也可以是普通字符)
a* -----a 出现0 次或多次
\d* -----任意数字 出现0 次或多次
[a-z]* -----任意小写字母出现0 次或多次
在 123 之前有 0 个或多个 a

2.+(匹配 1 次或多次)

3.?(匹配 0 次或 1 次)

4.{}

{M, N} -----匹配 M 到 N 次(最大 M 次,最大 N 次)
{M,} -----匹配最少 M 次
{, N} -----匹配最多 N 次
{N} -----匹配 N 次

例如:

from re import fullmatch


def main():
    # 1. *(匹配 0 或 n 次)
    # 字符*           -----指定的字符出现 0 次或多次(这里的字符可以是正则符号也可以是普通字符)
    # a*            -----a 出现0 次或多次
    # \d*           -----任意数字 出现0 次或多次
    # [a-z]*        -----任意小写字母出现0 次或多次
    # 在 123 之前有 0 个或多个 a
    re_str = r'a*123'
    print(fullmatch(re_str, 'aaaaaaaaaaa123'))
    print(fullmatch(re_str, '123'))
    # 在 123 之前有 0 个或多个任意小写字母
    re_str = r'[a-z]*123'
    print(fullmatch(re_str, 'adchhh123'))
    print(fullmatch(re_str, '123'))

    # 2.+(匹配 1 次或多次)
    re_str = r'a+123'
    print(fullmatch(re_str, 'aaaaaaaaaaa123'))
    print(fullmatch(re_str, 'a123'))

    # 3.?(匹配 0 次或 1 次)
    re_str = r'a\+?123'
    print(fullmatch(re_str, 'a+123'))
    print(fullmatch(re_str, 'a123'))

    # re_str = r'[+-]?[1-9]\d*]'
    re_str = r'[+-]?[1-9]\d[0-9]\d*'
    print(fullmatch(re_str, '-123'))

    # 4.{}
    # {M, N}            -----匹配 M 到 N 次(最大 M 次,最大 N 次)
    # {M,}              -----匹配最少 M 次
    # {, N}             -----匹配最多 N 次
    # {N}               -----匹配 N 次
    print(fullmatch(r'\d{6,16}', '123456'))


if __name__ == '__main__':
    main()

运行结果:

<_sre.SRE_Match object; span=(0, 14), match='aaaaaaaaaaa123'>
<_sre.SRE_Match object; span=(0, 3), match='123'>
<_sre.SRE_Match object; span=(0, 9), match='adchhh123'>
<_sre.SRE_Match object; span=(0, 3), match='123'>
<_sre.SRE_Match object; span=(0, 14), match='aaaaaaaaaaa123'>
<_sre.SRE_Match object; span=(0, 4), match='a123'>
<_sre.SRE_Match object; span=(0, 5), match='a+123'>
<_sre.SRE_Match object; span=(0, 4), match='a123'>
<_sre.SRE_Match object; span=(0, 4), match='-123'>
<_sre.SRE_Match object; span=(0, 6), match='123456'>

三、分之和分组

1. | :分之

表达式1 | 表达式2 | 表达式3 -----先使用 表达式1 进行匹配,匹配成功就直接成功;
匹配不失败就用 表达式2 再匹配,以此类推;里面的表达式都失败才匹配失败
2.():分组

a.分组 -----将()里面的内容看成一个整体

(adc){2} -----adcadc
adc{2} -----adcc

b.分组重复 -----在有分组的正则表达式中可以在分组的后面通过 (数字) 来重复前面第 数字 个分组匹配到的内容

(\d{3})adc\1 -----258adc258
例如:

from re import fullmatch


def main():
    re_str = r'[a-z]{5}|\d{3}'
    print(fullmatch(re_str, '147'))
    print(fullmatch(re_str, 'adcbe'))

    re_str = r'(adc){2}'
    print(fullmatch(re_str, 'adcadc'))

    re_str = r'(45)a(78)dc\2\1{2}'
    print(fullmatch(re_str, '45a78dc784545'))


if __name__ == '__main__':
    main()

运行结果:

<_sre.SRE_Match object; span=(0, 3), match='147'>
<_sre.SRE_Match object; span=(0, 5), match='adcbe'>
<_sre.SRE_Match object; span=(0, 6), match='adcadc'>
<_sre.SRE_Match object; span=(0, 13), match='45a78dc784545'>