摘要：爬取百思不得姐首先一步一步來，我們先從爬最簡單的文本開始。將百思不得姐段子保存到中別忘了將管道加到配置文件中。雖然我只是簡單的爬了百思不得姐，不過這些方法可以應用到其他方面，爬取更多更有用的數據。

前一篇文章介紹了很多關于scrapy的進階知識，不過說歸說，只有在實際應用中才能真正用到這些知識。所以這篇文章就來嘗試利用scrapy爬取各種網站的數據。

首先一步一步來，我們先從爬最簡單的文本開始。這里爬取的就是百思不得姐的的段子，都是文本。

首先打開段子頁面，用F12工具查看元素。然后用下面的命令打開scrapy shell。

scrapy shell http://www.budejie.com/text/

稍加分析即可得到我們要獲取的數據，在介紹scrapy的第一篇文章中我就寫過一次了。這次就給上次那個爬蟲加上一個翻頁功能。

要獲取的是用戶名和對應的段子，所以在items.py中新建一個類。

class BudejieItem(scrapy.Item):
    username = scrapy.Field()
    content = scrapy.Field()

爬蟲本體就這樣寫，唯一需要注意的就是段子可能分為好幾行，這里我們要統一合并成一個大字符串。選擇器的extract()方法默認會返回一個列表，哪怕數據只有一個也是這樣。所以如果數據是單個的，使用extract_first()方法。

import scrapy
from scrapy_sample.items import BudejieItem


class BudejieSpider(scrapy.Spider):
    """百思不得姐段子的爬蟲"""
    name = "budejie"
    start_urls = ["http://www.budejie.com/text/"]
    total_page = 1

    def parse(self, response):
        current_page = int(response.css("a.z-crt::text").extract_first())
        lies = response.css("div.j-r-list >ul >li")
        for li in lies:
            username = li.css("a.u-user-name::text").extract_first()
            content = "
".join(li.css("div.j-r-list-c-desc a::text").extract())
            yield BudejieItem(username=username, content=content)
        if current_page < self.total_page:
            yield scrapy.Request(self.start_urls[0] + f"{current_page+1}")

利用scrapy內置的Feed功能，我們可以非常方便的將爬蟲數據導出為XML、JSON和CSV等格式的文件。要做的只需要在運行scrapy的時候用-o參數指定導出文件名即可。

scrapy crawl budejie -o f.json
scrapy crawl budejie -o f.csv
scrapy crawl budejie -o f.xml

如果出現導出漢字變成Unicode編碼的話，需要在配置中設置導出編碼。

FEED_EXPORT_ENCODING = "utf-8"

有時候爬出來的數據并不想放到文件中，而是存在數據庫中。這時候就需要編寫管道來處理數據了。一般情況下，爬蟲只管爬取數據，數據是否重復是否有效都不是爬蟲要關心的事情。清洗數據、驗證數據、保存數據這些活，都應該交給管道來處理。當然爬個段子的話，肯定是用不到清洗數據這些步驟的。這里用的是pymongo，所以首先需要安裝它。

pip install pymongo

代碼其實很簡單，用scrapy官方文檔的例子稍微改一下就行了。由于MongoDB的特性，所以這部分代碼幾乎是無縫遷移的，如果希望保存其他數據，只需要改一下配置就可以了，其余代碼部分幾乎不需要更改。

import pymongo


class BudejieMongoPipeline(object):
    "將百思不得姐段子保存到MongoDB中"
    collection_name = "jokes"

    def __init__(self, mongo_uri, mongo_db):
        self.mongo_uri = mongo_uri
        self.mongo_db = mongo_db

    @classmethod
    def from_crawler(cls, crawler):
        return cls(
            mongo_uri=crawler.settings.get("MONGO_URI"),
            mongo_db=crawler.settings.get("MONGO_DATABASE", "budejie")
        )

    def open_spider(self, spider):
        self.client = pymongo.MongoClient(self.mongo_uri)
        self.db = self.client[self.mongo_db]

    def close_spider(self, spider):
        self.client.close()

    def process_item(self, item, spider):
        self.db[self.collection_name].insert_one(dict(item))
        return item

這個管道需要從配置文件中讀取數據庫信息，所以還需要在settings.py中增加以下幾行。別忘了在ITEM_PIPELINES中吧我們的管道加進去。

