python 正則表達式

正則表達式的做用：用來匹配字符串

1、字符串方法

字符串提供的方法是徹底匹配，不能進行模糊匹配

s = 'hello world'

# 字符串提供的方法是徹底匹配，不能進行模糊匹配
print(s.find('ll'))  # 2   查找ll的位置，輸出的是第一個l的位置   
ret = s.replace('ll', 'xx')   # 替換，用ll 替換爲 xx
print(ret)   # hexxo world   
print(s.split('w'))   # ['hello ', 'orld']   分割：以w爲界限，分割爲先後兩部分,存在列表中

2、正則表達式

正則的方法：
一、findall() :全部結果返回到一個列表裏
二、search() :返回匹配到的第一個對象，對象能夠調用group()返回結果
三、match() :只在字符串開始匹配,也返回一個對象，可調用group()

findall() 方法：

一、正則表達式能夠進行模糊匹配：

ret = re.findall(r'w\w{2}l', 'hello world')    # 匹配字符串中w開頭l結尾中間有兩個字符的詞
# (加r，聲明是原生字符串，避免字符串轉義)
print(ret)      # ['worl']

二、元字符

• 「.」  通配符：能夠代指除換行符以外的全部字符，一個通配符只能代指任意一個字符

ret = re.findall('w..l', 'hello world')    # 匹配字符串中w開頭l結尾中間有兩個字符的字符串
print(ret)      # ['worl']

• 「^」 上尖角號，只在字符串開始的位置匹配匹配

ret = re.findall('^h..o', 'hjklshllo')  # 只在字符串的開始位置進行匹配，匹配不上就結束，不匹配後面的內容
print(ret)    # []

ret = re.findall('^h..o', 'hjkoshllo')
print(ret)    # ['hjko']

• 「$」符， 只在字符串結尾匹配

ret = re.findall('h..o$', 'hjkoshllo')
print(ret)    # ['hllo']

ret = re.findall('h..o$', 'hjkoshlyto')
print(ret)    # []

• 「*」號，重複匹配(*還能夠代指0個) ，*代指的個數是0到無窮

ret = re.findall('h.*o', 'hjkoshlytg')      # *表示重複前面多個.  既只要是以h開頭o結尾的都行
print(ret)      # ['hjko']

ret = re.findall('h*', 'hhhhjlhl')        # 匹配多個h
print(ret)      # ['hhhh', '', '', 'h', '', '']

ret = re.findall('ah*', 'sdahhh')       # 貪婪匹配，既按最多的匹配
print(ret)      # ['ahhh']

ret = re.findall('ah*?', 'sdahhh')     # 後加？變爲惰性匹配，既按最少的匹配
print(ret)      # ['a']

• 「+」號，重複匹配，同*，可是個數最少爲1個，若是是0個匹配不了，範圍是1到無窮

ret = re.findall('ah+', 'asdahhhjlhl')   # 匹配以ah開頭的內容
print(ret)    # ['ahhh']

ret = re.findall('a+b', 'aaabsdbhbhabj')
print(ret)    # ['aaab', 'ab']

• 「?」號，匹配的範圍是[0, 1]個

ret = re.findall('a?b', 'aaabsdhbhabj')   # 匹配[0, 1]個a
print(ret)      # ['ab', 'b', 'ab']

• 「{}」大括號，自定義匹配的次數

ret = re.findall('a{2}b', 'aaabhaabhab')   # 匹配2個a開頭，b結尾共3位的字符
print(ret)  # ['aab', 'aab']

ret = re.findall('a{1,3}b', 'aaaabfaabhhab')   # 匹配1-3個a,以b結尾的字符
# 注意：{1,3} 之間不能有空格，不能寫成{1, 3}
print(ret)  # ['aaab', 'aab', 'ab']

ret = re.findall('a{1, }b', 'aaaaaaaab')   # {1,} 什麼都不加默認匹配的是正無窮
print(ret)      # ['aaaaaaaab']

