|
|
| \w | 匹配字母（包含中文）或數字或下劃線 |
| \W | 匹配非字母（包含中文）或數字或下劃線 |
| \s | 匹配任意的 空白符 如： 空格 \t \n |
| \S | 匹配任意非空白符 |
| \d | 匹配數字 |
| \D | p匹配非數字 |
| \A | 從字符串開頭匹配 |
| \z | 匹配字符串的結束，如果是換行，只匹配到換行前的結果 |
| \n | 匹配一個換行符 |
| \t | 匹配一個製表符 |
| ^ | 匹配字符串的開始 |
| $ | 匹配字符串的結尾 |
| . | 匹配任意字符，除了換行符，當re.DOTALL標記被指定時，則可以匹配包括換行符的任意字符。 |
| [...] | 匹配字符組中的字符 |
| [^...] | 匹配除了字符組中的字符的所有字符 |
| * | 匹配0個或者多個左邊的字符。 |
| + | 匹配一個或者多個左邊的字符。 |
| ？ | 匹配0個或者1個左邊的字符，非貪婪方式。 有一個絕對不兩個，，一般一個一個字符走 |
| {n} | 精準匹配n個前面的表達式。 |
| {n,m} | 匹配n到m次由前面的正則表達式定義的片段，貪婪方式 |
| a|b | 匹配a或者b。 |
| () | 匹配括號內的表達式，也表示一個組 |
元字符
【】 字符組，一箇中括號只能匹配一個字符 表示在一個位置上可以出現的字符
【^ 】 非字符組 中號裏面的字符不可以出現，除了字符組中的字符都可以匹配成功，也是一個字符一個字符匹配
^ 匹配字符串的開頭 只能出現在 開頭
$ 匹配字符串的結尾 只能出現在 結尾
^ 字符串 $ 則限制 匹配的字符串的長度 必須和 這兩個符號之間的長度相等
（） 變成一組 也屬於元字符 ————身份證號
（） \1 \2 表示前面第一個名爲1的分組，和第二個小括號的分組
量詞：
貪婪模式：（按照對大情況匹配）
如： 苗.{1,3} 能匹配三個就匹配三個，實在不行就兩個，最後纔會選擇一個
在能匹配上的情況儘量匹配多的
{3} 表示前面那個字符重複三次 只約束前面那個元字符
{3，} 表示至少重複三次
{3，5} 表示至少匹配三次，最多匹配五次 能匹配五次就會匹配五次
？ （其實就是表示前面那個元字符可有可無） 表示前面的元字符 匹配零次或一次 \d.?\d 表示 可以匹配 2.3 或 23
* 重複零次或更多次 所有
+ 重複一次或更多次 相當於 {1，}
？的使用：
所有量詞都可以加 ？
在量詞的後面跟了一個 ？ 取消 貪婪匹配，變成非貪婪模式（惰性）。。。按小的匹配
如： 苗.{1,3} 就只匹配一個 。。。在能匹配上的情況儘量匹配少的
最常用 .*?x 匹配任意字符直到找到一個x
總結
元字符
元字符量詞 默認貪婪匹配
元字符量詞？ 表示惰性匹配
find: 字符串匹配
s1 = 'Python是一門簡單的語言'
print(s1.find('簡單'))
# 9
# 匹配滿足的第一個字符的索引
# 2，正則匹配：
# 單個字符匹配
import re
# \w 與 \W
# print(re.findall('\w', '寶元meet 12*() _')) # ['寶', '元', 'j', 'x', '1', '2', '_']
# print(re.findall('\W', '寶元meet 12*() _')) # [' ', '*', '(', ')', ' ']
# \s 與\S
# print(re.findall('\s','寶元barry*(_ \t \n')) # [' ', '\t', ' ', '\n']
# print(re.findall('\S','寶元barry*(_ \t \n')) # ['寶', '元', 'b', 'a', 'r', 'r', 'y', '*', '(', '_']
# \d 與 \D
# print(re.findall('\d','1234567890 alex *（_')) # ['1', '2', '3', '4', '5', '6', '7', '8', '9', '0']
# print(re.findall('\D','1234567890 alex *（_')) # [' ', 'a', 'l', 'e', 'x', ' ', '*', '（', '_']
# \A 與 ^
# print(re.findall('\Ahel','hello 寶元 -_- 666')) # ['hel']
# print(re.findall('^hel','hello 寶元 -_- 666')) # ['hel']
# \Z、\z 與 $
# print(re.findall('666\Z','hello 寶元 *-_-* \n666')) # ['666']
# print(re.findall('666\z','hello 寶元 *-_-* \n666')) # []
# print(re.findall('666$','hello 寶元 *-_-* \n666')) # ['666']
# \n 與 \t
# print(re.findall('\n','hello \n 寶元 \t*-_-*\t \n666')) # ['\n', '\n']
# print(re.findall('\t','hello \n 寶元 \t*-_-*\t \n666')) # ['\t', '\t']
# 重複匹配
# . ? * + {m,n} .* .*?
# . 匹配任意字符，除了換行符（re.DOTALL 這個參數可以匹配\n）。
# print(re.findall('a.b', 'ab aab a*b a2b a牛b a\nb')) # ['aab', 'a*b', 'a2b', 'a牛b']
# print(re.findall('a.b', 'ab aab a*b a2b a牛b a\nb',re.DOTALL)) # ['aab', 'a*b', 'a2b', 'a牛b']
# ？匹配0個或者1個由左邊字符定義的片段。
# print(re.findall('a?b', 'ab aab abb aaaab a牛b aba**b')) # ['ab', 'ab', 'ab', 'b', 'ab', 'b', 'ab', 'b']
# * 匹配0個或者多個左邊字符表達式。 滿足貪婪匹配 @@
# print(re.findall('a*b', 'ab aab aaab abbb')) # ['ab', 'aab', 'aaab', 'ab', 'b', 'b']
# print(re.findall('ab*', 'ab aab aaab abbbbb')) # ['ab', 'a', 'ab', 'a', 'a', 'ab', 'abbbbb']
# + 匹配1個或者多個左邊字符表達式。 滿足貪婪匹配 @@
# print(re.findall('a+b', 'ab aab aaab abbb')) # ['ab', 'aab', 'aaab', 'ab']
# {m,n} 匹配m個至n個左邊字符表達式。 滿足貪婪匹配 @@
# print(re.findall('a{2,4}b', 'ab aab aaab aaaaabb')) # ['aab', 'aaab']
# .* 貪婪匹配 從頭到尾.
# print(re.findall('a.*b', 'ab aab a*()b')) # ['ab aab a*()b']
# .*? 此時的?不是對左邊的字符進行0次或者1次的匹配,
# 而只是針對.*這種貪婪匹配的模式進行一種限定:告知他要遵從非貪婪匹配 推薦使用!
# print(re.findall('a.*?b', 'ab a1b a*()b, aaaaaab')) # ['ab', 'a1b', 'a*()b']
# []: 括號中可以放任意一個字符,一箇中括號代表一個字符
# - 在[]中表示範圍,如果想要匹配上- 那麼這個-符號不能放在中間.
# ^ 在[]中表示取反的意思.
# print(re.findall('a.b', 'a1b a3b aeb a*b arb a_b')) # ['a1b', 'a3b', 'a4b', 'a*b', 'arb', 'a_b']
# print(re.findall('a[abc]b', 'aab abb acb adb afb a_b')) # ['aab', 'abb', 'acb']
# print(re.findall('a[0-9]b', 'a1b a3b aeb a*b arb a_b')) # ['a1b', 'a3b']
# print(re.findall('a[a-z]b', 'a1b a3b aeb a*b arb a_b')) # ['aeb', 'arb']
# print(re.findall('a[a-zA-Z]b', 'aAb aWb aeb a*b arb a_b')) # ['aAb', 'aWb', 'aeb', 'arb']
# print(re.findall('a[0-9][0-9]b', 'a11b a12b a34b a*b arb a_b')) # ['a11b', 'a12b', 'a34b']
# print(re.findall('a[*-+]b','a-b a*b a+b a/b a6b')) # ['a*b', 'a+b']
# - 在[]中表示範圍,如果想要匹配上- 那麼這個-符號不能放在中間.
# print(re.findall('a[-*+]b','a-b a*b a+b a/b a6b')) # ['a-b', 'a*b', 'a+b']
# print(re.findall('a[^a-z]b', 'acb adb a3b a*b')) # ['a3b', 'a*b']
# 練習:
# 找到字符串中'alex_sb ale123_sb wu12sir_sb wusir_sb ritian_sb' 的 alex wusir ritian
# print(re.findall('([a-z]+)_sb','alex_sb ale123_sb wusir12_sb wusir_sb ritian_sb'))
# 分組:
# () 制定一個規則,將滿足規則的結果匹配出來
# print(re.findall('(.*?)_sb', 'alex_sb wusir_sb 日天_sb')) # ['alex', ' wusir', ' 日天']
# 應用舉例:
# print(re.findall('href="(.*?)"','<a href="http://www.baidu.com">點擊</a>'))#['http://www.baidu.com']
# | 匹配 左邊或者右邊
# print(re.findall('alex|太白|wusir', 'alex太白wusiraleeeex太太白odlb')) # ['alex', '太白', 'wusir', '太白']
# print(re.findall('compan(y|ies)','Too many companies have gone bankrupt, and the next one is my company')) # ['ies', 'y']
# print(re.findall('compan(?:y|ies)','Too many companies have gone bankrupt, and the next one is my company')) # ['companies', 'company']
# 分組() 中加入?: 表示將整體匹配出來而不只是()裏面的內容。
常用方法舉例
import re
#1 findall 全部找到返回一個列表。
# print(re.findall('a', 'alexwusirbarryeval')) # ['a', 'a', 'a']
# 2 search 只到找到第一個匹配然後返回一個包含匹配信息的對象,該對象可以通過調用group()方法得到匹配的字符串,如果字符串沒有匹配，則返回None。
# print(re.search('sb|alex', 'alex sb sb barry 日天')) # <_sre.SRE_Match object; span=(0, 4), match='alex'>
# print(re.search('alex', 'alex sb sb barry 日天').group()) # alex
# 3 match：None,同search,不過在字符串開始處進行匹配,完全可以用search+^代替match
# print(re.match('barry', 'barry alex wusir 日天')) # <_sre.SRE_Match object; span=(0, 5), match='barry'>
# print(re.match('barry', 'barry alex wusir 日天').group()) # barry
# 4 split 分割 可按照任意分割符進行分割
# print(re.split('[ ：:,;；，]','alex wusir,日天，太白;女神;肖鋒：吳超')) # ['alex', 'wusir', '日天', '太白', '女神', '肖鋒', '吳超']
# 5 sub 替換
# print(re.sub('barry', '太白', 'barry是最好的講師，barry就是一個普通老師，請不要將barry當男神對待。'))
# 太白是最好的講師，太白就是一個普通老師，請不要將太白當男神對待。
# print(re.sub('barry', '太白', 'barry是最好的講師，barry就是一個普通老師，請不要將barry當男神對待。',2))
# 太白是最好的講師，太白就是一個普通老師，請不要將barry當男神對待。
# 6
# obj=re.compile('\d{2}')
#
# print(obj.search('abc123eeee').group()) #12
# print(obj.findall('abc123eeee')) #['12'],重用了obj
# import re
# ret = re.finditer('\d', 'ds3sy4784a') #finditer返回一個存放匹配結果的迭代器
# print(ret) # <callable_iterator object at 0x10195f940>
# print(next(ret).group()) #查看第一個結果
# print(next(ret).group()) #查看第二個結果
# print([i.group() for i in ret]) #查看剩餘的結果
命名分組舉例
# 命名分組匹配：
ret = re.search("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>")
# #還可以在分組中利用?<name>的形式給分組起名字
# #獲取的匹配結果可以直接用group('名字')拿到對應的值
# print(ret.group('tag_name')) #結果 ：h1
# print(ret.group()) #結果 ：<h1>hello</h1>
#
# ret = re.search(r"<(\w+)>\w+</\1>","<h1>hello</h1>")
# #如果不給組起名字，也可以用\序號來找到對應的組，表示要找的內容和前面的組內容一致
# #獲取的匹配結果可以直接用group(序號)拿到對應的值
# print(ret.group(1))
# print(ret.group()) #結果 ：<h1>hello</h1>
re.compile("正則語句") #返回一個re對象，其實就是將此正則語句提前聲明，下面代碼都可以使用。
import re
string = "<p>我是誰</p>"
pattern = re.compile(r"<(\w+)>.*</\1>")
ret = pattern.search(string)
print(ret.group())