MONGO_URI = "mongodb://localhost:27017/"
MONGO_DATABASE = "budejie"

ITEM_PIPELINES = {
    "scrapy.pipelines.images.ImagesPipeline": 1,
    "scrapy_sample.pipelines.BudejieMongoPipeline": 2
}

最后運行一下爬蟲，應該就可以看到MongoDB中保存好的數據了。這里我用的MongoDB客戶端是Studio 3T，我個人覺得比較好用的一個客戶端。

scrapy crawl budejie

原來我基本都是用MySQL數據庫，不過重裝系統之后，我選擇了另一個非常流行的開源數據庫PostgreSQL。這里就將數據保存到PostgreSQL中。不過說起來，SQL數據庫確實更加麻煩一些。MongoDB基本上毫無配置可言，一個數據庫、數據集合不需要定義就能直接用，如果沒有就自動創建。而SQL的表需要我們手動創建才行。

首先需要安裝PostgreSQL的Python驅動程序。

pip install Psycopg2

然后建立一個數據庫test和數據表joke。在PostgreSQL中自增主鍵使用SERIAL來設置。

CREATE TABLE joke (
  id      SERIAL PRIMARY KEY,
  author  VARCHAR(128),
  content TEXT
);

管道基本上一樣，只不過將插入數據換成了SQL形式的。由于默認情況下需要手動調用commit()函數才能提交數據，于是我索性打開了自動提交。

import psycopg2


class BudejiePostgrePipeline(object):
    "將百思不得姐段子保存到PostgreSQL中"

    def __init__(self):
        self.connection = psycopg2.connect("dbname="test" user="postgres" password="12345678"")
        self.connection.autocommit = True

    def open_spider(self, spider):
        self.cursor = self.connection.cursor()

    def close_spider(self, spider):
        self.cursor.close()
        self.connection.close()

    def process_item(self, item, spider):
        self.cursor.execute("insert into joke(author,content) values(%s,%s)", (item["username"], item["content"]))
        return item

別忘了將管道加到配置文件中。

ITEM_PIPELINES = {
    "scrapy.pipelines.images.ImagesPipeline": 1,
    "scrapy_sample.pipelines.BudejiePostgrePipeline": 2
}

再次運行爬蟲，就可以看到數據成功的放到PostgreSQL數據庫中了。

以上就是抽取文本數據的例子了。雖然我只是簡單的爬了百思不得姐，不過這些方法可以應用到其他方面，爬取更多更有用的數據。這就需要大家探索了。

說完了抽取文本，下面來看看如何下載圖片。這里以妹子圖為例說明一下。

首先定義一個圖片Item。scrapy要求圖片Item必須有image_urls和images兩個屬性。另外需要注意這兩個屬性類型都必須是列表，我就因為沒有將image_urls設置為列表而卡了好幾個小時。

class ImageItem(scrapy.Item):
    image_urls = scrapy.Field()
    images = scrapy.Field()

然后照例對網站用F12和scrapy shell這兩樣工具進行測試，找出爬取圖片的方式。這里我只是簡單的爬取一個頁面的上的圖片，不過只要熟悉了scrapy可以很快的修改成跨越多頁爬取圖片。再次提醒，爬蟲中生成Item的時候切記image_urls屬性是一個列表，就算只有一個URL也得是列表。

import scrapy
from scrapy_sample.items import ImageItem


class MeizituSpider(scrapy.Spider):
    name = "meizitu"
    start_urls = ["http://www.meizitu.com/a/5501.html"]

    def parse(self, response):
        yield ImageItem(image_urls=response.css("div#picture img::attr(src)").extract())

然后在配置文件中添加圖片管道的設置，還需要設置圖片保存位置，不然scrapy仍然會禁用圖片管道。

ITEM_PIPELINES = {
    "scrapy.pipelines.images.ImagesPipeline": 1,
}
IMAGES_STORE = "images"

然后運行爬蟲，就可以看到圖片已經成功保存到本地了。

scrapy crawl meizitu

從上面的圖中我們可以看到文件名是一堆亂碼字符，因為默認的圖片管道會將圖片地址做SHA1哈希之后作為文件名。如果我們希望自定義文件名，就需要自己繼承圖片管道并重寫file_path方法。

