5-1正則基本知識詳解
3.3 正則表示式
本節我們看一下正則表示式的相關用法，正則表示式是處理字串的強大的工具，它有自己特定的語法結構，有了它，實現字串的檢索、替換、匹配驗證都不在話下。
當然對於爬蟲來說，有了它，我們從 HTML 裡面提取我們想要的資訊就非常方便了。
1. 例項引入
說了這麼多，可能我們對它到底是個什麼還是比較模糊，下面我們就用幾個例項來感受一下正則表示式的用法。
我們開啟開源中國提供的正則表示式測試工具：http://tool.oschina.net/regex/，開啟之後我們可以輸入待匹配的文字，然後選擇常用的正則表示式，就可以從我們輸入的文字中得出相應的匹配結果了。
例如我們在這裡輸入待匹配的文字如下：
Hello, my phone number is 010-86432100 and email is [email protected], and my website is http://cuiqingcai.com.
這段字串中包含了一個電話號碼和一個電子郵件，接下來我們就嘗試用正則表示式提取出來，如圖 3-10 所示：
圖 3-10 執行頁面
我們在網頁中選擇匹配 Email 地址，就可以看到在下方出現了文字中的 Email。如果我們選擇了匹配網址 URL，就可以看到在下方出現了文字中的 URL。是不是非常神奇？
其實，在這裡就是用了正則表示式匹配，也就是用了一定的規則將特定的文字提取出來。比如電子郵件它開頭是一段字串，然後是一個 @ 符號，然後就是某個域名，這是有特定的組成格式的。另外對於 URL，開頭是協議型別，然後是冒號加雙斜線，然後是域名加路徑。
對於 URL 來說，我們就可以用下面的正則表示式匹配：
[a-zA-z]+://[^\s]*
如果我們用這個正則表示式去匹配一個字串，如果這個字串中包含類似 URL 的文字，那就會被提取出來。
這個正則表示式看上去是亂糟糟的一團，其實不然，這裡面都是有特定的語法規則的。比如 a-z 代表匹配任意的小寫字母，\s 表示匹配任意的空白字元，* 就代表匹配前面的字元任意多個，這一長串的正則表示式就是這麼多匹配規則的組合，最後實現特定的匹配功能。
寫好正則表示式後，我們就可以拿它去一個長字串裡匹配查找了，不論這個字串裡面有什麼，只要符合我們寫的規則，統統可以找出來。那麼對於網頁來說，如果我們想找出網頁原始碼裡有多少 URL，就可以用匹配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' | |
[^...] |
不在 [] 中的字元：abc 匹配除了 a,b,c 之外的字元。 | |
* |
匹配 0 個或多個的表示式。 | |
+ |
匹配 1 個或多個的表示式。 | |
? |
匹配 0 個或 1 個由前面的正則表示式定義的片段，非貪婪方式 | |
{n} |
精確匹配 n 個前面表示式。 | |
{n, m} |
匹配 n 到 m 次由前面的正則表示式定義的片段，貪婪方式 | |
| `a | b` | 匹配 a 或 b |
( ) |
匹配括號內的表示式，也表示一個組 |
可能看完了之後就有點暈暈的了把，不用擔心，下面我們會詳細講解下一些常見的規則的用法。怎麼用它來從網頁中提取我們想要的資訊。
2. 瞭解 re 庫
其實正則表示式不是 Python 獨有的，它在其他程式語言中也可以使用，但是 Python 的 re 庫提供了整個正則表示式的實現，利用 re 庫我們就可以在 Python 中使用正則表示式了，在 Python 中寫正則表示式幾乎都是用的這個庫，下面我們就來了解下它的一些常用方法。
3. 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 中怎樣使用正則表示式來匹配一段文字。
匹配目標
剛才我們用了 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() 會輸出完整的匹配結果，而 group(1) 會輸出第一個被 () 包圍的匹配結果，假如正則表示式後面還有 () 包括的內容，那麼我們可以依次用 group(2)、group(3) 等來依次獲取。
通用匹配
剛才我們寫的正則表示式其實比較複雜，出現空白字元我們就寫 \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)，是整個字串的長度。
因此，我們可以在使用 .* 來簡化正則表示式的書寫。
貪婪與非貪婪
在使用上面的通用匹配 .* 的時候可能我們有時候匹配到的並不是想要的結果，我們看下面的例子：
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，所以 \d+ 得到的內容就只有數字 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 了。原因可想而知，貪婪匹配是儘可能匹配多的字元，非貪婪匹配就是儘可能匹配少的字元，.*? 之後是 \d+ 用來匹配數字，當 .*? 匹配到 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 kEraCN
觀察到 .*? 沒有匹配到任何結果，而 .* 則儘量匹配多的內容，成功得到了匹配結果。
所以在這裡好好體會一下貪婪匹配和非貪婪匹配的原理，對後面寫正則表示式非常有幫助。
修飾符
正則表示式可以包含一些可選標誌修飾符來控制匹配的模式。修飾符被指定為一個可選的標誌。
我們用一個例項先來感受一下：
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)
在 match() 方法的第三個引數傳入 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。
轉義匹配
我們知道正則表示式定義了許多匹配模式，如 . 匹配除換行符以外的任意字元，但是如果目標字串裡面它就包含 . 我們改怎麼匹配？
那麼這裡就需要用到轉義匹配了，我們用一個例項來感受一下：
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'>
可以看到成功匹配到了原字串。
以上是寫正則表示式常用的幾個知識點，熟練掌握上面的知識點對後面我們寫正則表示式匹配非常有幫助。
4. 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="鄧麗君"><i class="fa fa-user"></i>但願人長久</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() 方法獲取，序號依次對應 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 修飾符，以免出現匹配不到的問題。
5. findall()
在前面我們說了 search() 方法的用法，它可以返回匹配正則表示式的第一個內容，但是如果我們想要獲取匹配正則表示式的所有內容的話怎麼辦？這時就需要藉助於 findall() 方法了。
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() 方法。
6. 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() 方法做一些相應處理可以事半功倍。
7. compile()
前面我們所講的方法都是用來處理字串的方法，最後再介紹一個 compile() 方法，這個方法可以講正則字串編譯成正則表示式物件，以便於在後面的匹配中複用。
import re
content1 = '2016-12-15 12:00'
content2 = '2016-12-17 12:55'
content3 = '2016-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)
例如這裡有三個日期，我們想分別將三個日期中的時間去掉，所以在這裡我們可以藉助於 sub() 方法，sub() 方法的第一個引數是正則表示式，但是這裡我們沒有必要重複寫三個同樣的正則表示式，所以可以藉助於 compile() 方法將正則表示式編譯成一個正則表示式物件，以便複用。
執行結果：
2016-12-15 2016-12-17 2016-12-22
另外 compile() 還可以傳入修飾符，例如 re.S 等修飾符，這樣在 search()、findall() 等方法中就不需要額外傳了。所以 compile() 方法可以說是給正則表示式做了一層封裝，以便於我們更好地複用。
8. 結語
到此為止，正則表示式的基本用法就介紹完畢了，後面我們會有實戰來講解正則表示式的使用。