Spider_Man_6 の Scrapy（未完待續）

時間 2019-11-17

原文原文鏈接

一：自我介紹

　　Scrapy是一個爲了爬取網站數據，提取結構性數據而編寫的應用框架。能夠應用在包括數據挖掘，信息處理或存儲歷史數據等一系列的程序中。
其最初是爲了頁面抓取 (更確切來講, 網絡抓取 )所設計的，也能夠應用在獲取API所返回的數據(例如 Amazon Associates Web Services ) 或者通用的網絡爬蟲。Scrapy用途普遍，能夠用於數據挖掘、監測和自動化測試。
css

　　Scrapy是基於twisted框架開發而來，twisted是一個流行的事件驅動的python網絡框架，所以Scrapy使用了一種非阻塞（又名異步）的代碼來實現併發。
html

　　總體架構大體以下：python

　　分析：程序員

The data flow in Scrapy is controlled by the execution engine, and goes like this: The Engine gets the initial Requests to crawl from the Spider. The Engine schedules the Requests in the Scheduler and asks for the next Requests to crawl. The Scheduler returns the next Requests to the Engine. The Engine sends the Requests to the Downloader, passing through the Downloader Middlewares (see process_request()). Once the page finishes downloading the Downloader generates a Response (with that page) and sends it to the Engine, passing through the Downloader Middlewares (see process_response()). The Engine receives the Response from the Downloader and sends it to the Spider for processing, passing through the Spider Middleware (see process_spider_input()). The Spider processes the Response and returns scraped items and new Requests (to follow) to the Engine, passing through the Spider Middleware (see process_spider_output()). The Engine sends processed items to Item Pipelines, then send processed Requests to the Scheduler and asks for possible next Requests to crawl. The process repeats (from step 1) until there are no more requests from the Scheduler.

Components：web

引擎(EGINE)

- 引擎負責控制系統全部組件之間的數據流，並在某些動做發生時觸發事件。有關詳細信息，請參見上面的數據流部分。引擎是整個框架的核心。ajax
調度器(SCHEDULER)
- 用來接受引擎發過來的請求, 壓入隊列中, 並在引擎再次請求的時候返回. 能夠想像成一個URL的優先級隊列, 由它來決定下一個要抓取的網址是什麼, 同時去除重複的網址。
下載器(DOWLOADER)
- 用於下載網頁內容, 並將網頁內容返回給EGINE，下載器是創建在twisted這個高效的異步模型上的。
爬蟲(SPIDERS)
- SPIDERS是開發人員自定義的類，用來解析responses，而且提取items，或者發送新的請求。
項目管道(ITEM PIPLINES)
- 在items被提取後負責處理它們，主要包括清理、驗證、持久化（好比存到數據庫）等操做。
下載器中間件(Downloader Middlewares)
- 位於Scrapy引擎和下載器之間，主要用來處理從EGINE傳到DOWLOADER的請求request，已經從DOWNLOADER傳到EGINE的響應response，你可用該中間件作如下幾件事爬蟲中間件(Spider Middlewares)
1. process a request just before it is sent to the Downloader (i.e. right before Scrapy sends the request to the website);
2. change received response before passing it to a spider;
3. send a new Request instead of passing received response to a spider;
4. pass response to a spider without fetching a web page;
5. silently drop some requests.
- 位於EGINE和SPIDERS之間，主要工做是處理SPIDERS的輸入（即responses）和輸出（即requests）

官網連接：https://docs.scrapy.org/en/latest/topics/architecture.html正則表達式

流程解析:mongodb

　　這裏是本人本身理解。shell

　　感受理解的不好，勞煩各位指正。數據庫