ret = re.findall('a{1,3}b', 'aaaab')   # 匹配1-3個a,貪婪匹配原則，既默認按多的匹配
print(ret)  # ['aaab']

三、字符集

    取消元字符的特殊功能   

• []

ret = re.findall('a[dc]b', 'adb')      # 匹配既能夠是adb也能夠是acb，只能2選一，注意[]裏面不用逗號隔開
print(ret)  # ['adb']

ret = re.findall('[a-z]', 'adb')       # 表示一個範圍
print(ret)  # 'a', 'd', 'b']

[]字符集還有取消元字符的特殊功能,(\ ^ -)例外：

ret = re.findall('[w,.]', 'awdb')     # .此時不是元字符，無特殊意義，而是一個普通的字符
print(ret)    # ['w']

ret = re.findall('[w,,]', 'awdb')
print(ret)     # ['w']

「^」放在[]裏面，表示取反：

ret = re.findall('[^w]', 'awdb')   # 匹配除W之外的全部字符
print(ret)  # ['a', 'd', 'b']

ret = re.findall('[^1,4]', 'a1wd42b')   # 注：取反的是(1,4) 總體
print(ret)  # ['a', 'w', 'd', '2', 'b']

四、\ 字符集

反斜槓後跟元字符去除特殊功能；反斜槓後跟普通字符實現特殊功能

"""
\d  匹配十進制數；至關於類[0-9]
\D  匹配任意非數字字符；至關於類[^0-9]
\s  匹配任意空白字符；至關於類[\t\n\r\f\v]
\S  匹配任何非空白字符；至關於類[^ \t\n\r\f\v]
\w  匹配任意字母數字字符；至關於類[a-zA-Z0-9]
\W  匹配任何人非字母數字字符；至關於類[^a-zA-Z0-9]
\b: 匹配一個特殊字符的邊界，就是單詞和空格間的位置
"""

ret = re.findall(r'\d{8}', 'qeqwe45454455qws1245')
print(ret)     # ['45454455']  只能匹配到1組，由於後面數字的不夠8位

ret = re.findall(r'\d{8}', 'qeqwe45454455qws12456541')
print(ret)      # ['45454455', '12456541']  匹配到2組，

ret = re.findall(r'\D{4}', 'qeqwe4555qws41')   # 大括號裏面的數字4表明的是4個字符一組
print(ret)     # ['qeqw']

ret = re.findall(r'\s', 'we4 g1')         # 匹配空白符
print(ret)      # [' ']

ret = re.findall(r'\sw', 'ws4 wsg1')       # 匹配空白符加w
print(ret)      # [' w']

ret = re.findall(r'\w', 'w4 g1')   # 匹配空白符
print(ret)      # ['w', '4', 'g', '1']

ret = re.findall(r'hello\b', 'hello, you is cat? ')   # 匹配出你想要的且是一個單詞的內容
print(ret)      # ['hello']

search() 方法：     匹配出第一個知足條件的結果

ret = re.search('lo', 'hello, youlo? ')   # 匹配出你想要的且是一個單詞的內容
print(ret)   # <_sre.SRE_Match object; span=(3, 5), match='lo'>
print(ret.group())   # lo

ret = re.search('a.', 'asd')
print(ret.group())   # as

ret = re.search(r'a\.', 'asd')   # 報錯，由於被索引字符串裏面沒有"."

print(ret.group())   # AttributeError: 'NoneType' object has no attribute 'group'

ret = re.search(r'a\.', 'a.sd')
print(ret.group())   # a.

ret = re.search(r'a\+', 'a+sd')
print(ret.group())   # a+

ret = re.search(r'\\c', r'asd\c')   # \\不加r會報錯
print(ret.group())   # \c

ret = re.search(r'\\', r'asd\c')   # \\不加r會報錯
print(ret.group())   # \

