1.正則表達式的符號

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

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

import re

if  __name__ == '__main__':


 注意：正則表達式的字符串，前面一般要加r來阻止轉(zhuǎn)義。因為正則表達式的符號中有很多帶'\'的符號，其功能不是轉(zhuǎn)義，而是表示特殊的意義
 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\sb'))

 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. $ 檢測字符串結(jié)束
    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.特殊符號轉(zhuǎn)義
正則中：. \ [] {} () * + ? ^ $ | 這些字符有特殊意義，所以在正則表達式中，如果想要單純表達這些字符，需要在前面加'';

注意：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個組中匹配到的內(nèi)容
    re_str = r'([1-9][a-z]{2})n(\d)\1\2'
    print(re.fullmatch(re_str, '9hjn09hj0'))

練習1.

用戶名必須由字母、數(shù)字或下劃線構(gòu)成且長度在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(正則字符串) 將正則表達式字符串轉(zhuǎn)換成正則表達式對象轉(zhuǎn)換成正則表達式對象后，可以通過對象調(diào)用相關(guān)的方法
    re_obct = re.compile(r'\w{6,12}')
    print(re_obct.fullmatch('ahsjjs'))
    print(re.fullmatch(r'\w{6,12}', 'ahjhjs'))

2.fullmatch(正則表達式, 字符串) 完全匹配，從字符串開頭匹配到結(jié)尾返回值是匹配對象, 如果匹配失敗返回None

   match = re.fullmatch('\w{3}', 'h3s')
   print(match)
   # a.獲取匹配到的結(jié)果
   print(match.group())
   # b.獲取匹配到的范圍
   print(match.span())
   # c.獲取匹配到的開始下標和結(jié)束下標
   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)

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

應用：字符串提取
6.finditer(正則表達式, 字符串) 用法和findall一樣，只是返回值的類型不一樣。返回一個迭代器，迭代器中的內(nèi)容是匹配對象
注意：()捕獲部分無效

    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)