第一步：spiders發出請求。
第二步：引擎接收到以後，去調度器中（有調度器來決定下一個要抓取的網址是啥，同時去除重複的網址，這步咱們能夠本身寫去重方法），拿到要請求的url，而且將下一個url也拿到。
第三步：引擎接收到來自調度器的請求，並經過downloader中間件（它主要是處理scrapy引擎和下載器之間的請求和響應）發送給downloader。
第四步：交給爬蟲解析Response。這裏會介入Spider Middlewares（這個爬蟲中間件是介於引擎和Spider之間的框架，主要工做是處理爬蟲的響應輸入和請求輸出。
第五步：如果解析出實體（item：是用來結構化數據的，item和piplines對應的，在piplines中會進行一些相應的處理。好比去重，選擇持久化數據的方式（好比吃點偉哥）：這裏分兩步寫，有解耦的效果，還有其餘做用，待解決。。。），則交給實體管道進行進一步處理。若是解析出url，會將新請求經過爬蟲中間件返回給引擎。引擎會把url交給Scheduler等待抓取。

二：安裝

#Windows平臺
    一、pip3 install wheel #安裝後，便支持經過wheel文件安裝軟件，wheel文件官網：https://www.lfd.uci.edu/~gohlke/pythonlibs
    3、pip3 install lxml 4、pip3 install pyopenssl 五、下載並安裝pywin32：https://sourceforge.net/projects/pywin32/files/pywin32/
    六、下載twisted的wheel文件：http://www.lfd.uci.edu/~gohlke/pythonlibs/#twisted
    七、執行pip3 install 下載目錄\Twisted-17.9.0-cp36-cp36m-win_amd64.whl 8、pip3 install scrapy #Linux平臺
    一、pip3 install scrapy

三：命令行工具

# 1. 查看幫助
scrapy -h scrapy <commond> -h  # 相關命令的help

# 2. 有兩種命令：其中Project-only必須切到項目文件夾下才能執行，而Global的命令則不須要
    Global commands:
        startproject #建立項目
        genspider    #建立爬蟲程序
        settings     #若是是在項目目錄下，則獲得的是該項目的配置
        runspider    #運行一個獨立的python文件，沒必要建立項目
        shell        #scrapy shell url地址  在交互式調試，如選擇器規則正確與否
        fetch        #獨立於程單純地爬取一個頁面，能夠拿到請求頭
        view         #下載完畢後直接彈出瀏覽器，以此能夠分辨出哪些數據是ajax請求
        version      #scrapy version 查看scrapy的版本，scrapy version -v查看scrapy依賴庫的版本
    Project-only commands:
        crawl        #運行爬蟲，必須建立項目才行，確保配置文件中ROBOTSTXT_OBEY = False
        check        #檢測項目中有無語法錯誤
        list         #列出項目中所包含的爬蟲名
        edit         #編輯器，通常不用
        parse        #scrapy parse url地址 --callback 回調函數  #以此能夠驗證咱們的回調函數是否正確
        bench        #scrapy bentch壓力測試

# 3. 官網連接
    https://docs.scrapy.org/en/latest/topics/commands.html

#一、執行全局命令：請確保不在某個項目的目錄下，排除受該項目配置的影響
scrapy startproject MyProject cd MyProject scrapy genspider baidu www.baidu.com scrapy settings --get XXX #若是切換到項目目錄下，看到的則是該項目的配置
 scrapy runspider baidu.py scrapy shell https://www.baidu.com response response.status response.body view(response) scrapy view https://www.taobao.com #若是頁面顯示內容不全，不全的內容則是ajax請求實現的，以此快速定位問題
 scrapy fetch --nolog --headers https://www.taobao.com scrapy version #scrapy的版本
 scrapy version -v #依賴庫的版本


#二、執行項目命令：切到項目目錄下
scrapy crawl baidu scrapy check scrapy list scrapy parse http://quotes.toscrape.com/ --callback parse scrapy bench

示例用法

四：項目結構以及爬蟲應用簡介

目錄結構：

目錄解讀：

scrapy.cfg　　項目的主配置信息，用來部署scrapy時使用，爬蟲相關的配置信息愛settings.py中
items.py　　設置數據存儲模版，用於結構化數據，相似於Django的Model
pipelines 數據處理行爲，通常結構化的數據持久化
settings.py 配置文件。如：遞歸的層數，併發數，延遲下載等。強調:配置文件的選項必須大寫不然視爲無效，正確寫法USER_AGENT='xxxx'
spiders 爬蟲目錄。如：建立文件，編寫爬蟲規則。

