正則表示式 (Regular Expression) 又稱 RegEx, 是用來匹配字元的一種工具. 在一大串字元中尋找你需要的內容. 它常被用在很多方面, 比如網頁爬蟲, 文稿整理, 資料篩選等等. 最簡單的一個例子, 比如我需要爬取網頁中每一頁的標題. 而網頁中的標題常常是這種形式.

<title>我是標題</ title>

而且每個網頁的標題各不相同, 我就能使用正則表示式, 用一種簡單的匹配方法, 一次性選取出成千上萬網頁的標題資訊. 正則表示式絕對不是一天就能學會和記住的, 因為表示式裡面的內容非常多, 強烈建議, 現在這個階段, 你只需要瞭解正則裡都有些什麼, 不用記住, 等到你真正需要用到它的時候, 再反過頭來, 好好琢磨琢磨, 那個時候才是你需要訓練自己記住這些表示式的時候.

簡單的匹配

正則表示式無非就是在做這麼一回事. 在文字中找到特定的內容, 比如下面的內容. 我們在 “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

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 regular expression
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'>

小抄

為了大家方便記憶, 我很久以前在網上找到了一份小抄, 這個小抄的原出處應該是這裡. 小抄很有用, 不記得的時候回頭方便看.