先將默認的file_path方法貼出來。

    def file_path(self, request, response=None, info=None):

        # check if called from image_key or file_key with url as first argument
        if not isinstance(request, Request):
            url = request
        else:
            url = request.url

        image_guid = hashlib.sha1(to_bytes(url)).hexdigest()  # change to request.url after deprecation
        return "full/%s.jpg" % (image_guid)

下面是我們的自定義圖片管道，這里獲取圖片URL的最后一部分作為圖片文件名，例如對于/123.JPG，就獲取123.jpg作為文件名。

import scrapy.pipelines.images
from scrapy.http import Request


class RawFilenameImagePipeline(scrapy.pipelines.images.ImagesPipeline):
    def file_path(self, request, response=None, info=None):
        if not isinstance(request, Request):
            url = request
        else:
            url = request.url
        beg = url.rfind("/") + 1
        end = url.rfind(".")
        if end == -1:
            return f"full/{url[beg:]}.jpg"
        else:
            return f"full/{url[beg:end]}.jpg"

如果文件名生成規則更加復雜，可以參考znns項目中的pipeline編寫。他這里要根據路徑生成多級文件夾保存圖片，所以他的圖片Item需要額外幾個屬性設置圖片分類等。這時候就需要重寫get_media_requests方法，從image_urls獲取圖片地址請求的時候用Request的meta屬性將對應的圖片Item也傳進去，這樣在生成文件名的時候就可以讀取meta屬性來確定圖片的分類等信息了。

class ZnnsPipeline(ImagesPipeline):
    def get_media_requests(self, item, info):
        for image_url in item["image_urls"]:
            yield Request(image_url, meta={"item": item}, headers=headers)
            # 這里把item傳過去，因為后面需要用item里面的書名和章節作為文件名

    def item_completed(self, results, item, info):
        image_paths = [x["path"] for ok, x in results if ok]
        if not image_paths:
            raise DropItem("Item contains no images")
        return item

    def file_path(self, request, response=None, info=None):
        item = request.meta["item"]
        image_guid = request.url.split("/")[-1]
        filename = u"full/{0[name]}/{0[albumname]}/{1}".format(item, image_guid)
        return filename

最后要說一點，如果不需要使用圖片管道的幾個功能，完全可以改為使用文件管道。因為圖片管道會嘗試將所有圖片都轉換成JPG格式的，你看源代碼的話也會發現圖片管道中文件名類型直接寫死為JPG的。所以如果想要保存原始類型的圖片，就應該使用文件管道。

mm131是另一個圖片網站，為什么我要說這個網站呢？因為這個網站使用了防盜鏈技術。對于妹子圖網站來說，由于它沒有防盜鏈功能，所以我們從HTML中獲取的圖片地址就是實際的圖片地址。但是對于有反盜鏈的網站來說，當你順著圖片URL去下載圖片的時候，會被重定向到一個無關的圖片。因為這個原因，另外瀏覽器有緩存機制導致我直接訪問圖片地址的時候會先返回緩存的圖片，導致我浪費好幾個小時。最后我刷新瀏覽器的時候才發現原來被重定向了。

對于這種情況，需要我們研究怎樣才能訪問到圖片。使用Scrapy框架時 普通反爬蟲機制的應對策略這篇文章列舉了一些常見的策略。我們要做的就是根據這些策略進行嘗試。現在我用的是火狐瀏覽器，它的F12工具很好用，其中有一個編輯和重發功能可以方便的幫助我們定位問題。

在上面幾張圖中，我們可以看到直接嘗試訪問圖片會得到302，然后被重定向到一個騰訊logo上。但是在添加了Referer之后，成功獲得了圖片。所以問題就是Referer了。這里簡單介紹一下Referer，它其實是Referrer的誤拼寫。當我們從一個頁面點擊進入另一個頁面時，后者的Referer就是前者。所以有些網站就利用Referer做判斷，如果檢測是由另一個網頁進來的，那么正常訪問，如果直接訪問圖片等資源沒有Referer，就判斷為爬蟲，拒絕請求。這種情況下的解決辦法也很簡單，既然網站要Referer，我們手動加上不就行了嗎。

首先，對于圖片Item，新增一個referer字段，用于保存該圖片的Referer。