　　注意：通常建立爬蟲文件時，以網站域名命名

　　默認只能在cmd中執行爬蟲，若是想在pycharm中執行須要這樣作：

#在項目目錄下新建：entrypoint.py
from scrapy.cmdline import execute execute(['scrapy', 'crawl', 'amazon'])

五：spiders

1：關於spiders

#一、Spiders是由一系列類（定義了一個網址或一組網址將被爬取）組成，具體包括如何執行爬取任務而且如何從頁面中提取結構化的數據。

#二、換句話說，Spiders是你爲了一個特定的網址或一組網址自定義爬取和解析頁面行爲的地方

2：spiders會循環着去作哪些事情？

#一、生成初始的Requests來爬取第一個URLS，而且標識一個回調函數
第一個請求定義在start_requests()方法內默認從start_urls列表中得到url地址來生成Request請求，默認的回調函數是parse方法。回調函數在下載完成返回response時自動觸發 #二、在回調函數中，解析response而且返回值
返回值能夠4種： 包含解析數據的字典 Item對象 新的Request對象（新的Requests也須要指定一個回調函數） 或者是可迭代對象（包含Items或Request） #三、在回調函數中解析頁面內容
一般使用Scrapy自帶的Selectors，但很明顯你也可使用Beutifulsoup，lxml或其餘想你鎖想。 #四、最後，針對返回的Items對象將會被持久化到數據庫
經過Item Pipeline組件存到數據庫：官方文檔：https://docs.scrapy.org/en/latest/topics/item-pipeline.html#topics-item-pipeline）
或者導出到不一樣的文件（經過Feed exports：官方文檔：https://docs.scrapy.org/en/latest/topics/feed-exports.html#topics-feed-exports）

3：spiders總共提供五種類

#一、scrapy.spiders.Spider #scrapy.Spider等同於scrapy.spiders.Spider #二、scrapy.spiders.CrawlSpider #三、scrapy.spiders.XMLFeedSpider #四、scrapy.spiders.CSVFeedSpider #五、scrapy.spiders.SitemapSpider

4：導入使用

# -*- coding: utf-8 -*-
import scrapy
from scrapy.spiders import Spider,CrawlSpider,XMLFeedSpider,CSVFeedSpider,SitemapSpider

class AmazonSpider(scrapy.Spider): #自定義類，繼承Spiders提供的基類
    name = 'amazon'
    allowed_domains = ['www.amazon.cn']
    start_urls = ['http://www.amazon.cn/']
    
    def parse(self, response):
        pass

5：class scrapy.spiders.Spider

這是最簡單的spider類，任何其餘的spider類都須要繼承它（包含你本身定義的）。

該類不提供任何特殊的功能，它僅提供了一個默認的start_requests方法：默認從start_urls中讀取url地址發送requests請求，而且默認parse做爲回調函數

class AmazonSpider(scrapy.Spider):
    name = 'amazon'    # 爬蟲名，有且必須惟一
    
    allowed_domains = ['www.amazon.cn'] # 規定爬取的域。
    
    start_urls = ['http://www.amazon.cn/']  # 若是不規定url，那麼程序啓動後默認爬取該url
    
    custom_settings = {
        'BOT_NAME' : 'Amazon',    # 此爬蟲項目實施的bot的名稱，即項目名稱。默認爲'scrapybot'。
        'REQUEST_HEADERS' : {
          'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
          'Accept-Language': 'en',
        }
    }
    
    def parse(self, response):
        pass

　　關於定製scrapy.spider屬性與方法詳解

