Python3網絡爬蟲實戰---2六、正則表達式

上一篇文章： Python3網絡爬蟲實戰---2五、requests：高級用法
下一篇文章：

本節咱們看一下正則表達式的相關用法，正則表達式是處理字符串的強大的工具，它有本身特定的語法結構，有了它，實現字符串的檢索、替換、匹配驗證都不在話下。
固然對於爬蟲來講，有了它，咱們從 HTML 裏面提取咱們想要的信息就很是方便了。

1. 實例引入

說了這麼多，可能咱們對它究竟是個什麼仍是比較模糊，下面咱們就用幾個實例來感覺一下正則表達式的用法。
咱們打開開源中國提供的正則表達式測試工具：http://tool.oschina.net/regex/，打開以後咱們能夠輸入待匹配的文本，而後選擇經常使用的正則表達式，就能夠從咱們輸入的文本中得出相應的匹配結果了。
例如咱們在這裏輸入待匹配的文本以下：

Hello, my phone number is 010-86432100 and email is cqc@cuiqingcai.com, 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	匹配任意空白字符，等價於 [tnrf].
S	匹配任意非空字符
d	匹配任意數字，等價於 [0-9]
D	匹配任意非數字
A	匹配字符串開始
Z	匹配字符串結束，若是是存在換行，只匹配到換行前的結束字符串
z	匹配字符串結束
G	匹配最後匹配完成的位置
n	匹配一個換行符
t	匹配一個製表符
^	匹配字符串的開頭
$	匹配字符串的末尾
.	匹配任意字符，除了換行符，當 re.DOTALL 標記被指定時，則能夠匹配包括換行符的任意字符
[...]	用來表示一組字符，單獨列出：[amk] 匹配 'a'，'m' 或 'k'
1	不在 [] 中的字符：abc 匹配除了 a,b,c 以外的字符。
*	匹配 0 個或多個的表達式。
+	匹配 1 個或多個的表達式。
?	匹配 0 個或 1 個由前面的正則表達式定義的片斷，非貪婪方式
{n}	精確匹配 n 個前面表達式。
{n, m}	匹配 n 到 m 次由前面的正則表達式定義的片斷，貪婪方式
ab	匹配 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
<re.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) 獲取匹配結果。

運行結果以下：

<re.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())

在這裏咱們將中間的部分直接省略，所有用 .* 來代替，最後加一個結尾字符串就行了，運行結果以下：

<re.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$，看樣子並無什麼問題，咱們看下運行結果：

<re.Match object; span=(0, 41), match='Hello 123 4567 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))

在這裏咱們只是將第一個 . 改爲了 .?，轉變爲非貪婪匹配。結果以下：

<re.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: '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()，再看下運行結果：

<re.Match object; span=(13, 53), match='Hello 1234567 World_This is a Regex Demo'>

這樣就獲得了匹配結果。

因此說，爲了匹配方便，咱們能夠儘可能使用 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>|<i.*?>|</i>', '', 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. 結語

到此爲止，正則表達式的基本用法就介紹完畢了，後面咱們會有實戰來說解正則表達式的使用。

---

1. ... ↩