class ImageItem(scrapy.Item):
    image_urls = scrapy.Field()
    images = scrapy.Field()
    referer = scrapy.Field()

然后在爬蟲里面，抓取圖片實際地址的時候，同時設置當前網頁作為Referer。

import scrapy
from scrapy_sample.items import ImageItem


class Mm131Spider(scrapy.Spider):
    name = "mm131"

    start_urls = ["http://www.mm131.com/xinggan/3473.html",
                  "http://www.mm131.com/xinggan/2746.html",
                  "http://www.mm131.com/xinggan/3331.html"]

    def parse(self, response):
        total_page = int(response.css("span.page-ch::text").extract_first()[1:-1])
        current_page = int(response.css("span.page_now::text").extract_first())
        item = ImageItem()
        item["image_urls"] = response.css("div.content-pic img::attr(src)").extract()
        item["referer"] = response.url
        yield item
        if response.url.rfind("_") == -1:
            head, sep, tail = response.url.rpartition(".")
        else:
            head, sep, tail = response.url.rpartition("_")
        if current_page < total_page:
            yield scrapy.Request(head + f"_{current_page+1}.html")

最后還需要重寫圖片管道的get_media_requests方法。我們先來看看圖片管道基類中是怎么寫的。self.images_urls_field在這幾行前面設置的，scrapy會嘗試先從配置文件中讀取自定義的圖片URL屬性，獲取不到就使用默認的。然后在用圖片URL屬性從item中獲取url，然后傳遞給Request構造函數組裝為一個Request列表，后續下載器就會用這些請求來下載圖片。

    def get_media_requests(self, item, info):
        return [Request(x) for x in item.get(self.images_urls_field, [])]

恰好我們要做的事情很簡單，就是遍歷一遍這個Request列表，在每個Request上加上Referer請求頭就行了。所以實際上代碼超級簡單。我們調用基類的實現，也就是上面這個，然后遍歷一邊再返回即可。

class RefererImagePipeline(ImagesPipeline):
    def get_media_requests(self, item, info):
        requests = super().get_media_requests(item, info)
        for req in requests:
            req.headers.appendlist("referer", item["referer"])
        return requests

最后啟用這個管道。

ITEM_PIPELINES = {
    # "scrapy.pipelines.images.ImagesPipeline": 1,
    "scrapy_sample.pipelines.RefererImagePipeline": 2
}

運行一下爬蟲，這次可以看到，成功下載到了一堆圖片。

scrapy crawl mm131

當然你也可以關掉這個管道，然后運行看看，會發現終端里一堆重定向錯誤，無法下載圖片。

這僅僅是一個例子，實際上很多網站可能綜合使用多種技術來檢測爬蟲，這樣我們的爬蟲也需要多種辦法結合來反爬蟲。這個網站恰好只使用了Referer，所以我們只用Referer就能解決。

最后一個例子就來爬取CSDN上所有文章，其實在我的scrapy練習中很早就有一個簡單的例子，不過那個是在未登錄的情況下獲取所有文章的名字和鏈接。這里我要做的是登錄CSDN賬號，然后把所有文章爬下來保存成文件，也就是演示一下如何用scrapy模擬登錄過程。

為什么要選擇CSDN呢？其實也很簡單，因為現在POST明文用戶名和密碼還不需要驗證碼就能登錄的網站真的不多了啊！當然用CSDN的同學也不用怕，雖然CSDN傳遞的是明文密碼，但是由于使用了HTTPS，所以安全性還是可以的。

翻了翻以前寫的文章，發現我確實寫過模擬CSDN登錄的文章Python登錄并獲取CSDN博客所有文章列表，不過運行了一下我發現CSDN頁面經過改版，有些地方變了，所以還是需要重新研究一下。需要注意HTTPS傳輸是不會出現在瀏覽器F12工具中的，只有HTTP傳輸才能在工具中捕獲。所以這時候需要用Fiddler來研究。

不過實際上我又研究了半天，發現其實CSDN登錄過程沒變化，我只要把原來寫的一個多余的驗證函數刪了馬上又可以正常運行了……這里是我原來的CSDN模擬登錄代碼，用BeautifulSoup4和requests寫的。

