背景

頁面解析和資料提取

一般來講對我們而言，需要抓取的是某個網站或者某個應用的內容，提取有用的價值。內容一般分為兩部分，非結構化的資料 和 結構化的資料。

非結構化資料：先有資料，再有結構，
結構化資料：先有結構、再有資料
不同型別的資料，我們需要採用不同的方式來處理。

文字、電話號碼、郵箱地址

正則表示式

HTML 檔案

正則表示式
XPath
CSS選擇器

結構化的資料處理
JSON 檔案

JSON Path
轉化成Python型別進行操作（json類）

XML 檔案

轉化成Python型別（xmltodict）
XPath
CSS選擇器
正則表示式
 

對於以上bs4 的beautifulsoup 也是不錯的

為何要學習正則表示式

實際上爬蟲一共就四個主要步驟：

明確目標 (要知道你準備在哪個範圍或者網站去搜索)
爬 (將所有的網站的內容全部爬下來)
取 (去掉對我們沒用處的資料)
處理資料（按照我們想要的方式儲存和使用）

那麼對於文字的過濾或者規則的匹配，最強大的就是正則表示式，是Python爬蟲世界裡必不可少的神兵利器。

什麼是正則表示式

正則表示式，又稱規則表示式，通常被用來檢索、替換那些符合某個模式(規則)的文字。

正則表示式是對字串操作的一種邏輯公式，就是用事先定義好的一些特定字元、及這些特定字元的組合，組成一個“規則字串”，這個“規則字串”用來表達對字串的一種過濾邏輯。
 

給定一個正則表示式和另一個字串，我們可以達到如下的目的：

    給定的字串是否符合正則表示式的過濾邏輯（“匹配”）；
    通過正則表示式，從文字字串中獲取我們想要的特定部分（“過濾”）。

正則表示式匹配規則

Python 的re 模組

在Python 中可以使用Python 來使用正則表示式
有一點要注意 正則表示式使用對特殊字元進行轉義。 所以如果要使用原始字串， 只需要加一個r 字首

r'chuanzhiboke\t\.\tpython'

re 模組的一般使用步驟如下：

1. 使用 compile() 函式將正則表示式的字串形式編譯為一個 Pattern 物件
2. 通過 Pattern 物件提供的一系列方法對文字進行匹配查詢，獲得匹配結果，一個 Match 物件。
3. 最後使用 Match 物件提供的屬性和方法獲得資訊，根據需要進行其他的操作
 

compile 函式

compile 函式用於編譯正則表示式，生成一個 Pattern 物件，它的一般使用形式如下

import re

# 將正則表示式編譯成 Pattern 物件
pattern = re.compile(r'\d+')

在上面，我們已將一個正則表示式編譯成 Pattern 物件，接下來，我們就可以利用 pattern 的一系列方法對文字進行匹配查找了。

Pattern 物件的一些常用方法主要有：

    1. match 方法：從起始位置開始查詢，一次匹配
   2.  search 方法：從任何位置開始查詢，一次匹配
   3.  findall 方法：全部匹配，返回列表
   4. finditer 方法：全部匹配，返回迭代器
   5.  split 方法：分割字串，返回列表
   6.  sub 方法：替換

match 方法

import re
 pattern = re.compile(r'\d+')  # 用於匹配至少一個數字

>>> m = pattern.match('one12twothree34four')  # 查詢頭部，沒有匹配
>>> print m
None

>>> m = pattern.match('one12twothree34four', 2, 10) # 從'e'的位置開始匹配，沒有匹配
>>> print m
None

>>> m = pattern.match('one12twothree34four', 3, 10) # 從'1'的位置開始匹配，正好匹配
>>> print m                                         # 返回一個 Match 物件
<_sre.SRE_Match object at 0x10a42aac0>

>>> m.group(0)   # 可省略 0
'12'
>>> m.start(0)   # 可省略 0
3
>>> m.end(0)     # 可省略 0
5
>>> m.span(0)    # 可省略 0
(3, 5)

在上面，當匹配成功時返回一個 Match 物件，其中：

group([group1, …]) 方法用於獲得一個或多個分組匹配的字串，當要獲得整個匹配的子串時，可直接使用 group() 或 group(0)；

start([group]) 方法用於獲取分組匹配的子串在整個字串中的起始位置（子串第一個字元的索引），引數預設值為 0；
end([group]) 方法用於獲取分組匹配的子串在整個字串中的結束位置（子串最後一個字元的索引+1），引數預設值為 0；
span([group]) 方法返回 (start(group), end(group))。

再看看一個例子：

>>> import re
>>> pattern = re.compile(r'([a-z]+) ([a-z]+)', re.I)  # re.I 表示忽略大小寫
>>> m = pattern.match('Hello World Wide Web')

>>> print m     # 匹配成功，返回一個 Match 物件
<_sre.SRE_Match object at 0x10bea83e8>

>>> m.group(0)  # 返回匹配成功的整個子串
'Hello World'

>>> m.span(0)   # 返回匹配成功的整個子串的索引
(0, 11)

>>> m.group(1)  # 返回第一個分組匹配成功的子串
'Hello'

