一、正則表達(dá)式

1.什么是正則表達(dá)式

正則就是一個用來做字符串匹配的工具，通過不同的符號匹配不同的字符。

2.python 對正則表達(dá)式的支持

通過 re 模塊，通過相應(yīng)支持的正則表達(dá)式的方法

fullmatth（正則表達(dá)式， 字符串） -----用正則表達(dá)式來和指定字符串進(jìn)行匹配，
如果匹配成功，就返回匹配對象；
如果匹配失敗，就返回 None 。
python 中的正則表達(dá)式是寫在字符串中間的，但是一般情況下，會在最前面加 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(匹配字母,數(shù)字,下劃線)
    # 注意:也可以匹配中文(ASCLL表以外的字符);一個 \w 只能匹配一個字符
    # 匹配一個字符串,第一,二個字符是字母,數(shù)字,下劃線或中文;第三個字符是任意字符,第五,六,七為字符'adc'
    re_str = r'\w\w..adc'
    result = fullmatch(re_str, '阿勒34adc')
    print(result)

    # 3.\s(匹配空白字符)
    # 所有能產(chǎn)生空白的字符,包括空格,制表符,換行
    # 匹配一個字符串,前兩個字符是字母,數(shù)字,下劃線或中文;第三個字符是空白;第五,六,七為字符'adc'
    re_str = r'\w\w\s\sadc'
    result = fullmatch(re_str, '啊嘞\t adc')
    print(result)

    # 4.\d(匹配數(shù)字字符)
    # 匹配一個字符串,前三個字符是數(shù)字字符,后兩個字符為任意字符
    re_str = r'\d\d\d..'
    result = fullmatch(re_str, '123%^')
    print(result)

    # 5.\b(檢查單詞邊界)
    # a.檢查正則表達(dá)式中 \b 所在的位置是否是單詞邊界
    # b.單詞邊界:所有的可以將兩個單詞區(qū)分開的符號都是單詞邊界,例如;空格、縮進(jìn)、標(biāo)點符號(單詞開頭或者結(jié)尾)等
    # c.\b 不是匹配符號,就不會匹配出一個字符,只是檢測所在的位置是否滿足要求
    # 匹配一個字符串的內(nèi)容是 'and are' 并且要求字符 'a' 的前面是單詞邊界
    re_str = r'and\b adc'
    result = fullmatch(re_str, 'and adc')
    print(result)

    # 6.^(檢查字符串開頭)
    # 匹配一個字符串是三個數(shù)字字符,并且字符所在位置是字符串開頭
    re_str = r'^\d\d\d'
    result = fullmatch(re_str, '123')
    print(result)

    # 7.$(檢查字符串結(jié)尾)
    # 匹配一個字符串是三個數(shù)字字符,并且字符所在位置是字符串結(jié)尾
    re_str = r'\d\d\d$'
    result = fullmatch(re_str, '123')
    print(result)

    # 8.\B(檢查非單詞邊界)
    # 匹配一個字符串是四個數(shù)字字符,并且字符所在位置是字符串結(jié)尾
    re_str = r'\d\d\d\B.'
    result = fullmatch(re_str, '1234')
    print(result)

    # 9.\W(匹配非數(shù)字,字母,下劃線,中文)
    # 10.\S(匹配非空白字符)
    # 11.\D(匹配非數(shù)字字符)

    # 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]             -----數(shù)字 1 到 9
    # [a-z]             -----小寫字母
    # [A-Z]             -----大寫字母
    # [a-zA-Z]          -----所有字母
    # [\da-zA-Z_]          -----數(shù)字,字母,下劃線
    # 匹配一個字符串,第一個字符是數(shù)字 0 到 9 的其中一個,中間兩個是任意數(shù)字,最后的字符是 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.轉(zhuǎn)義符號
    # a.正則中也可以在特殊符號前,加 '\' 來對符號進(jìn)行轉(zhuǎn)義
    # b.除了在[]有特殊意義的符號,其它符號放在[]中也是不是符號本身
    #       - 在[]中的兩個字符之間表示誰到誰,如果要表示它本身,就不要放在兩個字符之間(放在兩端)
    #       ^ 在[]中最前面有特殊意義,如果要表示它本身,就不要放在最前面
    #       ] 在[]中表示,如果要表示它本身,就在前面加 \
    # 注意:轉(zhuǎn)義字符是字符串中的概念;轉(zhuǎn)義符號是正則表達(dá)式里的概念
    # 匹配一個字符串,第一,二個字符
    re_str = r'^\d\d\.\s\s'
    result = fullmatch(re_str, '12. \t')
    print(result)
    print(fullmatch(r'[.]', 'k'))
    pass


if __name__ == '__main__':
    main()

運行結(jié)果:

<_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

二、匹配次數(shù)

1. * (匹配 0 或 n 次)

字符* -----指定的字符出現(xiàn) 0 次或多次(這里的字符可以是正則符號也可以是普通字符)
a* -----a 出現(xiàn)0 次或多次
\d* -----任意數(shù)字 出現(xiàn)0 次或多次
[a-z]* -----任意小寫字母出現(xiàn)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 次)
    # 字符*           -----指定的字符出現(xiàn) 0 次或多次(這里的字符可以是正則符號也可以是普通字符)
    # a*            -----a 出現(xiàn)0 次或多次
    # \d*           -----任意數(shù)字 出現(xiàn)0 次或多次
    # [a-z]*        -----任意小寫字母出現(xiàn)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()

運行結(jié)果:

<_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. | :分之

表達(dá)式1 | 表達(dá)式2 | 表達(dá)式3 -----先使用 表達(dá)式1 進(jìn)行匹配,匹配成功就直接成功;
匹配不失敗就用 表達(dá)式2 再匹配,以此類推;里面的表達(dá)式都失敗才匹配失敗
2.():分組

a.分組 -----將()里面的內(nèi)容看成一個整體

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

b.分組重復(fù) -----在有分組的正則表達(dá)式中可以在分組的后面通過 (數(shù)字) 來重復(fù)前面第 數(shù)字 個分組匹配到的內(nèi)容

(\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()

運行結(jié)果:

<_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'>