又耗費了幾個小時終于把這個爬蟲寫完了，其實編碼過程真的沒費多少時間。主要是由于我對Python語言還是屬于速成的，很多細節沒掌握。比方說scrapy如何用回調方法來分別解析不同頁面、回調方法如何傳遞數據、寫文件的時候沒有檢查目錄是否存在、文件應該用什么模式寫入、如何以UTF-8編碼寫文件、目錄分隔符如何處理等等，其實都是一些小問題，不過一個一個解決真的廢了我不少事情。

首先，照例定義一個Item，因為我只準備簡單下載文章，所以只需要標題和內容兩個屬性即可，標題會作為文件名來使用。

class CsdnBlogItem(scrapy.Item):
    title = scrapy.Field()
    content = scrapy.Field()

然后是爬蟲本體，這是我目前寫過的最復雜的一個爬蟲，確實費了不少時間。這個爬蟲跨越了多個頁面，還要針對不同頁面解析不同的數據。不過雖然看著復雜，其實倒是也很簡單。首先是初始方法，從命令行獲取CSDN登錄用戶名和密碼，然后存起來備用。由于需要用戶登錄，所以parse方法的作用就從解析頁面變成了用戶登錄。具體登錄過程在我原來那篇文章中詳細解釋過了。這里就是簡單的利用FormRequest.from_response方法將用戶名、密碼以及頁面中的隱藏表單域一起提交。需要注意的就是callback參數，它表示頁面返回的請求會有另一個方法來處理。

然后是redirect_to_articles方法，本來瀏覽器登錄成功的話，會返回一個重定向頁面，瀏覽器會執行其中的JS代碼重定向到CSDN頁面。不過我們這是爬蟲，完全沒有執行JS代碼的功能。實際上我們也完全不用在意這個重定向過程，既然登陸成功，有了Cookie，我們想訪問什么頁面都可以。所以這里同樣直接生成一個新請求訪問文章頁面，然后用callback參數指定get_all_articles作為回調。

從get_all_articles方法開始，我們就開始解析頁面了。這個方法首先查詢總共有多少頁，而且由于csdn服務器是REST形式的，所以我們可以直接將文章頁面基地址和文章頁數拼起來生成所有的頁面。在這些頁面中，每一頁上都有一些文章鏈接，我們點進去就能訪問實際文章了。生成所有頁面的鏈接之后，我們同樣設置回調，將這些頁面交給parse_article_links方法處理。

import scrapy
from scrapy import FormRequest
from scrapy import Request
from scrapy_sample.items import CsdnBlogItem


class CsdnBlogBackupSpider(scrapy.Spider):
    name = "csdn_backup"
    start_urls = ["https://passport.csdn.net/account/login"]
    base_url = "http://write.blog.csdn.net/postlist/"
    get_article_url = "http://write.blog.csdn.net/mdeditor/getArticle?id="

    def __init__(self, name=None, username=None, password=None, **kwargs):
        super(CsdnBlogBackupSpider, self).__init__(name=name, **kwargs)
        if username is None or password is None:
            raise Exception("沒有用戶名和密碼")
        self.username = username
        self.password = password

    def parse(self, response):
        lt = response.css("form#fm1 input[name="lt"]::attr(value)").extract_first()
        execution = response.css("form#fm1 input[name="execution"]::attr(value)").extract_first()
        eventid = response.css("form#fm1 input[name="_eventId"]::attr(value)").extract_first()
        return FormRequest.from_response(
            response,
            formdata={
                "username": self.username,
                "password": self.password,
                "lt": lt,
                "execution": execution,
                "_eventId": eventid
            },
            callback=self.redirect_to_articles
        )

    def redirect_to_articles(self, response):
        return Request(CsdnBlogBackupSpider.base_url, callback=self.get_all_articles)

    def get_all_articles(self, response):
        import re
        text = response.css("div.page_nav span::text").extract_first()
        total_page = int(re.findall(r"共(d+)頁", text)[0])
        for i in range(1, total_page + 1):
            yield Request(CsdnBlogBackupSpider.base_url + f"0/0/enabled/{i}", callback=self.parse_article_links)

    def parse_article_links(self, response):
        article_links = response.xpath("http://table[@id="lstBox"]/tr[position()>1]/td[1]/a[1]/@href").extract()
        last_index_of = lambda x: x.rfind("/")
        article_ids = [link[last_index_of(link) + 1:] for link in article_links]
        for id in article_ids:
            yield Request(CsdnBlogBackupSpider.get_article_url + id, callback=self.parse_article_content)

    def parse_article_content(self, response):
        import json
        obj = json.loads(response.body, encoding="UTF8")
        yield CsdnBlogItem(title=obj["data"]["title"], content=obj["data"]["markdowncontent"])