>>> m.span(1)   # 返回第一個分組匹配成功的子串的索引
(0, 5)

>>> m.group(2)  # 返回第二個分組匹配成功的子串
'World'

>>> m.span(2)   # 返回第二個分組匹配成功的子串
(6, 11)

>>> m.groups()  # 等價於 (m.group(1), m.group(2), ...)
('Hello', 'World')

>>> m.group(3)   # 不存在第三個分組
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: no such group

search 方法

search 方法用於查詢字串的任何位置，它也是一次匹配，只要找到了一個匹配的結果就返回，而不是查詢所有匹配的結果，它的一般使用形式如下：

search(string[, pos[, endpos]])

其中，string 是待匹配的字串，pos 和 endpos 是可選引數，指定字串的起始和終點位置，預設值分別是 0 和 len (字串長度)。

當匹配成功時，返回一個 Match 物件，如果沒有匹配上，則返回 None。

讓我們看看例子：

>>> import re
>>> pattern = re.compile('\d+')
>>> m = pattern.search('one12twothree34four')  # 這裡如果使用 match 方法則不匹配
>>> m
<_sre.SRE_Match object at 0x10cc03ac0>
>>> m.group()
'12'
>>> m = pattern.search('one12twothree34four', 10, 30)  # 指定字串區間
>>> m
<_sre.SRE_Match object at 0x10cc03b28>
>>> m.group()
'34'
>>> m.span()
(13, 15)

# -*- coding: utf-8 -*-

import re
# 將正則表示式編譯成 Pattern 物件
pattern = re.compile(r'\d+')
# 使用 search() 查詢匹配的子串，不存在匹配的子串時將返回 None
# 這裡使用 match() 無法成功匹配
m = pattern.search('hello 123456 789')
if m:
    # 使用 Match 獲得分組資訊
    print 'matching string:',m.group()
    # 起始位置和結束位置
    print 'position:',m.span()

列印結果

matching string: 123456
position: (6, 12)

findall 方法

上面的 match 和 search 方法都是一次匹配，只要找到了一個匹配的結果就返回。然而，在大多數時候，我們需要搜尋整個字串，獲得所有匹配的結果。

findall 方法的使用形式如下：

findall(string[, pos[, endpos]])

其中，string 是待匹配的字串，pos 和 endpos 是可選引數，指定字串的起始和終點位置，預設值分別是 0 和 len (字串長度)。

findall 以列表形式返回全部能匹配的子串，如果沒有匹配，則返回一個空列表。

看看例子：

import re
pattern = re.compile(r'\d+')   # 查詢數字

result1 = pattern.findall('hello 123456 789')
result2 = pattern.findall('one1two2three3four4', 0, 10)

print result1
print result2

執行結果

['123456', '789']
['1', '2']

再看一個

# re_test.py

import re

#re模組提供一個方法叫compile模組，提供我們輸入一個匹配的規則
#然後返回一個pattern例項，我們根據這個規則去匹配字串
pattern = re.compile(r'\d+\.\d*')

#通過partten.findall()方法就能夠全部匹配到我們得到的字串
result = pattern.findall("123.141593, 'bigcat', 232312, 3.15")

#findall 以 列表形式 返回全部能匹配的子串給result
for item in result:
    print item

結果

123.141593
3.15

finditer 方法

finditer 方法的行為跟 findall 的行為類似，也是搜尋整個字串，獲得所有匹配的結果。但它返回一個順序訪問每一個匹配結果（Match 物件）的迭代器。

看看例子：

# -*- coding: utf-8 -*-

import re
pattern = re.compile(r'\d+')

result_iter1 = pattern.finditer('hello 123456 789')
result_iter2 = pattern.finditer('one1two2three3four4', 0, 10)

print type(result_iter1)
print type(result_iter2)

print 'result1...'
for m1 in result_iter1:   # m1 是 Match 物件
    print 'matching string: {}, position: {}'.format(m1.group(), m1.span())

print 'result2...'
for m2 in result_iter2:
    print 'matching string: {}, position: {}'.format(m2.group(), m2.span())

result

<type 'callable-iterator'>
<type 'callable-iterator'>
result1...
matching string: 123456, position: (6, 12)
matching string: 789, position: (13, 16)
result2...
matching string: 1, position: (3, 4)
matching string: 2, position: (7, 8)

split 方法

split 方法按照能夠匹配的子串將字串分割後返回列表，它的使用形式如下：

split(string[, maxsplit])

其中，maxsplit 用於指定最大分割次數，不指定將全部分割。

import re
p = re.compile(r'[\s\,\;]+')
print p.split('a,b;; c   d')

result

['a', 'b', 'c', 'd']

sub 方法

sub 方法用於替換。它的使用形式如下：

sub(repl, string[, count])

其中，repl 可以是字串也可以是一個函式：

如果 repl 是字串，則會使用 repl 去替換字串每一個匹配的子串，並返回替換後的字串，另外，repl 還可以使用 id 的形式來引用分組，但不能使用編號 0；

如果 repl 是函式，這個方法應當只接受一個引數（Match 物件），並返回一個字串用於替換（返回的字串中不能再引用分組）。
count 用於指定最多替換次數，不指定時全部替換。