#一、name = 'amazon' 
定義爬蟲名，scrapy會根據該值定位爬蟲程序 因此它必需要有且必須惟一（In Python 2 this must be ASCII only.） #二、allowed_domains = ['www.amazon.cn'] 
定義容許爬取的域名，若是OffsiteMiddleware啓動（默認就啓動）， 那麼不屬於該列表的域名及其子域名都不容許爬取 若是爬取的網址爲：https://www.example.com/1.html，那就添加'example.com'到列表. #三、start_urls = ['http://www.amazon.cn/']
若是沒有指定url，就從該列表中讀取url來生成第一個請求 #四、custom_settings
值爲一個字典，定義一些配置信息，在運行爬蟲程序時，這些配置會覆蓋項目級別的配置 因此custom_settings必須被定義成一個類屬性，因爲settings會在類實例化前被加載 #五、settings
經過self.settings['配置項的名字']能夠訪問settings.py中的配置，若是本身定義了custom_settings仍是以本身的爲準 #六、logger
日誌名默認爲spider的名字 self.logger.debug('=============>%s' %self.settings['BOT_NAME']) #五、crawler：瞭解
該屬性必須被定義到類方法from_crawler中 #六、from_crawler(crawler, *args, **kwargs)：瞭解
You probably won’t need to override this directly  because the default implementation acts as a proxy to the __init__() method, calling it with the given arguments args and named arguments kwargs. #七、start_requests()
該方法用來發起第一個Requests請求，且必須返回一個可迭代的對象。它在爬蟲程序打開時就被Scrapy調用，Scrapy只調用它一次。 默認從start_urls裏取出每一個url來生成Request(url, dont_filter=True) #針對參數dont_filter,請看自定義去重規則
 若是你想要改變起始爬取的Requests，你就須要覆蓋這個方法，例如你想要起始發送一個POST請求，以下 class MySpider(scrapy.Spider): name = 'myspider'

    def start_requests(self): return [scrapy.FormRequest("http://www.example.com/login", formdata={'user': 'john', 'pass': 'secret'}, callback=self.logged_in)] def logged_in(self, response): # here you would extract links to follow and return Requests for
        # each of them, with another callback
        pass
        
#八、parse(response)
這是默認的回調函數，全部的回調函數必須返回an iterable of Request and/or dicts or Item objects. #九、log(message[, level, component])：瞭解
Wrapper that sends a log message through the Spider’s logger, kept for backwards compatibility. For more information see Logging from Spiders. #十、closed(reason)
爬蟲程序結束時自動觸發

去重規則應該多個爬蟲共享的，但凡一個爬蟲爬取了，其餘都不要爬了，實現方式以下 #方法一：
1、新增類屬性 visited=set() #類屬性

2、回調函數parse方法內： def parse(self, response): if response.url in self.visited: return None ....... self.visited.add(response.url) #方法一改進：針對url可能過長，因此咱們存放url的hash值
def parse(self, response): url=md5(response.request.url) if url in self.visited: return None ....... self.visited.add(url) #方法二：Scrapy自帶去重功能
配置文件： DUPEFILTER_CLASS = 'scrapy.dupefilter.RFPDupeFilter' #默認的去重規則幫咱們去重，去重規則在內存中
DUPEFILTER_DEBUG = False JOBDIR = "保存範文記錄的日誌路徑，如：/root/"  # 最終路徑爲 /root/requests.seen，去重規則放文件中
 scrapy自帶去重規則默認爲RFPDupeFilter，只須要咱們指定 Request(...,dont_filter=False) ，若是dont_filter=True則告訴Scrapy這個URL不參與去重。 #方法三：
咱們也能夠仿照RFPDupeFilter自定義去重規則， from scrapy.dupefilter import RFPDupeFilter，看源碼，仿照BaseDupeFilter #步驟一：在項目目錄下自定義去重文件dup.py
class UrlFilter(object): def __init__(self): self.visited = set() #或者放到數據庫
 @classmethod def from_settings(cls, settings): return cls() def request_seen(self, request): if request.url in self.visited: return True self.visited.add(request.url) def open(self):  # can return deferred
        pass

    def close(self, reason):  # can return a deferred
        pass

    def log(self, request, spider):  # log that a request has been filtered
        pass

#步驟二：配置文件settings.py：
DUPEFILTER_CLASS = '項目名.dup.UrlFilter'


