原文鏈接：https://morvanzhou.github.io/tutorials/python-basic/basic/13-10-regular-expression/
一、簡單的匹配
正則表達式無非就是在做這麼一回事. 在文字中找到特定的內容, 比如下面的內容. 我們在 “dog runs to cat” 這句話中尋找是否存在 “cat” 或者 “bird”.
# matching string
pattern1 = "cat"
pattern2 = "bird"
string = "dog runs to cat"
print(pattern1 in string) # True
print(pattern2 in string) # False
但是正則表達式絕非不止這樣簡單的匹配, 它還能做更加高級的內容. 要使用正則表達式, 首先需要調用一個 python 的內置模塊 re. 然後我們重複上面的步驟, 不過這次使用正則. 可以看出, 如果 re.search() 找到了結果, 它會返回一個 match 的 object. 如果沒有匹配到, 它會返回 None. 這個 re.search() 只是 re 中的一個功能, 之後會介紹其它的功能.
import re
# regular expression
pattern1 = "cat"
pattern2 = "bird"
string = "dog runs to cat"
print(re.search(pattern1, string)) # <_sre.SRE_Match object; span=(12, 15), match='cat'>
print(re.search(pattern2, string)) # None
二、靈活匹配
除了上面的簡單匹配, 下面的內容纔是正則的核心內容, 使用特殊的 pattern 來靈活匹配需要找的文字.
如果需要找到潛在的多個可能性文字, 我們可以使用 [] 將可能的字符囊括進來. 比如 [ab] 就說明我想要找的字符可以是 a 也可以是 b. 這裏我們還需要注意的是, 建立一個正則的規則, 我們在 pattern 的 “” 前面需要加上一個 r 用來表示這是正則表達式, 而不是普通字符串. 通過下面這種形式, 如果字符串中出現 “run” 或者是 “ran”, 它都能找到.
# multiple patterns ("run" or "ran")
ptn = r"r[au]n" # start with "r" means raw string
print(re.search(ptn, "dog runs to cat")) # <_sre.SRE_Match object; span=(4, 7), match='run'>
同樣, 中括號 [] 中還可以是以下這些或者是這些的組合. 比如 [A-Z] 表示的就是所有大寫的英文字母. [0-9a-z] 表示可以是數字也可以是任何小寫字母.
print(re.search(r"r[A-Z]n", "dog runs to cat")) # None
print(re.search(r"r[a-z]n", "dog runs to cat")) # <_sre.SRE_Match object; span=(4, 7), match='run'>
print(re.search(r"r[0-9]n", "dog r2ns to cat")) # <_sre.SRE_Match object; span=(4, 7), match='r2n'>
print(re.search(r"r[0-9a-z]n", "dog runs to cat")) # <_sre.SRE_Match object; span=(4, 7), match='run'>
三、按類型匹配
除了自己定義規則, 還有很多匹配的規則時提前就給你定義好了的. 下面有一些特殊的匹配類型給大家先總結一下, 然後再上一些例子.
\d : 任何數字
\D : 不是數字
\s : 任何 white space, 如 [\t\n\r\f\v]
\S : 不是 white space
\w : 任何大小寫字母, 數字和 “” [a-zA-Z0-9]
\W : 不是 \w
\b : 空白字符 (只在某個字的開頭或結尾)
\B : 空白字符 (不在某個字的開頭或結尾)
\ : 匹配
. : 匹配任何字符 (除了 \n)
^ : 匹配開頭
$ : 匹配結尾
? : 前面的字符可有可無
下面就是具體的舉例說明啦.
# \d : decimal digit
print(re.search(r"r\dn", "run r4n")) # <_sre.SRE_Match object; span=(4, 7), match='r4n'>
# \D : any non-decimal digit
print(re.search(r"r\Dn", "run r4n")) # <_sre.SRE_Match object; span=(0, 3), match='run'>
# \s : any white space [\t\n\r\f\v]
print(re.search(r"r\sn", "r\nn r4n")) # <_sre.SRE_Match object; span=(0, 3), match='r\nn'>
# \S : opposite to \s, any non-white space
print(re.search(r"r\Sn", "r\nn r4n")) # <_sre.SRE_Match object; span=(4, 7), match='r4n'>
# \w : [a-zA-Z0-9_]
print(re.search(r"r\wn", "r\nn r4n")) # <_sre.SRE_Match object; span=(4, 7), match='r4n'>
# \W : opposite to \w
print(re.search(r"r\Wn", "r\nn r4n")) # <_sre.SRE_Match object; span=(0, 3), match='r\nn'>
# \b : empty string (only at the start or end of the word)
print(re.search(r"\bruns\b", "dog runs to cat")) # <_sre.SRE_Match object; span=(4, 8), match='runs'>
# \B : empty string (but not at the start or end of a word)
print(re.search(r"\B runs \B", "dog runs to cat")) # <_sre.SRE_Match object; span=(8, 14), match=' runs '>
# \\ : match \
print(re.search(r"runs\\", "runs\ to me")) # <_sre.SRE_Match object; span=(0, 5), match='runs\\'>
# . : match anything (except \n)
print(re.search(r"r.n", "r[ns to me")) # <_sre.SRE_Match object; span=(0, 3), match='r[n'>
# ^ : match line beginning
print(re.search(r"^dog", "dog runs to cat")) # <_sre.SRE_Match object; span=(0, 3), match='dog'>
# $ : match line ending
print(re.search(r"cat$", "dog runs to cat")) # <_sre.SRE_Match object; span=(12, 15), match='cat'>
# ? : may or may not occur
print(re.search(r"Mon(day)?", "Monday")) # <_sre.SRE_Match object; span=(0, 6), match='Monday'>
print(re.search(r"Mon(day)?", "Mon")) # <_sre.SRE_Match object; span=(0, 3), match='Mon'>
如果一個字符串有很多行, 我們想使用 ^ 形式來匹配行開頭的字符, 如果用通常的形式是不成功的. 比如下面的 “I” 出現在第二行開頭, 但是使用 r"^I" 卻匹配不到第二行, 這時候, 我們要使用 另外一個參數, 讓 re.search() 可以對每一行單獨處理. 這個參數就是 flags=re.M, 或者這樣寫也行 flags=re.MULTILINE.
string = """
dog runs to cat.
I run to dog.
"""
print(re.search(r"^I", string)) # None
print(re.search(r"^I", string, flags=re.M)) # <_sre.SRE_Match object; span=(18, 19), match='I'>
四、重複匹配
如果我們想讓某個規律被重複使用, 在正則裏面也是可以實現的, 而且實現的方式還有很多. 具體可以分爲這三種:
* : 重複零次或多次
+ : 重複一次或多次
{n, m} : 重複 n 至 m 次
{n} : 重複 n 次
舉例如下:
# * : occur 0 or more times
print(re.search(r"ab*", "a")) # <_sre.SRE_Match object; span=(0, 1), match='a'>
print(re.search(r"ab*", "abbbbb")) # <_sre.SRE_Match object; span=(0, 6), match='abbbbb'>
# + : occur 1 or more times
print(re.search(r"ab+", "a")) # None
print(re.search(r"ab+", "abbbbb")) # <_sre.SRE_Match object; span=(0, 6), match='abbbbb'>
# {n, m} : occur n to m times
print(re.search(r"ab{2,10}", "a")) # None
print(re.search(r"ab{2,10}", "abbbbb")) # <_sre.SRE_Match object; span=(0, 6), match='abbbbb'>
五、分組
我們甚至可以爲找到的內容分組, 使用 () 能輕鬆實現這件事. 通過分組, 我們能輕鬆定位所找到的內容. 比如在這個 (\d+) 組裏, 需要找到的是一些數字, 在 (.+) 這個組裏, 我們會找到 “Date: “ 後面的所有內容. 當使用 match.group() 時, 他會返回所有組裏的內容, 而如果給 .group(2) 里加一個數, 它就能定位你需要返回哪個組裏的信息.
match = re.search(r"(\d+), Date: (.+)", "ID: 021523, Date: Feb/12/2017")
print(match.group()) # 021523, Date: Feb/12/2017
print(match.group(1)) # 021523
print(match.group(2)) # Date: Feb/12/2017
有時候, 組會很多, 光用數字可能比較難找到自己想要的組, 這時候, 如果有一個名字當做索引, 會是一件很容易的事. 我們字需要在括號的開頭寫上這樣的形式 ?P<名字> 就給這個組定義了一個名字. 然後就能用這個名字找到這個組的內容.
match = re.search(r"(?P<id>\d+), Date: (?P<date>.+)", "ID: 021523, Date: Feb/12/2017")
print(match.group('id')) # 021523
print(match.group('date')) # Date: Feb/12/2017
六、findall
前面我們說的都是隻找到了最開始匹配上的一項而已, 如果需要找到全部的匹配項, 我們可以使用 findall 功能. 然後返回一個列表. 注意下面還有一個新的知識點, | 是 or 的意思, 要不是前者要不是後者.
# findall
print(re.findall(r"r[ua]n", "run ran ren")) # ['run', 'ran']
# | : or
print(re.findall(r"(run|ran)", "run ran ren")) # ['run', 'ran']
七、replace
我們還能通過正則表達式匹配上一些形式的字符串然後再替代掉這些字符串. 使用這種匹配 re.sub(), 將會比 python 自帶的 string.replace() 要靈活多變.
print(re.sub(r"r[au]ns", "catches", "dog runs to cat")) # dog catches to cat
八、split
再來我們 Python 中有個字符串的分割功能, 比如想獲取一句話中所有的單詞. 比如 “a is b”.split(" "), 這樣它就會產生一個列表來保存所有單詞. 但是在正則中, 這種普通的分割也可以做的淋漓精緻.
print(re.split(r"[,;\.]", "a;b,c.d;e")) # ['a', 'b', 'c', 'd', 'e']
九、compile
最後, 我們還能使用 compile 過後的正則, 來對這個正則重複使用. 先將正則 compile 進一個變量, 比如 compiled_re, 然後直接使用這個 compiled_re 來搜索.
compiled_re = re.compile(r"r[ua]n")
print(compiled_re.search("dog ran to cat")) # <_sre.SRE_Match object; span=(4, 7), match='ran'>
十、小抄
爲了大家方便記憶, 我很久以前在網上找到了一份小抄, 這個小抄的原出處應該是這裏. 小抄很有用, 不記得的時候回頭方便看.