看看例子：

import re
p = re.compile(r'(\w+) (\w+)') # \w = [A-Za-z0-9]
s = 'hello 123, hello 456'

print p.sub(r'hello world', s)  # 使用 'hello world' 替換 'hello 123' 和 'hello 456'
print p.sub(r'\2 \1', s)        # 引用分組

def func(m):
    return 'hi' + ' ' + m.group(2)

print p.sub(func, s)
print p.sub(func, s, 1)         # 最多替換一次

result

hello world, hello world
123 hello, 456 hello
hi 123, hi 456
hi 123, hello 456

匹配中文

在某些情況下，我們想匹配文字中的漢字，有一點需要注意的是，中文的 unicode 編碼範圍 主要在 [u4e00-u9fa5]，這裡說主要是因為這個範圍並不完整，比如沒有包括全形（中文）標點，不過，在大部分情況下，應該是夠用的。

假設現在想把字串 title = u’你好，hello，世界’ 中的中文提取出來，可以這麼做：

import re

title = u'你好，hello，世界'
pattern = re.compile(ur'[\u4e00-\u9fa5]+')
result = pattern.findall(title)

print result

注意到，我們在正則表示式前面加上了兩個字首 ur，其中 r 表示使用原始字串，u 表示是 unicode 字串。

執行結果:
[u'\u4f60\u597d', u'\u4e16\u754c']

注意：貪婪模式與非貪婪模式

貪婪模式：在整個表示式匹配成功的前提下，儘可能多的匹配 ( * )；
非貪婪模式：在整個表示式匹配成功的前提下，儘可能少的匹配 ( ? )；
Python裡數量詞預設是貪婪的。

示例一 ： 源字串：abbbc

使用貪婪的數量詞的正則表示式 ab* ，匹配結果： abbb。

    * 決定了儘可能多匹配 b，所以a後面所有的 b 都出現了。

使用非貪婪的數量詞的正則表示式ab*?，匹配結果： a。

    即使前面有 *，但是 ? 決定了儘可能少匹配 b，所以沒有 b。

示例二 ： 源字串：aa

test1bbtest2cc

使用貪婪的數量詞的正則表示式：<div>.*</div>

匹配結果：<div>test1</div>bb<div>test2</div>

這裡採用的是貪婪模式。在匹配到第一個“</div>”時已經可以使整個表示式匹配成功，但是由於採用的是貪婪模式，所以仍然要向右嘗試匹配，檢視是否還有更長的可以成功匹配的子串。匹配到第二個“</div>”後，向右再沒有可以成功匹配的子串，匹配結束，匹配結果為“<div>test1</div>bb<div>test2</div>”

使用非貪婪的數量詞的正則表示式：<div>.*?</div>

匹配結果：<div>test1</div>

正則表示式二採用的是非貪婪模式，在匹配到第一個“</div>”時使整個表示式匹配成功，由於採用的是非貪婪模式，所以結束匹配，不再向右嘗試，匹配結果為“<div>test1</div>”。

爬取內涵段子使用re 來獲取需要資料
根據正則表示式，我們可以推算出一個公式是:

<div.*?class="f18 mb20">(.*?)</div>

    這個表示式實際上就是匹配到所有div中class="f18 mb20 裡面的內容(具體可以看前面正則介紹)

    然後將這個正則應用到程式碼中，我們會得到以下程式碼：

  def loadPage(self, page):
    """
        @brief 定義一個url請求網頁的方法
        @param page 需要請求的第幾頁
        @returns 返回的頁面html
    """

    url = "http://www.neihan8.com/article/list_5_" + str(page)
+ ".html"
    #User-Agent頭
    user_agent = 'Mozilla/5.0 (compatible; MSIE 9.0; Windows NT
6.1; Trident/5.0'
    headers = {'User-Agent': user_agent}
    req = urllib2.Request(url, headers = headers)
    response = urllib2.urlopen(req)
    html = response.read()
    gbk_html = html.decode('gbk').encode('utf-8')

    #找到所有的段子內容<div class = "f18 mb20"></div>
    #re.S 如果沒有re.S 則是隻匹配一行有沒有符合規則的字串，如果沒有則下一行重新匹配
    # 如果加上re.S 則是將所有的字串將一個整體進行匹配
    pattern = re.compile(r'<div.*?class="f18 mb20">(.*?)</di
v>', re.S)
    item_list = pattern.findall(gbk_html)

    return item_list


def printOnePage(self, item_list, page):
    """
        @brief 處理得到的段子列表
        @param item_list 得到的段子列表
        @param page 處理第幾頁
    """

    print "******* 第 %d 頁 爬取完畢...*******" %page
    for item in item_list:
        print "================"
        print ite

    這裡需要注意一個是re.S是正則表示式中匹配的一個引數。

    如果 沒有re.S 則是 只匹配一行 有沒有符合規則的字串，如果沒有則下一行重新匹配。
    如果 加上re.S 則是將 所有的字串 將一個整體進行匹配，findall 將所有匹配到的結果封裝到一個list中。