1.正則表達式的符號

正則表達式：用來做字符串查找、匹配、切割用的一種工具

python對正則表達式的支持：提供了re模塊(python內置模塊),包含字符串匹配、查找、切割等相關方法
fullmatch(正則表達式, 字符串)：用正則表達式來和字符串進行匹配，看是否能夠匹配成功,
正則表達式：是一個符合正則規(guī)范的字符串
"""

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 匹配一個字符是字母、數(shù)字或者下滑線
    """匹配第一個字符是字母、數(shù)字或者下滑線，第二個字符是字母、數(shù)字或者下滑線的字符串"""
    re_str = r'\w\w'
    print(re.fullmatch(re_str, 'b8'))

    re_str = r'\w.\w'
    print(re.fullmatch(re_str,'u(o'))

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

    # 4. \d 匹配一個數(shù)字字符
    re_str = r'\d\d\d'
    print(re.fullmatch(re_str,'120'))

    """匹配第一字符是0，后面兩個字符都是數(shù)字的字符串"""
    re_str = r'0\d\d'
    print(re.fullmatch(re_str, '019'))

    # 5. \b 檢測邊界(單詞邊界--一般的符號都可以作為單詞邊界)
    print(re.match(re_str, '0190'))
    """匹配三個任意字符的前面和后面都是單詞邊界的字符串"""
    re_str = r'\b...\b'
    print(re.match(re_str, 'jsh,abc'))

    # 6. ^ 檢測字符串開始(^The -- 匹配以The開頭的字符串)
    re_str = r'^The'
    print(re.fullmatch(re_str, 'The'))
    print(re.findall(r'^The', 'aThe789abc hThe989ekl'))

    # 7. $ 檢測字符串結束
    re_str = r'abc$'
    print(re.fullmatch(re_str, 'abc'))
    print(re.findall(re_str, 'hkakh jkjs abc-'))

    # 8. \W 匹配非字母、數(shù)組、下劃線
    re_str = r'\W\w'
    print(re.fullmatch(re_str, '&k'))

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

    # 10. \D 匹配非數(shù)字字符
    """匹配第一個字符是非數(shù)字字符，第二個字符是字母、數(shù)字、下劃線"""
    re_str = r'\D\w'
    print(re.fullmatch(re_str, 'p8'))

    # 11. \B 檢測非邊界
    """匹配前面兩個字符是a和b,第三個字符是c。并且檢測b的后面是一個非邊界"""
    re_str = r'ab\Bc'
    print(re.fullmatch(re_str, 'abc'))
    print(re.match(re_str,'abc0'))

2.正則表達式符號組合

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

    """第一位是數(shù)字或者下劃線，后面是abc"""
    re_str = r'[\d_]abc'
    print(re.fullmatch(re_str, '9abc'))

    # 2. [^] 匹配不在[]中出現(xiàn)的任意一個字符
    """匹配一個字符串，前三位是anc,第四位不是數(shù)字字符也不是字符a"""
    re_str = r'abc[^\da]'
    print(re.fullmatch(re_str, 'abcl'))

    # 3. * 匹配0次或者多次
    """匹配一個字符串，前面是0個或者多個數(shù)字字符，然后是abc"""
    re_str = r'\d*abc'
    print(re.fullmatch(re_str, '19076abc'))

    """
    [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'))

    # 寫一個正則表達式，判斷一個字符串是數(shù)字字符串（不能空串）
    re_str = r'\d\d*'
    re_str = r'[0-9][0-9]*'
    print(re.fullmatch(re_str, '0'))

    # 寫一個正則表達式，檢測一個字符串是否是合格的標識符(字母數(shù)字下劃線組成，數(shù)字不開頭)
    """
    abc  -> 成功
    _a12h -> 成功
    __23a -> 成功
    1hj_ -> None
    a*h -> None
    """
    re_str = r'[a-zA-Z_]\w*'
    print(re.fullmatch(re_str, 'a*h'))

    # 4. + 匹配一次或者多次
    """匹配一個字符串開頭出現(xiàn)一次或者多個數(shù)字字符，然后再有0次或者多次數(shù)字、字母、下劃線"""
    re_str = r'\d+\w*'
    print(re.fullmatch(re_str, '16u78abc'))

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

    # 判斷是一個字符串是否是正整數(shù)字符串(除0) '123' -> 成功 '+1234' -> 成功 '0123' -> None '12012' ->  成功
    re_str = r'[+]?[1-9]\d*'
    print(re.fullmatch(re_str, '+1234'))

    # 5.{N} 匹配N次
    """前面5個數(shù)字，然后是abc"""
    re_str = r'\d{5}abc'

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

    # 6.{N,} 匹配大于等于N次
    """字符串前面至少三位數(shù)字，后面隨意"""
    re_str = r'\d{3,}.*'
    print(re.fullmatch(re_str, '151263jah92390..;'))

    # 7.{M,N} 匹配至少M次，最多N次
    """密碼要求：數(shù)字、字母組成，并且8-16位"""
    re_str = r'[\da-zA-Z]{6,10}'
    print(re.fullmatch(re_str, 'uy2huy?28'))

    # 8. | 分之
    """匹配一個字符串，是三個數(shù)字字符或者是三個小寫字符"""
    re_str = r'\d{3}|[a-z]{3}'
    print(re.fullmatch(re_str, 'hsu'))

    # 9.() 匹配的時候是分組，讓括號中的正則條件變成一個整體,進行整體操作
    """匹配一個字符串，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'))

    """========以下了解========"""
    # 盡可能少：在能夠匹配到的前提下盡可能少
    # 10. *? 重復任意次，盡可能少的重復
    re_str = r'ba*?b'
    print(re.match(re_str, 'baabaa'))

    # 11. +? 重復一次或多次，盡可能少的重復
    re_str = r'ba+?'
    print(re.match(re_str, 'baaaa'))

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

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

3.正則表達式

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



    # 練習1.
    # 用戶名必須由字母、數(shù)字或下劃線構成且長度在6~20個字符之間
    re_str = r'\w{6,20}'
    #QQ號是5~12的數(shù)字且首位不能為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'))

4.re模塊方法

import re
if __name__ == '__main__':

    # 1.compile(正則字符串) 將正則表達式字符串轉換成正則表達式對象
    # 轉換成正則表達式對象后，可以通過對象調用相關的方法
    re_obct = re.compile(r'\w{6,12}')
    print(re_obct.fullmatch('ahsjjs'))
    print(re.fullmatch(r'\w{6,12}', 'ahjhjs'))


    # 2.fullmatch(正則表達式, 字符串) 完全匹配，從字符串開頭匹配到結尾
    # 返回值是匹配對象, 如果匹配失敗返回None
    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(r'\w{3}', 'h3shhhhsbs')
    print(match)
    print(match.group())
    print(match.string)

    # 應用: 判斷一個字符串是否以某種字符串開頭

    # 4.search(正則表達式, 字符串) 在指定的字符串中查找某種字符串(以正則表達式來描述)，如果有過個滿足條件的，只匹配第一個
    # 返回值是匹配對象，如果找不到符合要求的返回None
    print(re.search(r'\d{2,}[a-z]', 'sh23n--8a7a7m0899'))

    # 應用：判斷一個字符串中是否包含某種字符串

    # 5.findall(正則表達式, 字符串) 去獲取指定字符串中滿足正則條件的所有的子串
    # 返回值是列表，列表中是符合要求的字符串。沒有滿足要求的子串就返回[]
    result = re.findall(r'[a-zA-Z](\d+)', '12a123buy=236ok98s')
    print(result)

    # 注意：在通過正則表達式獲取子串的時候，可以通過在正則表達式中添加括號，來約束獲取的內容(只捕獲括號中匹配到的內容)
    #      匹配的時候還是按原正則表達式去查找

    # 應用：字符串提取

    # 6.finditer(正則表達式, 字符串) 用法和findall一樣，只是返回值的類型不一樣
    # 返回一個迭代器，迭代器中的內容是匹配對象
    # 注意：()捕獲部分無效
    result = re.finditer(r'[a-zA-Z](\d+)', '12a123buy=236ok98s')
    for match in result:
        print(match)

    # print('ahsj27jkkaj7js8jsj'.split('sj'))
    # 7.split(正則表達式, 字符串) 按正則表達式匹配到的字符串進行切割
    # 返回值是列表，列表元素就切割后被分段的字符串
    result = re.split(r'[\[\]*\-]', 'a[hsj27]jkkaj*7js8-jsj')
    print(result)


    # 8.sub(正則表達式,新字符串, 原字符串)  在原字符串中查找符合正則的子串，替換成新的字符串
    # 返回值是替換后的字符串
    """將指定字符串中所有'sb'替換成'*'"""
    str1 = '你好sb,你全家都是sb,傻叉，你是不是傻，手機上叉'
    result = re.sub(r'sb|傻叉|傻', '*', str1)
    print(str1, result)