Python re「正則表達式解析」
當我們學會了如何用 Requests 來獲取網頁的原始碼，得到 HTML 程式碼。但我們如何從 HTML 程式碼中獲取真正想要的數據呢？
正則表達式就是一個有效的方法。
本文，我分享正則表達式的相關用法。正則表達式是處理字串的強大工具，它有自己特定的語法結構。有了它，我們就能實現字串的檢索、替換、匹配驗證。
當然，對於爬蟲來說，有了它，要從 HTML 裡提取想要的資訊就非常方便了。
1. 範例引入
說了這麼多，可能我們對正則表達式的概念還是比較模糊，下面 下麪就用幾個範例來看一下正則表達式的用法。
開啓開源中國提供的正則表達式測試工具 http://tool.oschina.net/regex/，輸入待匹配的文字，然後選擇常用的正則表達式，就可以得出相應的匹配結果了。
例如，輸入下面 下麪這段待匹配的文字：
Hello, my phone number is 010-86432100 and email is cqc@cuiqingcai.com, and my website is https://cuiqingcai.com.
這段字串中包含了一個電話號碼和一個電子郵件，接下來就嘗試用正則表達式提取出來，如圖所示。
在網頁右側選擇 「匹配 Email 地址」，就可以看到下方出現了文字中的 E-mail。如果選擇 「匹配網址 URL」，就可以看到下方出現了文字中的 URL。是不是非常神奇？
其實，這裏使用了正則表達式的匹配功能，也就是用一定規則將特定的文字提取出來。
比方說，電子郵件是有其特定的組成格式的：一段字串 + @ 符號 + 某個域名。而 URL的組成格式則是協定型別 + 冒號加雙斜線 + 域名和路徑。
可以用下面 下麪的正則表達式匹配 URL：
[a-zA-z]+://[^\s]*
用這個正則表達式去匹配一個字串，如果這個字串中包含類似 URL 的文字，那就會被提取出來。
這個看上去亂糟糟的正則表達式其實有特定的語法規則。比如，a-z 匹配任意的小寫字母，\s 匹配任意的空白字元，* 匹配前面任意多個字元。這一長串的正則表達式就是這麼多匹配規則的組合。
寫好正則表達式後，就可以拿它去一個長字串裡匹配查詢了。不論這個字串裏面有什麼，只要符合我們寫的規則，統統可以找出來。對於網頁來說，如果想找出網頁原始碼裡有多少 URL，用 URL 的正則表達式去匹配即可。
下表中列出了常用的匹配規則：
| 模式 | 描述 |
|---|---|
| \w | 匹配字母、數位及下劃線 |
| \W | 匹配不是字母、數位及下劃線的字元 |
| \s | 匹配任意空白字元，等價於 [\t\n\r\f] |
| \S | 匹配任意非空字元 |
| \d | 匹配任意數位，等價於 [0~9] |
| \D | 匹配任意非數位的字元 |
| \A | 匹配字串開頭 |
| \Z | 匹配字串結尾，如果存在換行，只匹配到換行前的結束字串 |
| \z | 匹配字串結尾，如果存在換行，同時還會匹配換行符 |
| \G | 匹配最後匹配完成的位置 |
| \n | 匹配一個換行符 |
| \t | 匹配一個製表符 |
| ^ | 匹配一行字串的開頭 |
| $ | 匹配一行字串的結尾 |
| . | 匹配任意字元，除了換行符，當 re.DOTALL 標記被指定時，則可以匹配包括換行符的任意字元 |
| […] | 用來表示一組字元，單獨列出，比如 [amk] 匹配 a、m 或 k |
| [^…] | 不在 [] 中的字元，比如 匹配除了 a、b、c 之外的字元 |
| * | 匹配 0 個或多個表達式 |
| + | 匹配 1 個或多個表達式 |
| ? | 匹配 0 個或 1 個前面的正則表達式定義的片段，非貪婪方式 |
| {n} | 精確匹配 n 個前面的表達式 |
| {n, m} | 匹配 n 到 m 次由前面正則表達式定義的片段，貪婪方式 |
| a|b | 匹配 a 或 b |
| () | 匹配括號內的表達式，也表示一個組 |
看完之後，你可能有點暈暈的吧，不用擔心，後面我們會詳細講解一些常見規則的用法。
其實正則表達式不是 Python 獨有的，它也可以用在其他程式語言中。但是 Python 的 re 庫提供了整個正則表達式的實現，利用這個庫，可以在 Python 中使用正則表達式。
在 Python 中寫正則表達式幾乎都用這個庫，下面 下麪就來了解它的一些常用方法。
2. match
首先介紹一個常用的匹配方法 —— match，向它傳入要匹配的字串，以及正則表達式，就可以檢測這個正則表達式是否匹配字串。
match 方法會嘗試從字串的起始位置匹配正則表達式，如果匹配，就返回匹配成功的結果；如果不匹配，就返回 None。
範例如下：
import re
content = 'Hello 123 4567 World_This is a Regex Demo'
print(len(content))
result = re.match('^Hello\s\d\d\d\s\d{4}\s\w{10}', content)
print(result)
print(result.group())
print(result.span())
執行結果如下：
41
<_sre.SRE_Match object; span=(0, 25), match='Hello 123 4567 World_This'>
Hello 123 4567 World_This
(0, 25)
這裏首先宣告瞭一個字串，其中包含英文字母、空白字元、數位等。接下來，我們寫一個正則表達式：
^Hello\s\d\d\d\s\d{4}\s\w{10}
用它來匹配這個長字串。開頭的 ^ 匹配字串的開頭，也就是以 Hello 開頭； \s 匹配空白字元，用來匹配目標字串的空格；\d 匹配數位，3 個 \d 匹配 123；再寫 1 個 \s 匹配空格；後面的 4567，其實依然能用 4 個 \d 來匹配，但是這麼寫比較煩瑣，所以後面可以跟 {4} 代表匹配前面的規則 4 次，也就是匹配 4 個數字；後面再緊接 1 個空白字元，最後 \w{10} 匹配 10 個字母及下劃線。
我們注意到，這裏並沒有把目標字串匹配完，不過依然可以進行匹配，只不過匹配結果短一點而已。
而在 match 方法中，第一個參數傳入正則表達式，第二個參數傳入要匹配的字串。
列印輸出結果，可以看到結果是 SRE_Match 物件，這證明成功匹配。該物件有兩個方法：group 方法可以輸出匹配的內容，結果是 Hello 123 4567 World_This，這恰好是正則表達式規則所匹配的內容；span 方法可以輸出匹配的範圍，結果是 (0, 25)，這就是匹配到的結果字串在原字串中的位置範圍。
通過上面的例子，我們基本瞭解瞭如何在 Python 中使用正則表達式來匹配一段文字。
3. 匹配目標
剛纔我們用 match 方法得到了匹配到的字串內容，但當我們想從字串中提取一部分內容，該怎麼辦呢？
就像最前面的範例一樣，要從一段文字中提取出郵件或電話號碼等內容。我們可以使用 () 括號將想提取的子字串括起來。() 實際上標記了一個子表達式的開始和結束位置，被標記的每個子表達式會依次對應每一個分組，呼叫 group 方法傳入分組的索引即可獲取提取的結果。
範例如下：
import re
content = 'Hello 1234567 World_This is a Regex Demo'
result = re.match('^Hello\s(\d+)\sWorld', content)
print(result)
print(result.group())
print(result.group(1))
print(result.span())
這裏我們想把字串中的 1234567 提取出來，此時可以將數位部分的正則表達式用 () 括起來，然後呼叫了 group(1) 獲取匹配結果。
執行結果如下：
<_sre.SRE_Match object; span=(0, 19), match='Hello 1234567 World'>
Hello 1234567 World
1234567
(0, 19)
可以看到，我們成功得到了 1234567。這裏用的是 group(1)，它與 group() 有所不同，後者會輸出完整的匹配結果，而前者會輸出第一個被 () 包圍的匹配結果。假如正則表達式後面還有 () 包括的內容，那麼可以依次用 group(2)、group(3) 等來獲取。
4. 通用匹配
剛纔我們寫的正則表達比較複雜，出現空白字元我們就寫 \s 匹配，出現數字我們就用 \d 匹配，這樣的工作量非常大。
我們還可以用一個萬能匹配來減少這些工作，那就是 .*。其中 . 可以匹配任意字元（除換行符），* 代表匹配前面的字元無限次，它們組合在一起就可以匹配任意字元了。有了它，我們就不用挨個字元的匹配了。
接着上面的例子，我們可以改寫一下正則表達式：
import re
content = 'Hello 123 4567 World_This is a Regex Demo'
result = re.match('^Hello.*Demo$', content)
print(result)
print(result.group())
print(result.span())
這裏我們將中間部分直接省略，全部用 .* 來代替，最後加一個結尾字元就好了。
執行結果如下：
<_sre.SRE_Match object; span=(0, 41), match='Hello 123 4567 World_This is a Regex Demo'>
Hello 123 4567 World_This is a Regex Demo
(0, 41)
可以看到，group 方法輸出了匹配的全部字串，也就是說我們寫的正則表達式匹配到了目標字串的全部內容；span 方法輸出 (0, 41)，這是整個字串的長度。
因此，我們可以使用 .* 簡化正則表達式的書寫。
5. 貪婪與非貪婪
使用上面的通用匹配 .* 時，有時候匹配到的並不是我們想要的結果。
看下面 下麪的例子：
import re
content = 'Hello 1234567 World_This is a Regex Demo'
result = re.match('^He.*(\d+).*Demo$', content)
print(result)
print(result.group(1))
這裏我們依然想獲取中間的數位，所以中間依然寫的是 (\d+)。由於數位兩側的內容比較雜亂，所以略寫成 .*。最後，組成 ^He.*(\d+).*Demo$，看樣子並沒有什麼問題。
我們看下執行結果：
<_sre.SRE_Match object; span=(0, 40), match='Hello 1234567 World_This is a Regex Demo'>
7
奇怪的事情發生了，我們只得到了 7 這個數位，這是怎麼回事呢？
這裏就涉及一個貪婪匹配與非貪婪匹配的問題了。在貪婪匹配下，.* 會匹配儘可能多的字元。正則表達式中 .* 後面是 \d+，也就是至少一個數字，並沒有指定具體多少個數字，因此，.* 就儘可能匹配多的字元，這裏就把 123456 匹配了，給 \d+ 留下一個可滿足條件的數位 7，最後得到的內容就只有數位 7 了。
這顯然會給我們帶來很大的不便。有時候，匹配結果會莫名其妙少了一部分內容。其實，這裏只需要使用非貪婪匹配就好了。非貪婪匹配的寫法是 .*?，多了一個 ？，那麼它可以達到怎樣的效果？
我們再用範例看一下：
import re
content = 'Hello 1234567 World_This is a Regex Demo'
result = re.match('^He.*?(\d+).*Demo$', content)
print(result)
print(result.group(1))
這裏我們只是將第一個.* 改成了 .*?，轉變爲非貪婪匹配。
結果如下：
<_sre.SRE_Match object; span=(0, 40), match='Hello 1234567 World_This is a Regex Demo'>
1234567
此時就可以成功獲取 1234567 了。原因可想而知，貪婪匹配是儘可能匹配多的字元，非貪婪匹配就是儘可能匹配少的字元。當 .*? 匹配到 Hello 後面的空白字元時，再往後的字元就是數位了，而 \d+ 恰好可以匹配，那麼 .*? 就不再進行匹配，交給 \d+ 去匹配後面的數位。這樣 .*? 匹配了儘可能少的字元，\d+ 的結果就是 1234567 了。
所以，在做匹配的時候，字串中間儘量使用非貪婪匹配，也就是用 .*? 來代替 .*，以免出現匹配結果缺失的情況。
但需要注意的是，如果匹配的結果在字串結尾，.*? 就有可能匹配不到任何內容了，因爲它會匹配儘可能少的字元。例如：
import re
content = 'http://weibo.com/comment/kEraCN'
result1 = re.match('http.*?comment/(.*?)', content)
result2 = re.match('http.*?comment/(.*)', content)
print('result1', result1.group(1))
print('result2', result2.group(1))
執行結果如下：
result1
result2 kEraCNimport re
content = '''Hello 1234567 World_This
is a Regex Demo
'''
result = re.match('^He.*?(\d+).*?Demo$', content)
print(result.group(1))
可以觀察到，.*? 沒有匹配到任何結果，而 .* 則儘量匹配多的內容，成功得到了匹配結果。
6. 修飾符
正則表達式可以包含一些可選標誌修飾符來控制匹配的模式。修飾符被指定爲一個可選的標誌。
我們用範例來看一下：
import re
content = '''Hello 1234567 World_This
is a Regex Demo
'''
result = re.match('^He.*?(\d+).*?Demo$', content)
print(result.group(1))
和上面的例子相仿，我們在字串中加了換行符，正則表達式還是一樣的，用來匹配其中的數位。看一下執行結果：
AttributeError Traceback (most recent call last)
<ipython-input-18-c7d232b39645> in <module>()
5 '''
6 result = re.match('^He.*?(\d+).*?Demo$', content)
----> 7 print(result.group(1))
AttributeError: 'NoneType' object has no attribute 'group'
執行直接報錯，也就是說正則表達式沒有匹配到這個字串，返回結果爲 None，而我們又呼叫了 group 方法導致 AttributeError。
爲什麼加了一個換行符，就匹配不到了呢？
這是因爲我們匹配的是除換行符之外的任意字元，當遇到換行符時，.*? 就不能匹配了，導致匹配失敗。
這裏只需加一個修飾符 re.S，即可修正這個錯誤：
result = re.match('^He.*?(\d+).*?Demo$', content, re.S)
這個修飾符的作用是匹配包括換行符在內的所有字元。
此時執行結果如下：
1234567
這個 re.S 在網頁匹配中經常用到。因爲 HTML 節點經常會有換行，加上它，就可以匹配節點與節點之間的換行了。
另外，還有一些修飾符，在必要的情況下也可以使用，如表所示：
| 修飾符 | 描 述 |
|---|---|
| re.I | 使匹配對大小寫不敏感 |
| re.L | 做在地化識別（locale-aware）匹配 |
| re.M | 多行匹配，影響 ^ 和 $ |
| re.S | 使匹配包括換行在內的所有字元 |
| re.U | 根據 Unicode 字元集解析字元。這個標誌影響 \w、\W、\b 和 \B |
| re.X | 該標誌通過給予你更靈活的格式以便你將正則表達式寫得更易於理解 |
在網頁匹配中，較爲常用的修飾符有 re.S 和 re.I。
7. 跳脫匹配
我們知道正則表達式定義了許多匹配模式，如匹配除換行符以外的任意字元，但如果目標字串裏面就包含 .，那該怎麼辦呢？
這裏就需要用到跳脫匹配了，範例如下：
import re
content = '(百度) www.baidu.com'
result = re.match('\(百度 \) www\.baidu\.com', content)
print(result)
當遇到用於正則匹配模式的特殊字元時，在前面加反斜線跳脫一下即可。例 . 就可以用 . 來匹配。
執行結果如下：
<_sre.SRE_Match object; span=(0, 17), match='(百度) www.baidu.com'>
可以看到，這裏成功匹配到了原字串。
這些是寫正則表達式常用的幾個知識點，熟練掌握它們對後面寫正則表達式匹配非常有幫助。
8. search
前面提到過，match 方法是從字串的開頭開始匹配的，一旦開頭不匹配，那麼整個匹配就失敗了。
我們看下面 下麪的例子：
import re
content = 'Extra stings Hello 1234567 World_This is a Regex Demo Extra stings'
result = re.match('Hello.*?(\d+).*?Demo', content)
print(result)
這裏的字串以 Extra 開頭，但是正則表達式以 Hello 開頭，整個正則表達式是字串的一部分，但是這樣匹配是失敗的。
執行結果如下：
None
因爲 match 方法在使用時需要考慮到開頭的內容，這在做匹配時並不方便。它更適合用來檢測某個字串是否符合某個正則表達式的規則。
這裏有另外一個方法 search，它在匹配時會掃描整個字串，然後返回第一個成功匹配的結果。也就是說，正則表達式可以是字串的一部分，在匹配時，search 方法會依次掃描字串，直到找到第一個符合規則的字串，然後返回匹配內容，如果搜尋完了還沒有找到，就返回 None。
我們把上面程式碼中的 match 方法修改成 search，再看下執行結果：
<_sre.SRE_Match object; span=(13, 53), match='Hello 1234567 World_This is a Regex Demo'>
1234567
這時就得到了匹配結果。
因此，爲了匹配方便，我們可以儘量使用 search 方法。
下面 下麪再用幾個範例來看看 search 方法的用法。
這裏有一段待匹配的 HTML 文字，接下來我們寫幾個正則表達式範例來實現相應資訊的提取：
html = '''<div id="songs-list">
<h2 class="title">經典老歌</h2>
<p class="introduction">
經典老歌列表
</p>
<ul id="list" class="list-group">
<li data-view="2">一路上有你</li>
<li data-view="7">
<a href="/2.mp3" singer="任賢齊">滄海一聲笑</a>
</li>
<li data-view="4" class="active">
<a href="/3.mp3" singer="齊秦">往事隨風</a>
</li>
<li data-view="6"><a href="/4.mp3" singer="beyond">光輝歲月</a></li>
<li data-view="5"><a href="/5.mp3" singer="陳慧琳">記事本</a></li>
<li data-view="5">
<a href="/6.mp3" singer="鄧麗君">但願人長久</a>
</li>
</ul>
</div>'''
可以觀察到，ul 節點裏有許多 li 節點，其中 li 節點中有的包含 a 節點，有的不包含 a 節點，a 節點還有一些相應的屬性 —— 超鏈接和歌手名。
首先，我們嘗試提取 class爲 active 的 li 節點內部超鏈接包含的歌手名和歌名，此時需要提取第三個 li 節點下 a 節點的 singer 屬性和文字。
此時，正則表達式可以用 li 開頭，然後尋找一個標誌符 active，中間的部分可以用 .*? 來匹配。
接下來，要提取 singer 這個屬性值，所以還需要寫入 singer=「(.*?)"，這裏需要提取的部分用小括號括起來，以便用 group 方法提取出來，它的兩側邊界是雙引號。
然後還需要匹配 a 節點的文字，其中它的左邊界是 >，右邊界是 </a>。目標內容依然用 (.*?) 來匹配，所以最後的正則表達式就變成了：
<li.*?active.*?singer="(.*?)">(.*?)</a>
然後再呼叫 search 方法，它會搜尋整個 HTML 文字，找到符合正則表達式的第一個內容返回。
另外，由於程式碼有換行，所以這裏第三個參數需要傳入 re.S。整個匹配程式碼如下：
result = re.search('<li.*?active.*?singer="(.*?)">(.*?)</a>', html, re.S)
if result:
print(result.group(1), result.group(2))
由於需要獲取的歌手和歌名都已經用小括號包圍，所以可以用 group 方法獲取。
執行結果如下：
齊秦 往事隨風
可以看到，這正是 class 爲 active 的 li 節點內部的超鏈接包含的歌手名和歌名。
如果正則表達式不加 active（也就是匹配不帶 class 爲 active 的節點內容），那會怎樣呢？我們將正則表達式中的 active 去掉。
程式碼改寫如下：
result = re.search('<li.*?singer="(.*?)">(.*?)</a>', html, re.S)
if result:
print(result.group(1), result.group(2))
由於 search 方法會返回第一個符合條件的匹配目標，這裏結果就變了：
任賢齊 滄海一聲笑
把 active 標籤去掉後，從字串開頭開始搜尋，此時符合條件的節點就變成了第二個 li 節點，後面的不再匹配，所以執行結果變成第二個 li 節點中的內容。
注意，在上面的兩次匹配中，search 方法的第三個參數都加了 re.S，這使得 .*? 可以匹配換行，所以含有換行的 li 節點被匹配到了。如果我們將其去掉，結果會是什麼？
程式碼如下：
result = re.search('<li.*?singer="(.*?)">(.*?)</a>', html)
if result:
print(result.group(1), result.group(2))
執行結果如下：
beyond 光輝歲月
可以看到，結果變成了第四個 li 節點的內容。這是因爲第二個和第三個 li 節點都包含了換行符，去掉 re.S 之後，.*? 已經不能匹配換行符，所以正則表達式不會匹配到第二個和第三個 li 節點，而第四個 li 節點中不包含換行符，所以成功匹配。
由於絕大部分的 HTML 文字都包含了換行符，所以儘量都需要加上 re.S 修飾符，以免出現匹配不到的問題。
9. findall
前面我們介紹了 search 方法的用法，它可以返回匹配正則表達式的第一個內容，但是如果想要獲取匹配正則表達式的所有內容，那該怎麼辦呢？這時就要藉助 findall 方法了。
該方法會搜尋整個字串，然後返回匹配正則表達式的所有內容。
還是上面的 HTML 文字，如果想獲取所有 a 節點的超鏈接、歌手和歌名，就可以將 search 方法換成 findall 方法。如果有返回結果的話，就是列表型別，所以需要遍歷一下來依次獲取每組內容。
程式碼如下：
results = re.findall('<li.*?href="(.*?)".*?singer="(.*?)">(.*?)</a>', html, re.S)
print(results)
print(type(results))
for result in results:
print(result)
print(result[0], result[1], result[2])
執行結果如下：
[('/2.mp3', ' 任賢齊 ', ' 滄海一聲笑 '), ('/3.mp3', ' 齊秦 ', ' 往事隨風 '), ('/4.mp3', 'beyond', ' 光輝歲月 '), ('/5.mp3', ' 陳慧琳 ', ' 記事本 '), ('/6.mp3', ' 鄧麗君 ', ' 但願人長久 ')]
<class 'list'>
('/2.mp3', ' 任賢齊 ', ' 滄海一聲笑 ')
/2.mp3 任賢齊 滄海一聲笑
('/3.mp3', ' 齊秦 ', ' 往事隨風 ')
/3.mp3 齊秦 往事隨風
('/4.mp3', 'beyond', ' 光輝歲月 ')
/4.mp3 beyond 光輝歲月
('/5.mp3', ' 陳慧琳 ', ' 記事本 ')
/5.mp3 陳慧琳 記事本
('/6.mp3', ' 鄧麗君 ', ' 但願人長久 ')
/6.mp3 鄧麗君 但願人長久
可以看到，返回的列表中的每個元素都是元組型別，我們用對應的索引依次取出即可。
如果只是獲取第一個內容，可以用 search 方法。當需要提取多個內容時，可以用 findall 方法。
10. sub
除了使用正則表達式提取資訊外，有時候還需要藉助它來修改文字。比如，想要把一串文字中的所有數位都去掉，如果只用字串的 replace 方法，那就太煩瑣了，這時可以藉助 sub 方法。
範例如下：
import re
content = '54aK54yr5oiR54ix5L2g'
content = re.sub('\d+', '', content)
print(content)
執行結果如下：
aKyroiRixLg
這裏只需要給第一個參數傳入 \d+ 來匹配所有的數位，第二個參數替換成的字串（如果去掉該參數的話，可以賦值爲空），第三個參數是原字串。
在上面的 HTML 文字中，如果想獲取所有 li 節點的歌名，直接用正則表達式來提取可能比較煩瑣。比如，可以寫成這樣子：
results = re.findall('<li.*?>\s*?(<a.*?>)?(\w+)(</a>)?\s*?</li>', html, re.S)
for result in results:
print(result[1])
執行結果如下：
一路上有你
滄海一聲笑
往事隨風
光輝歲月
記事本
但願人長久
此時藉助 sub 方法就比較簡單了。可以先用 sub 方法將 a 節點去掉，只留下文字，然後再利用 findall 提取就好了：
html = re.sub('<a.*?>|</a>', '', html)
print(html)
results = re.findall('<li.*?>(.*?)</li>', html, re.S)
for result in results:
print(result.strip())
執行結果如下：
<div id="songs-list">
<h2 class="title"> 經典老歌 </h2>
<p class="introduction">
經典老歌列表
</p>
<ul id="list" class="list-group">
<li data-view="2"> 一路上有你 </li>
<li data-view="7">
滄海一聲笑
</li>
<li data-view="4" class="active">
往事隨風
</li>
<li data-view="6"> 光輝歲月 </li>
<li data-view="5"> 記事本 </li>
<li data-view="5">
但願人長久
</li>
</ul>
</div>
一路上有你
滄海一聲笑
往事隨風
光輝歲月
記事本
但願人長久
可以看到，a 節點經過 sub 方法處理後就沒有了，隨後我們通過 findall 方法直接提取即可。
通過以上例子，你會發現，在適當的時候，藉助 sub 方法可以起到事半功倍的效果。
11. compile
前面所講的方法都是用來處理字串的方法，最後再介紹一下 compile 方法，這個方法可以將正則字串編譯成正則表達式物件，以便在後面的匹配中複用。
範例程式碼如下：
import re
content1 = '2019-12-15 12:00'
content2 = '2019-12-17 12:55'
content3 = '2019-12-22 13:21'
pattern = re.compile('\d{2}:\d{2}')
result1 = re.sub(pattern, '', content1)
result2 = re.sub(pattern, '', content2)
result3 = re.sub(pattern, '', content3)
print(result1, result2, result3)
這裏有 3 個日期，我們想分別將 3 個日期中的時間去掉，這時可以藉助 sub 方法。該方法的第一個參數是正則表達式，但是我們沒有必要重複寫 3 個同樣的正則表達式。此時可以藉助 compile 方法將正則表達式編譯成一個正則表達式物件，以便複用。
執行結果如下：
2019-12-15 2019-12-17 2019-12-22
另外，compile 還可以傳入修飾符，例如 re.S 等修飾符，這樣在 search、findall 等方法中就不需要額外傳了。所以，compile 方法可以說是給正則表達式做了一層封裝，以便我們更好的複用。
歡迎關注公衆號：AI悅創，搶先閱讀。