# 源碼分析：
from scrapy.core.scheduler import Scheduler 見Scheduler下的enqueue_request方法：self.df.request_seen(request)

去重規則：url的去重

#例一：
import scrapy class MySpider(scrapy.Spider): name = 'example.com' allowed_domains = ['example.com'] start_urls = [ 'http://www.example.com/1.html', 'http://www.example.com/2.html', 'http://www.example.com/3.html', ] def parse(self, response): self.logger.info('A response from %s just arrived!', response.url) #例二：一個回調函數返回多個Requests和Items
import scrapy class MySpider(scrapy.Spider): name = 'example.com' allowed_domains = ['example.com'] start_urls = [ 'http://www.example.com/1.html', 'http://www.example.com/2.html', 'http://www.example.com/3.html', ] def parse(self, response): for h3 in response.xpath('//h3').extract(): yield {"title": h3} for url in response.xpath('//a/@href').extract(): yield scrapy.Request(url, callback=self.parse) #例三：在start_requests()內直接指定起始爬取的urls，start_urls就沒有用了，

import scrapy from myproject.items import MyItem class MySpider(scrapy.Spider): name = 'example.com' allowed_domains = ['example.com'] def start_requests(self): yield scrapy.Request('http://www.example.com/1.html', self.parse) yield scrapy.Request('http://www.example.com/2.html', self.parse) yield scrapy.Request('http://www.example.com/3.html', self.parse) def parse(self, response): for h3 in response.xpath('//h3').extract(): yield MyItem(title=h3) for url in response.xpath('//a/@href').extract(): yield scrapy.Request(url, callback=self.parse)

代碼示例

咱們可能須要在命令行爲爬蟲程序傳遞參數，好比傳遞初始的url，像這樣 #命令行執行
scrapy crawl myspider -a category=electronics #在__init__方法中能夠接收外部傳進來的參數
import scrapy class MySpider(scrapy.Spider): name = 'myspider'

    def __init__(self, category=None, *args, **kwargs): super(MySpider, self).__init__(*args, **kwargs) self.start_urls = ['http://www.example.com/categories/%s' % category] #...

        
#注意接收的參數全都是字符串，若是想要結構化的數據，你須要用相似json.loads的方法

參數傳遞

六、其餘通用Spiders：https://docs.scrapy.org/en/latest/topics/spiders.html#generic-spiders

六：selectors:xpath & css

什麼是解釋器？

-----------------------------------------------------------------------------------------------------

當您抓取網頁時，您須要執行的最多見任務是從HTML源中提取數據。有幾個庫能夠實現這一點：

BeautifulSoup是Python程序員中很是流行的網絡抓取庫，它基於HTML代碼的結構構建一個Python對象，而且處理至關糟糕的標記，但它有一個缺點：它很慢。
lxml是一個XML解析庫（它還解析HTML）與基於ElementTree的pythonic API 。（lxml不是Python標準庫的一部分。）
Scrapy自帶了提取數據的機制。它們稱爲選擇器，由於它們「選擇」由XPath或CSS表達式指定的HTML文檔的某些部分。

XPath是用於選擇XML文檔中的節點的語言，其也能夠與HTML一塊兒使用。CSS是一種用於將樣式應用於HTML文檔的語言。它定義了選擇器以將這些樣式與特定的HTML元素相關聯。

Scrapy選擇器構建在lxml庫之上，這意味着它們的速度和解析精度很是類似。

這個頁面解釋了選擇器是如何工做的，並描述了他們的API是很是小和簡單，不像lxml API是更大，由於 lxml庫能夠用於許多其餘任務，除了選擇標記文檔。　

#1 //與/ #2 text #三、extract與extract_first:從selector對象中解出內容 #四、屬性：xpath的屬性加前綴@ #四、嵌套查找 #五、設置默認值 #四、按照屬性查找 #五、按照屬性模糊查找 #六、正則表達式 #七、xpath相對路徑 #八、帶變量的xpath