注意：加r是告訴python解釋器，\\就是原生字符，不須要轉義，就直接把2個\送給re模塊

ret = re.search('\\\\', r'asd\c')   # 等同於上面的語句，
print(ret.group())   # \c

注意：由於在python解釋器裏面\也是有特殊意義的,因此當傳入4個\時，python解釋器經過轉義，變爲2個\，而後傳給re模塊；在re模塊裏面，\一樣是有特殊意義，因此把2個\轉義爲1個\,而後進行匹配

5、() ：分組    |：或

ret = re.search('(as)+', r'asasd\c')   # 匹配括號裏面一個組的字符，而不是單個字符
print(ret.group())   # asas

ret = re.findall(r'www.(\w+).com', 'www.123swd.com')   # 涉及到組時，只會把組裏面的內容匹配出來
print(ret)   # ['123swd']

ret = re.findall(r'www.(?:\w+).com', 'www.123swd.com')   # 加問號冒號（?:）取消組的優先級
print(ret)   # ['www.123swd.com']

ret = re.search('(as)|', r'asd35')   # 匹配括號裏面一個組的字符，而不是單個字符
print(ret.group())   # as

ret = re.search('(as)|3', r'asd35')   # as或3，優先匹配第一個，誰在前輸出誰
print(ret.group())   # as

ret = re.search('(as)|3', r'3as5e')
print(ret.group())   # 3

3、稍複雜一點兒的正則

ret = re.search(r'(?P<id>\d{3})', 'asdsf124c4vss7').group('id')  # 給匹配到的三個數字起一個名字，叫id；?<名字>是固定寫法
print(ret)      # 124

# 後面匹配項只能是 '數字/數字或字母' 的形式，/前的一個字符必定不能爲字母
ret = re.search(r'(?P<id>\d{3})/(?P<name>\w{3})', 'wa124/bug')
print(ret.group())      # 124/bug
print(ret.group('id'))      # 124
print(ret.group('name'))    # bug

ret = re.match('asd', 'sdsasd')
print(ret)    # None

ret = re.split('s', 'qwesdc')   # 經過s對後面的字符串進行分割
print(ret)  # ['qwe', 'dc']

ret = re.split('[eh]', 'qwesdhtrc')   # 先經過e對後面的字符串進行分割，而後經過h對前面分割開的兩部分繼續分割
print(ret)  # ['qw', 'sd', 'trc']

ret = re.split('[eh]', 'hqwesdhtrc')
print(ret)  # ['', 'qw', 'sd', 'trc']   列表第一個元素爲空，是由於字符串h前面沒有其餘的字符

ret = re.sub('臭豬', '小baby', '雙雙是臭豬')    # ('原內容', '新內容', '對象')
print(ret)  # 雙雙是小baby

ret = re.subn('臭豬', '小baby', '雙雙是臭豬，小臭豬')    # ('原內容', '新內容', '對象')，該方法會輸出替換的次數
print(ret)  # ('雙雙是小baby，小小baby', 2)

ret = re.sub('q..s', 's..z', 'zaqwesf')    # ('原內容', '新內容', '操做對象')
print(ret)  # zas..zf


ret = re.findall(r'\.com', 'adsdas.comasdaf')
print(ret)      # ['.com']

obj = re.compile(r'\.com')   # 爲了不重複，把規則編譯爲一個對象，下次使用只需調用對象便可
ret = obj.findall('adsdas.comasdaf')   # 等價於 re.findall(r'\.com', 'adsdas.comasdaf')
print(ret)      # ['.com']

ret = re.finditer(r'\d', 'a2da7f')   # 把結果封裝爲一個迭代器，既此時ret爲一個迭代器
print(ret)      # <callable_iterator object at 0x000001E3DDFF1320>
print(next(ret))    # <_sre.SRE_Match object; span=(1, 2), match='2'>
print(next(ret).group())    # 2