在parse_article_links方法中，我們獲取每一頁上的所有文章，將文章ID抽出來，然后和這個地址"http://write.blog.csdn.net/mdeditor/getArticle?id="拼起來。這是我編輯CSDN文章的時候從瀏覽器中抓出來的一個地址，它會返回一個JSON字符串，包含文章標題、內容、Markdown文本等各種信息。同樣地，我們用parse_article_content回調函數來處理這個新請求。

下面就是最后一步了，在parse_article_content方法中做的事情很簡單，將JSON字符串轉換成Python對象，然后把我們需要的屬性拿出來。需要交給管道處理的Item對象，也是在這最后一步生成。當然除了用這么多回調函數來處理，我們還可以在一個函數中手動生成請求并處理響應。

這種通過多個回調函數來處理請求的方式，在編寫復雜的爬蟲中是很常見的。例如我們要爬一個美女圖片網站，這個網站中每個美女都有好幾個圖集，每個圖集有好幾頁，每頁好幾張圖。如果我們希望按照分類和圖集來生成目錄并保存，那么不僅需要多個回調函數來爬取，還需要將圖集、分類等信息跨越多個回調函數傳遞給最終生成Item的函數。這時候需要利用Request構造函數中的meta屬性，這里是一個例子，具體代碼大家自己看就行了。

最后就是文章保存管道了。這里沒什么技術難點，不過讓我這個以前沒弄過這玩意的人來寫，確實費了不少功夫。首先檢測目錄是否存在，如果不存在則創建之。假如目錄不存在的話，open函數就會失敗。然后就是用UTF8編碼保存文章。

class CsdnBlogBackupPipeline(object):
    def process_item(self, item, spider):
        dirname = "blogs"
        import os
        import codecs
        if not os.path.exists(dirname):
            os.mkdir(dirname)
        with codecs.open(f"{dirname}{os.sep}{item["title"]}.md", "w", encoding="utf-8") as f:
            f.write(item["content"])
            f.close()
        return item

最后別忘了在配置文件中啟用管道。

ITEM_PIPELINES = {
    # "scrapy.pipelines.images.ImagesPipeline": 1,
    "scrapy_sample.pipelines.CsdnBlogBackupPipeline": 2
}

然后運行一下爬蟲，注意這個爬蟲需要接受額外的用戶名和密碼參數，我們使用-a參數來指定。

scrapy crawl csdn_backup -a username="用戶名" -a password="密碼"

這里說一下，我現在改為使用簡書來編寫文章，一來是由于簡書的體驗確實相比來說非常好，在編輯器中可以直接粘貼并自動上傳剪貼板中的圖片；二來因為簡書圖片沒有外鏈限制，所以Markdown文本可以直接復制到其他網站中，同時維護多個博客非常容易，如果有同時關注我CSDN和簡書的同學也會發現，很多文章我的提交時間基本只差了十幾秒，這就是復制粘貼所用的時間。包括剛剛爬下來的文章，只要在Markdown編輯器中打開，圖片都可以正常訪問。

以上就是我備份CSDN上文章的一個簡單例子，說它簡單因為真的沒干什么事情，單純的把文章內容爬下來而已，其中的圖片存儲仍然依賴于簡書和其他網站來保存。有興趣的同學可以嘗試做更完善的備份功能，將每篇文章按目錄保存，文章中的圖片按照各自的目錄下載到本地，并將Markdown文本中對應圖片的地址由服務器替換為本地路徑。把這些功能全做完，就是一個真正的文章備份工具了。由于水平所限，我就不做了。

這篇文章到這里也該結束了，雖然只有4個例子，但是我嘗試涵蓋爬蟲的所有應用場景、爬取圖片、爬取文本、保存到數據庫和文件、自定義管道等等。希望這篇文章對大家能有所幫助！這些代碼全在我的Github上，歡迎關注。