response.selector.css() response.selector.xpath() 可簡寫爲 response.css() response.xpath() #1 //與/
response.xpath('//body/a/')# response.css('div a::text') >>> response.xpath('//body/a') #開頭的//表明從整篇文檔中尋找,body以後的/表明body的兒子
[] >>> response.xpath('//body//a') #開頭的//表明從整篇文檔中尋找,body以後的//表明body的子子孫孫
[<Selector xpath='//body//a' data='<a href="image1.html">Name: My image 1 <'>, <Selector xpath='//body//a' data='<a href="image2.html">Name: My image 2 <'>, <Selector xpath='//body//a' data='<a href="
image3.html">Name: My image 3 <'>, <Selector xpath='//body//a' data='<a href="image4.html">Name: My image 4 <'>, <Selector xpath='//body//a' data='<a href="image5.html">Name: My image 5 <'>]

#2 text
>>> response.xpath('//body//a/text()') >>> response.css('body a::text') #三、extract與extract_first:從selector對象中解出內容
>>> response.xpath('//div/a/text()').extract() ['Name: My image 1 ', 'Name: My image 2 ', 'Name: My image 3 ', 'Name: My image 4 ', 'Name: My image 5 '] >>> response.css('div a::text').extract() ['Name: My image 1 ', 'Name: My image 2 ', 'Name: My image 3 ', 'Name: My image 4 ', 'Name: My image 5 '] >>> response.xpath('//div/a/text()').extract_first() 'Name: My image 1 '
>>> response.css('div a::text').extract_first() 'Name: My image 1 '

#四、屬性：xpath的屬性加前綴@
>>> response.xpath('//div/a/@href').extract_first() 'image1.html'
>>> response.css('div a::attr(href)').extract_first() 'image1.html'

#四、嵌套查找
>>> response.xpath('//div').css('a').xpath('@href').extract_first() 'image1.html'

#五、設置默認值
>>> response.xpath('//div[@id="xxx"]').extract_first(default="not found") 'not found'

#四、按照屬性查找
response.xpath('//div[@id="images"]/a[@href="image3.html"]/text()').extract() response.css('#images a[@href="image3.html"]/text()').extract() #五、按照屬性模糊查找
response.xpath('//a[contains(@href,"image")]/@href').extract() response.css('a[href*="image"]::attr(href)').extract() response.xpath('//a[contains(@href,"image")]/img/@src').extract() response.css('a[href*="imag"] img::attr(src)').extract() response.xpath('//*[@href="image1.html"]') response.css('*[href="image1.html"]') #六、正則表達式
response.xpath('//a/text()').re(r'Name: (.*)') response.xpath('//a/text()').re_first(r'Name: (.*)') #七、xpath相對路徑
>>> res=response.xpath('//a[contains(@href,"3")]')[0] >>> res.xpath('img') [<Selector xpath='img' data='<img src="image3_thumb.jpg">'>] >>> res.xpath('./img') [<Selector xpath='./img' data='<img src="image3_thumb.jpg">'>] >>> res.xpath('.//img') [<Selector xpath='.//img' data='<img src="image3_thumb.jpg">'>] >>> res.xpath('//img') #這就是從頭開始掃描
[<Selector xpath='//img' data='<img src="image1_thumb.jpg">'>, <Selector xpath='//img' data='<img src="image2_thumb.jpg">'>, <Selector xpath='//img' data='<img src="image3_thumb.jpg">'>, <Selector xpa th='//img' data='<img src="image4_thumb.jpg">'>, <Selector xpath='//img' data='<img src="image5_thumb.jpg">'>] #八、帶變量的xpath
>>> response.xpath('//div[@id=$xxx]/a/text()',xxx='images').extract_first() 'Name: My image 1 '
>>> response.xpath('//div[count(a)=$yyy]/@id',yyy=5).extract_first() #求有5個a標籤的div的id
'images'

參照官方文檔：https://docs.scrapy.org/en/latest/topics/selectors.html

七：items

爬取的主要目標就是從非結構性的數據源提取結構性數據，例如網頁。 Scrapy提供 item 類來知足這樣的需求。

item 對象是種簡單的容器，保存了爬取到得數據。

Scrapy spiders能夠將提取的數據做爲Python字典返回。雖然方便且熟悉，但Python字典缺少結構：在字段名稱中輸入拼寫錯誤或返回不一致的數據很容易，特別是在有大量spiders的大型項目中。

定義公共輸出數據格式Scrapy提供了這個Item類。 Item對象是用來收集被爬取的數據的簡單容器。其提供了相似於字典(dictionay-like) 的API以及用於聲明可用字段的簡單語法。

各類Scrapy組件使用Items提供的額外信息：導出者查看已聲明的字段以肯定要導出的列，可使用Item字段元數據定製序列化，trackref 跟蹤Item實例以幫助查找內存泄漏（請參閱使用trackref調試內存泄漏：https://docs.scrapy.org/en/latest/topics/leaks.html#topics-leaks-trackrefs）等。

官方文檔：https://docs.scrapy.org/en/latest/topics/items.html

八：Itme Pipeline

當 Item 在 Spider 中被收集以後，它將會被傳遞到 Item Pipeline，一些組件會按照必定的順序執行對 Item 的處理。

每一個 item pipeline 組件(有時稱之爲「Item Pipeline」)是實現了簡單方法的 Python 類。他們接收到 Item 並經過它執行一些行爲，同時也決定此 Item 是否繼續經過 pipeline，或是被丟棄而再也不進行處理。

如下是 item pipeline 的一些典型應用：

清理 HTML 數據
驗證爬取的數據(檢查 item 包含某些字段)
查重(並丟棄)
將爬取結果保存到數據庫中

#一：能夠寫多個Pipeline類 #一、若是優先級高的Pipeline的process_item返回一個值或者None，會自動傳給下一個pipline的process_item, #二、若是隻想讓第一個Pipeline執行，那得讓第一個pipline的process_item拋出異常raise DropItem()

#三、能夠用spider.name == '爬蟲名' 來控制哪些爬蟲用哪些pipeline
 二：示範 from scrapy.exceptions import DropItem class CustomPipeline(object): def __init__(self,v): self.value = v @classmethod def from_crawler(cls, crawler): """ Scrapy會先經過getattr判斷咱們是否自定義了from_crawler,有則調它來完 成實例化 """ val = crawler.settings.getint('MMMM') return cls(val) def open_spider(self,spider): """ 爬蟲剛啓動時執行一次 """
        print('000000') def close_spider(self,spider): """ 爬蟲關閉時執行一次 """
        print('111111') def process_item(self, item, spider): # 操做並進行持久化

        # return表示會被後續的pipeline繼續處理
        return item # 表示將item丟棄，不會被後續pipeline處理
        # raise DropItem()

#一、settings.py
HOST="127.0.0.1" PORT=27017 USER="root" PWD="123" DB="amazon" TABLE="goods" ITEM_PIPELINES = { 'Amazon.pipelines.CustomPipeline': 200, } #二、pipelines.py
class CustomPipeline(object): def __init__(self,host,port,user,pwd,db,table): self.host=host self.port=port self.user=user self.pwd=pwd self.db=db self.table=table @classmethod def from_crawler(cls, crawler): """ Scrapy會先經過getattr判斷咱們是否自定義了from_crawler,有則調它來完 成實例化 """ HOST = crawler.settings.get('HOST') PORT = crawler.settings.get('PORT') USER = crawler.settings.get('USER') PWD = crawler.settings.get('PWD') DB = crawler.settings.get('DB') TABLE = crawler.settings.get('TABLE') return cls(HOST,PORT,USER,PWD,DB,TABLE) def open_spider(self,spider): """ 爬蟲剛啓動時執行一次 """ self.client = MongoClient('mongodb://%s:%s@%s:%s' %(self.user,self.pwd,self.host,self.port)) def close_spider(self,spider): """ 爬蟲關閉時執行一次 """ self.client.close() def process_item(self, item, spider): # 操做並進行持久化
 self.client[self.db][self.table].save(dict(item))