Scrapy框架

時間 2019-12-14

標籤 scrapy 框架欄目 Python 简体版

原文原文鏈接

Scrapy框架

官網連接：點擊
Scrapy一個開源和協做的框架，其最初是爲了頁面抓取 (更確切來講, 網絡抓取 )所設計的，使用它能夠以快速、簡單、可擴展的方式從網站中提取所需的數據。
但目前Scrapy的用途十分普遍，可用於如數據挖掘、監測和自動化測試等領域，也能夠應用在獲取API所返回的數據(例如 Amazon Associates Web Services ) 或者通用的網絡爬蟲。
Scrapy 是基於twisted框架開發而來，twisted是一個流行的事件驅動的python網絡框架。所以Scrapy使用了一種非阻塞（又名異步）的代碼來實現併發。

1、框架安裝和基礎使用

一、安裝

linux mac os:
1. pip install scrapy
win:
1. pip install wheel
2. 下載twisted：https://www.lfd.uci.edu/~gohlke/pythonlibs/#twisted
3. pip install 下載好的框架.whl
4. pip install pywin32
5. pip install scrapy

二、基礎使用

建立一個工程：scrapy startproject工程名稱
在工程目錄下建立一個爬蟲文件:
1. cd 工程
2. scrapy genspider 爬蟲文件的名稱起始url （例如：scrapy genspider qiubai www.qiushibaike.com）
對應的文件中編寫爬蟲程序來完成爬蟲的相關操做
設置修改settings.py配置文件相關配置:
1. 19行：USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.106 Safari/537.36' #假裝請求載體身份
2. 22行：ROBOTSTXT_OBEY = False #能夠忽略或者不遵照robots協議
執行爬蟲程序：scrapy crawl 應用名稱
1. scrapy crawl 爬蟲名稱：該種執行形式會顯示執行的日誌信息
2. scrapy crawl 爬蟲名稱 --nolog：該種執行形式不會顯示執行的日誌信息

"""
目錄結構：
project_name/
   scrapy.cfg：
   project_name/
       __init__.py
       items.py
       pipelines.py
       settings.py
       spiders/
           __init__.py

scrapy.cfg   項目的主配置信息。（真正爬蟲相關的配置信息在settings.py文件中）
items.py     設置數據存儲模板，用於結構化數據，如：Django的Model
pipelines    數據持久化處理
settings.py  配置文件，如：遞歸的層數、併發數，延遲下載等
spiders      爬蟲目錄，如：建立文件，編寫爬蟲解析規則
"""

#spiders/qiubai.py
import scrapy

class QiubaiSpider(scrapy.Spider):
    # 爬蟲文件的名稱：經過爬蟲文件的名稱能夠指定的定位到某一個具體的爬蟲文件
    name = 'qiubai'
    #容許的域名：只能夠爬取指定域名下的頁面數據（若是遇到非該域名的url則爬取不到數據）
    #通常不用直接註釋了
    #allowed_domains = ['https://www.qiushibaike.com/']
    #起始url：當前工程將要爬取的頁面所對應的url
    start_urls = ['https://www.qiushibaike.com/']

    # 解析方法：訪問起始URL並獲取結果後的回調函數
    # 該函數的response參數就是向起始的url發送請求後，獲取的響應對象
    # parse方法的返回值必須爲可迭代對象或者NUll
    def parse(self, response):
        print(response.text) #獲取字符串類型的響應內容
        print(response.body)#獲取字節類型的相應內容

        # 建議你們使用xpath進行指定內容的解析（框架集成了xpath解析的接口）
        # xpath爲response中的方法，能夠將xpath表達式直接做用於該函數中
        odiv = response.xpath('//div[@id="content-left"]/div')
        content_list = []  # 用於存儲解析到的數據
        for div in odiv:
            #xpath解析到的指定內容被存儲到了Selector對象
            #extract()該方法能夠將Selector對象中存儲的數據值拿到
            #author = div.xpath('./div/a[2]/h2/text()').extract()[0]
            #extract_first()  ==   extract()[0]

            # xpath函數返回的爲列表，列表中存放的數據爲Selector類型的數據。
            # 咱們解析到的內容被封裝在了Selector對象中，須要調用extract()函數將解析的內容從Selecor中取出。
            author = div.xpath('.//div[@class="author clearfix"]/a/h2/text()')[0].extract()
            content = div.xpath('.//div[@class="content"]/span/text()')[0].extract()

            # author = div.xpath('./div/a[2]/h2/text()').extract_first()
            # content = div.xpath('.//div[@class="content"]/span/text()').extract_first()

            # 將解析到的內容封裝到字典中
            dic = {
                '做者': author,
                '內容': content
            }
            # 將數據存儲到content_list這個列表中
            content_list.append(dic)

        return content_list


"""
settings.py
19行
22行
"""
# Crawl responsibly by identifying yourself (and your website) on the user-agent
#USER_AGENT = 'qiubaiPro (+http://www.yourdomain.com)'
USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.106 Safari/537.36'

# Obey robots.txt rules
ROBOTSTXT_OBEY = False

基本使用

2、持久化存儲

磁盤文件:
1. 基於終端指令:
  1. 保證parse方法返回一個可迭代類型的對象（存儲解析到的頁面內容）
  2. 使用終端指令完成數據存儲到制定磁盤文件中的操做
  3. scrapy crawl 爬蟲文件名稱–o 磁盤文件.後綴
  4. scrapy crawl qiubai -o qiubai.csv --nolog
  5. scrapy crawl qiubai -o qiubai.json --nolog
  6. scrapy crawl qiubai -o qiubai.xml --nolog
2. 基於管道:
  1. items：數據結構模板文件,定義數據屬性,存儲解析到的頁面數據
  2. pipelines：管道文件,接收數據(items),處理持久化存儲的相關操做
  3. 代碼實現流程：
    1. 爬蟲文件爬取到數據後，須要將數據存儲到items對象中。
    2. 使用yield關鍵字將items對象提交給pipelines管道文件進行持久化處理
    3. 在管道文件中的process_item方法中接收爬蟲文件提交過來的item對象，而後編寫持久化存儲的代碼將item對象中存儲的數據進行持久化存儲
    4. settings.py配置文件中開啓管道
數據庫:
1. mysql
2. redis
3. 編碼流程:
  1. 將解析到的頁面數據存儲到items對象
  2. 使用yield關鍵字將items提交給管道文件進行處理
  3. *****在管道文件中編寫代碼完成數據存儲的操做【】
  4. 在配置文件中開啓管道操做

"""
基於終端指令
1.保證parse方法返回一個可迭代類型的對象（存儲解析到的頁面內容）
2.使用終端指令完成數據存儲到制定磁盤文件中的操做
scrapy crawl qiubai -o qiubai.csv --nolog
"""
# -*- coding: utf-8 -*-
import scrapy
class QiubaiSpider(scrapy.Spider):
    name = 'qiubai'
    #allowed_domains = ['www.qiushibaike.com/text']
    start_urls = ['https://www.qiushibaike.com/text/']
    def parse(self, response):
        #建議你們使用xpath進行指定內容的解析（框架集成了xpath解析的接口）
        # 段子的內容和做者
        div_list = response.xpath('//div[@id="content-left"]/div')
        #存儲解析到的頁面數據
        data_list = []
        for div in div_list:
            #xpath解析到的指定內容被存儲到了Selector對象
            #extract()該方法能夠將Selector對象中存儲的數據值拿到
            #author = div.xpath('./div/a[2]/h2/text()').extract()[0]
            #extract_first()  ==   extract()[0]
            author = div.xpath('./div/a[2]/h2/text()').extract_first()
            content = div.xpath('.//div[@class="content"]/span/text()').extract_first()

            dict = {
                'author':author,
                'content':content
            }
            data_list.append(dict)
        return data_list


"""
settings.py
19行

22行
"""
# Crawl responsibly by identifying yourself (and your website) on the user-agent
#USER_AGENT = 'qiubaiPro (+http://www.yourdomain.com)'
USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.106 Safari/537.36'
# Obey robots.txt rules
ROBOTSTXT_OBEY = False

基於終端指令

"""
基於管道
1.對應文件的修改（spiders/qiubai.py，items.py，pipelines.py，settings.py）
2.使用終端指令完成數據存儲到制定磁盤文件中的操做
scrapy crawl qiubai --nolog
"""
# -*- coding: utf-8 -*-
import scrapy
from qiubaiPro.items import QiubaiproItem


class QiubaiSpider(scrapy.Spider):
    name = 'qiubai'
    # allowed_domains = ['www.qiushibaike.com/text']
    start_urls = ['https://www.qiushibaike.com/text/']

    def parse(self, response):
        # 建議你們使用xpath進行指定內容的解析（框架集成了xpath解析的接口）
        # 段子的內容和做者
        div_list = response.xpath('//div[@id="content-left"]/div')
        for div in div_list:
            # xpath解析到的指定內容被存儲到了Selector對象
            # extract()該方法能夠將Selector對象中存儲的數據值拿到
            # author = div.xpath('./div/a[2]/h2/text()').extract()[0]
            # extract_first()  ==   extract()[0]
            author = div.xpath('./div/a[2]/h2/text()').extract_first()
            content = div.xpath('.//div[@class="content"]/span/text()').extract_first()

            # 1.將解析到的數據值（author和content）存儲到items對象
            item = QiubaiproItem()
            item['author'] = author
            item['content'] = content

            # 2.將item對象提交給管道
            yield item


"""
items.py
"""
# -*- coding: utf-8 -*-

# Define here the models for your scraped items
#
# See documentation in:
# https://doc.scrapy.org/en/latest/topics/items.html

import scrapy


class QiubaiproItem(scrapy.Item):
    # define the fields for your item here like:
    # name = scrapy.Field()
    author = scrapy.Field()
    content = scrapy.Field()


"""
pipelines.py
"""


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

# Define your item pipelines here
#
# Don't forget to add your pipeline to the ITEM_PIPELINES setting
# See: https://doc.scrapy.org/en/latest/topics/item-pipeline.html


class QiubaiproPipeline(object):

    fp = None

    # # 構造方法
    # def __init__(self):
    #     self.fp = None  # 定義一個文件描述符屬性

    # 整個爬蟲過程當中，該方法只會在開始爬蟲的時候被調用一次
    def open_spider(self, spider):
        print('開始爬蟲')
        self.fp = open('./qiubai_pipe.txt', 'w', encoding='utf-8')

    # 該方法就能夠接受爬蟲文件中提交過來的item對象，而且對item對象中存儲的頁面數據進行持久化存儲
    # 參數：item表示的就是接收到的item對象

    # 每當爬蟲文件向管道提交一次item，則該方法就會被執行一次
    # 由於該方法會被執行調用屢次，因此文件的開啓和關閉操做寫在了另外兩個只會各自執行一次的方法中。
    def process_item(self, item, spider):
        # print('process_item 被調用！！！')
        # 取出item對象中存儲的數據值
        author = item['author']
        content = item['content']

        # 持久化存儲
        self.fp.write(author + ":" + content + '\n\n\n')
        return item

    # 該方法只會在爬蟲結束的時候被調用一次
    def close_spider(self, spider):
        print('爬蟲結束')
        self.fp.close()


"""
settings.py
19行
22行
68行 開啓管道
"""
# Crawl responsibly by identifying yourself (and your website) on the user-agent
# USER_AGENT = 'qiubaiPro (+http://www.yourdomain.com)'
USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.106 Safari/537.36'

# Obey robots.txt rules
ROBOTSTXT_OBEY = False

ITEM_PIPELINES = {
    'qiubaiPro.pipelines.QiubaiproPipeline': 300,  # 300表示爲優先級，值越小優先級越高

}

基於管道

"""
基於mysql的管道存儲
1.對應文件的修改（spiders/qiubai.py，items.py，pipelines.py，settings.py）
2.使用終端指令完成數據存儲到制定磁盤文件中的操做
scrapy crawl qiubai --nolog
"""
# -*- coding: utf-8 -*-
import scrapy
from qiubaiPro.items import QiubaiproItem

class QiubaiSpider(scrapy.Spider):
    name = 'qiubai'
    #allowed_domains = ['www.qiushibaike.com/text']
    start_urls = ['https://www.qiushibaike.com/text/']
    def parse(self, response):
        #建議你們使用xpath進行指定內容的解析（框架集成了xpath解析的接口）
        # 段子的內容和做者
        div_list = response.xpath('//div[@id="content-left"]/div')
        for div in div_list:
            #xpath解析到的指定內容被存儲到了Selector對象
            #extract()該方法能夠將Selector對象中存儲的數據值拿到
            #author = div.xpath('./div/a[2]/h2/text()').extract()[0]
            #extract_first()  ==   extract()[0]
            author = div.xpath('./div/a[2]/h2/text()').extract_first()
            content = div.xpath('.//div[@class="content"]/span/text()').extract_first()

            #1.將解析到的數據值（author和content）存儲到items對象
            #建立items對象
            item = QiubaiproItem()
            item['author'] = author
            item['content'] = content

            #2.將item對象提交給管道
            yield item


"""
items.py
"""
# -*- coding: utf-8 -*-

# Define here the models for your scraped items
#
# See documentation in:
# https://doc.scrapy.org/en/latest/topics/items.html

import scrapy

class QiubaiproItem(scrapy.Item):
    # define the fields for your item here like:
    # name = scrapy.Field()
    author = scrapy.Field()
    content = scrapy.Field()

"""
pipelines.py
"""
# -*- coding: utf-8 -*-

# Define your item pipelines here
#
# Don't forget to add your pipeline to the ITEM_PIPELINES setting
# See: https://doc.scrapy.org/en/latest/topics/item-pipeline.html
import pymysql
class QiubaiproPipelineByMysql(object):

    conn = None
    cursor = None
    def open_spider(self,spider):
        print('開始爬蟲')
        #連接數據庫
        self.conn = pymysql.Connect(host='127.0.0.1',port=3306,user='root',password='123456',db='qiubai')
    #編寫向數據庫中存儲數據的相關代碼
    def process_item(self, item, spider):
        #1.連接數據庫
        #2.執行sql語句
        sql = 'insert into qiubai values("%s","%s")'%(item['author'],item['content'])
        self.cursor = self.conn.cursor()
        try:
            self.cursor.execute(sql)
            self.conn.commit()
        except Exception as e:
            print(e)
            self.conn.rollback()
        #3.提交事務

        return item
    def close_spider(self,spider):
        print('爬蟲結束')
        self.cursor.close()
        self.conn.close()

"""
settings.py
19行
22行
68行 開啓管道
"""
# Crawl responsibly by identifying yourself (and your website) on the user-agent
#USER_AGENT = 'qiubaiPro (+http://www.yourdomain.com)'
USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.106 Safari/537.36'

# Obey robots.txt rules
ROBOTSTXT_OBEY = False

ITEM_PIPELINES = {
    'qiubaiPro.pipelines.QiubaiproPipelineByMysql': 300,  #300表示爲優先級，值越小優先級越高
}

基於mysql的管道存儲

"""
基於redis的管道存儲
1.對應文件的修改（spiders/qiubai.py，items.py，pipelines.py，settings.py）
2.使用終端指令完成數據存儲到制定磁盤文件中的操做
scrapy crawl qiubai --nolog
"""
# -*- coding: utf-8 -*-
import scrapy
from qiubaiPro.items import QiubaiproItem

class QiubaiSpider(scrapy.Spider):
    name = 'qiubai'
    #allowed_domains = ['www.qiushibaike.com/text']
    start_urls = ['https://www.qiushibaike.com/text/']
    def parse(self, response):
        #建議你們使用xpath進行指定內容的解析（框架集成了xpath解析的接口）
        # 段子的內容和做者
        div_list = response.xpath('//div[@id="content-left"]/div')
        for div in div_list:
            #xpath解析到的指定內容被存儲到了Selector對象
            #extract()該方法能夠將Selector對象中存儲的數據值拿到
            #author = div.xpath('./div/a[2]/h2/text()').extract()[0]
            #extract_first()  ==   extract()[0]
            author = div.xpath('./div/a[2]/h2/text()').extract_first()
            content = div.xpath('.//div[@class="content"]/span/text()').extract_first()

            #1.將解析到的數據值（author和content）存儲到items對象
            #建立items對象
            item = QiubaiproItem()
            item['author'] = author
            item['content'] = content

            #2.將item對象提交給管道
            yield item


"""
items.py
"""
# -*- coding: utf-8 -*-

# Define here the models for your scraped items
#
# See documentation in:
# https://doc.scrapy.org/en/latest/topics/items.html

import scrapy

class QiubaiproItem(scrapy.Item):
    # define the fields for your item here like:
    # name = scrapy.Field()
    author = scrapy.Field()
    content = scrapy.Field()

"""
pipelines.py
"""
# -*- coding: utf-8 -*-

# Define your item pipelines here
#
# Don't forget to add your pipeline to the ITEM_PIPELINES setting
# See: https://doc.scrapy.org/en/latest/topics/item-pipeline.html

import redis

class QiubaiproPipelineByRedis(object):
    conn = None
    def open_spider(self,spider):
        print('開始爬蟲')
        self.conn = redis.Redis(host='127.0.0.1',port=6379)
    def process_item(self, item, spider):
        dict = {
            'author':item['author'],
            'content':item['content']
        }
        # 寫入redis中
        self.conn.lpush('data', dict)
        return item

"""
settings.py
19行
22行
68行 開啓管道
"""
# Crawl responsibly by identifying yourself (and your website) on the user-agent
#USER_AGENT = 'qiubaiPro (+http://www.yourdomain.com)'
USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.106 Safari/537.36'

# Obey robots.txt rules
ROBOTSTXT_OBEY = False

ITEM_PIPELINES = {
    'qiubaiPro.pipelines.QiubaiproPipelineByRedis': 300,  #300表示爲優先級，值越小優先級越高
}

基於redis的管道存儲

"""
不一樣形式的持久化操做
1.對應文件的修改（spiders/qiubai.py，items.py，pipelines.py，settings.py）
2.使用終端指令完成數據存儲到制定磁盤文件中的操做
scrapy crawl qiubai --nolog
3.主要就是管道文件pipelines.py和配置文件settings.py
	-須要在管道文件中編寫對應平臺的管道類
	-在配置文件中對自定義的管道類進行生效操做
"""
# -*- coding: utf-8 -*-
import scrapy
from qiubaiPro.items import QiubaiproItem

class QiubaiSpider(scrapy.Spider):
    name = 'qiubai'
    #allowed_domains = ['www.qiushibaike.com/text']
    start_urls = ['https://www.qiushibaike.com/text/']
    def parse(self, response):
        #建議你們使用xpath進行指定內容的解析（框架集成了xpath解析的接口）
        # 段子的內容和做者
        div_list = response.xpath('//div[@id="content-left"]/div')
        for div in div_list:
            #xpath解析到的指定內容被存儲到了Selector對象
            #extract()該方法能夠將Selector對象中存儲的數據值拿到
            #author = div.xpath('./div/a[2]/h2/text()').extract()[0]
            #extract_first()  ==   extract()[0]
            author = div.xpath('./div/a[2]/h2/text()').extract_first()
            content = div.xpath('.//div[@class="content"]/span/text()').extract_first()

            #1.將解析到的數據值（author和content）存儲到items對象
            #建立items對象
            item = QiubaiproItem()
            item['author'] = author
            item['content'] = content

            #2.將item對象提交給管道
            yield item


"""
items.py
"""
# -*- coding: utf-8 -*-

# Define here the models for your scraped items
#
# See documentation in:
# https://doc.scrapy.org/en/latest/topics/items.html

import scrapy

class QiubaiproItem(scrapy.Item):
    # define the fields for your item here like:
    # name = scrapy.Field()
    author = scrapy.Field()
    content = scrapy.Field()

"""
pipelines.py
"""
# -*- coding: utf-8 -*-

# Define your item pipelines here
#
# Don't forget to add your pipeline to the ITEM_PIPELINES setting
# See: https://doc.scrapy.org/en/latest/topics/item-pipeline.html

import redis

class QiubaiproByRedis(object):
    conn = None
    def open_spider(self,spider):
        print('開始爬蟲')
        self.conn = redis.Redis(host='127.0.0.1',port=6379)
    def process_item(self, item, spider):
        dict = {
            'author':item['author'],
            'content':item['content']
        }
        # 寫入redis中
        self.conn.lpush('data', dict)
        return item


class QiubaiproPipeline(object):
    fp = None
    # 整個爬蟲過程當中，該方法只會在開始爬蟲的時候被調用一次
    def open_spider(self, spider):
        print('開始爬蟲')
        self.fp = open('./qiubai_pipe.txt', 'w', encoding='utf-8')

    # 該方法就能夠接受爬蟲文件中提交過來的item對象，而且對item對象中存儲的頁面數據進行持久化存儲
    # 參數：item表示的就是接收到的item對象

    # 每當爬蟲文件向管道提交一次item，則該方法就會被執行一次
    # 由於該方法會被執行調用屢次，因此文件的開啓和關閉操做寫在了另外兩個只會各自執行一次的方法中。
    def process_item(self, item, spider):
        # print('process_item 被調用！！！')
        # 取出item對象中存儲的數據值
        author = item['author']
        content = item['content']

        # 持久化存儲
        self.fp.write(author + ":" + content + '\n\n\n')
        return item

    # 該方法只會在爬蟲結束的時候被調用一次
    def close_spider(self, spider):
        print('爬蟲結束')
        self.fp.close()

"""
settings.py
19行
22行
68行 開啓管道
"""
# Crawl responsibly by identifying yourself (and your website) on the user-agent
#USER_AGENT = 'qiubaiPro (+http://www.yourdomain.com)'
USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.106 Safari/537.36'

# Obey robots.txt rules
ROBOTSTXT_OBEY = False

#下列結構爲字典，字典中的鍵值表示的是即將被啓用執行的管道文件和其執行的優先級。
ITEM_PIPELINES = {
    'qiubaiPro.pipelines.QiubaiproByRedis': 300,  #300表示爲優先級，值越小優先級越高
    'qiubaiPro.pipelines.QiubaiproPipeline': 200,
}
#上述代碼中，字典中的兩組鍵值分別表示會執行管道文件中對應的兩個管道類中的process_item方法，實現兩種不一樣形式的持久化操做。

不一樣形式的持久化操做

"""
多個url頁面數據爬取
1.對應文件的修改（spiders/qiubai.py，items.py，pipelines.py，settings.py）
2.使用終端指令完成數據存儲到制定磁盤文件中的操做
scrapy crawl qiubai --nolog
"""
# -*- coding: utf-8 -*-
import scrapy
from qiubaiByPages.items import QiubaibypagesItem

class QiubaiSpider(scrapy.Spider):
    name = 'qiubai'
    #allowed_domains = ['www.qiushibaike.com/text']
    start_urls = ['https://www.qiushibaike.com/text/']

    #設計一個通用的url模板
    url = 'https://www.qiushibaike.com/text/page/%d/'
    pageNum = 1

    def parse(self, response):
        div_list = response.xpath('//*[@id="content-left"]/div')

        for div in div_list:
            author = div.xpath('./div[@class="author clearfix"]/a[2]/h2/text()').extract_first()
            content = div.xpath('.//div[@class="content"]/span/text()').extract_first()

            #建立一個items對象，將解析到數據值存儲到items對象中
            item = QiubaibypagesItem()
            item['author'] = author
            item['content'] = content

            #將item提交給管道
            yield item

        #請求的手動發送
        #13表示的是最後一頁的頁碼
        if self.pageNum <= 13:
            print('爬取到了第%d頁的頁面數據'%self.pageNum)
            self.pageNum += 1
            new_url = format(self.url % self.pageNum)
            #callback:將請求獲取到的頁面數據進行解析
            yield scrapy.Request(url=new_url,callback=self.parse)


"""
items.py
"""
# -*- coding: utf-8 -*-

# Define here the models for your scraped items
#
# See documentation in:
# https://doc.scrapy.org/en/latest/topics/items.html

import scrapy


class QiubaibypagesItem(scrapy.Item):
    # define the fields for your item here like:
    # name = scrapy.Field()
    author = scrapy.Field()
    content = scrapy.Field()

"""
pipelines.py
"""
# -*- coding: utf-8 -*-

# Define your item pipelines here
#
# Don't forget to add your pipeline to the ITEM_PIPELINES setting
# See: https://doc.scrapy.org/en/latest/topics/item-pipeline.html


class QiubaibypagesPipeline(object):
    fp = None
    def open_spider(self,spider):
        print('開始爬蟲')
        self.fp = open('./qiubai.txt','w',encoding='utf-8')
    def process_item(self, item, spider):
        self.fp.write(item['author']+":"+item['content'])
        return item
    def close_spider(self,spider):
        self.fp.close()
        print('爬蟲結束')

"""
settings.py
19行
22行
68行 開啓管道
"""
# Crawl responsibly by identifying yourself (and your website) on the user-agent
#USER_AGENT = 'qiubaiPro (+http://www.yourdomain.com)'
USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.106 Safari/537.36'

# Obey robots.txt rules
ROBOTSTXT_OBEY = False

ITEM_PIPELINES = {
    'qiubaiByPages.pipelines.QiubaibypagesPipeline': 300,
}

多個url頁面數據爬取

一、Scrapy核心組件

引擎(Scrapy):
1. 用來處理整個系統的數據流處理, 觸發事務(框架核心)
調度器(Scheduler):
1. 用來接受引擎發過來的請求, 壓入隊列中, 並在引擎再次請求的時候返回. 能夠想像成一個URL（抓取網頁的網址或者說是連接）的優先隊列, 由它來決定下一個要抓取的網址是什麼, 同時去除重複的網址
下載器(Downloader):
1. 用於下載網頁內容,並將網頁內容返回給蜘蛛(Scrapy下載器是創建在twisted這個高效的異步模型上的)
爬蟲(Spiders):
1. 爬蟲是主要幹活的, 用於從特定的網頁中提取本身須要的信息, 即所謂的實體(Item)。用戶也能夠從中提取出連接,讓Scrapy繼續抓取下一個頁面
項目管道(Pipeline):
1. 負責處理爬蟲從網頁中抽取的實體，主要的功能是持久化實體、驗證明體的有效性、清除不須要的信息。當頁面被爬蟲解析後，將被髮送到項目管道，並通過幾個特定的次序處理數據。

3、代理和cookie

一、post請求發送

問題：在以前代碼中，咱們歷來沒有手動的對start_urls列表中存儲的起始url進行過請求的發送，可是起始url的確是進行了請求的發送，那這是如何實現的呢？
解答：實際上是由於爬蟲文件中的爬蟲類繼承到了Spider父類中的start_requests（self）這個方法，該方法就能夠對start_urls列表中的url發起請求
【注意】start_requests方法默認的實現，是對起始的url發起get請求，若是想發起post請求，則須要子類重寫該方法。

"""
post請求發送
"""
# -*- coding: utf-8 -*-
import scrapy
#需求：百度翻譯中指定詞條對應的翻譯結果進行獲取
class PostdemoSpider(scrapy.Spider):
    name = 'postDemo'
    #allowed_domains = ['www.baidu.com']
    start_urls = ['https://fanyi.baidu.com/sug']
    #該方法實際上是父類中的一個方法：該方法能夠對star_urls列表中的元素進行get請求的發送
    #發起post：
        #1.將Request方法中method參數賦值成post
        #2.FormRequest()能夠發起post請求（推薦）
    def start_requests(self):
        print('start_requests()')
        #post請求的參數
        data = {
            'kw': 'dog',
        }
        for url in self.start_urls:
            #formdata:請求參數對應的字典
            yield scrapy.FormRequest(url=url,formdata=data,callback=self.parse)

    #發起get：
    # def start_requests(self):
    #     for u in self.start_urls:
    #         yield scrapy.Request(url=url, callback=self.parse)

    def parse(self, response):
        print(response.text)

post請求發送

二、cookie

登陸後，獲取該用戶我的主頁這個二級頁面的頁面數據

"""
cookie:豆瓣網我的登陸，獲取該用戶我的主頁這個二級頁面的頁面數據。
"""
# -*- coding: utf-8 -*-
import scrapy


class DoubanSpider(scrapy.Spider):
    name = 'douban'
    #allowed_domains = ['www.douban.com']
    start_urls = ['https://www.douban.com/accounts/login']

    #重寫start_requests方法
    def start_requests(self):
        #將請求參數封裝到字典
        data = {
            'source': 'index_nav',
            'form_email': '15027900535',
            'form_password': 'bobo@15027900535'
        }
        for url in self.start_urls:
            yield scrapy.FormRequest(url=url,formdata=data,callback=self.parse)
    #針對我的主頁頁面數據進行解析操做
    def parseBySecondPage(self,response):
        fp = open('second.html', 'w', encoding='utf-8')
        fp.write(response.text)

        #能夠對當前用戶的我的主頁頁面數據進行指定解析操做

    def parse(self, response):
        #登陸成功後的頁面數據進行存儲
        fp = open('main.html','w',encoding='utf-8')
        fp.write(response.text)

        #獲取當前用戶的我的主頁
        url = 'https://www.douban.com/people/185687620/'
        yield scrapy.Request(url=url,callback=self.parseBySecondPage)

三、代理

下載中間件做用：攔截請求，能夠將請求的ip進行更換
流程：下載中間件類的自制定
配置文件中進行下載中間件的開啓

"""
代理：
下載中間件做用：攔截請求，能夠將請求的ip進行更換。
流程：
1.    下載中間件類的自制定
    a)    object
    b)    重寫process_request(self,request,spider)的方法
2.    配置文件中進行下載中間件的開啓。
"""
# -*- coding: utf-8 -*-
import scrapy

class ProxydemoSpider(scrapy.Spider):
    name = 'proxyDemo'
    #allowed_domains = ['www.baidu.com/s?wd=ip']
    start_urls = ['https://www.baidu.com/s?wd=ip']

    def parse(self, response):
        fp = open('proxy.html','w',encoding='utf-8')
        fp.write(response.text)


"""
middlewares.py
"""
# -*- coding: utf-8 -*-

# Define here the models for your spider middleware
#
# See documentation in:
# https://doc.scrapy.org/en/latest/topics/spider-middleware.html

from scrapy import signals

#自定義一個下載中間件的類，在類中事先process_request（處理中間價攔截到的請求）方法
class MyProxy(object):
    def process_request(self,request,spider):
        #請求ip的更換
        request.meta['proxy'] = "https://178.128.90.1:8080"

"""
settings.py
19行
22行
56行 開啓下載中間件
"""
# Crawl responsibly by identifying yourself (and your website) on the user-agent
#USER_AGENT = 'qiubaiPro (+http://www.yourdomain.com)'
USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.106 Safari/537.36'

# Obey robots.txt rules
ROBOTSTXT_OBEY = False

DOWNLOADER_MIDDLEWARES = {
    'proxyPro.middlewares.MyProxy': 543,
}

代理

4、日誌等級和請求傳參

一、日誌信息

日誌等級(種類):
1. ERROR：錯誤
2. WARNING：警告
3. INFO：通常信息
4. DEBUG：調試信息（默認）
指定輸入某一種日誌信息:
1. settings.py文件中配置:LOG_LEVEL ='ERROR'
將日誌信息存儲到指定文件中，而並不是顯示在終端裏：
1. settings.py文件中配置:LOG_FILE ='log.txt'

二、請求傳參

爬取的數據值不在同一個頁面中。
列表頁和詳情頁的爬取

"""
請求傳參
"""
# -*- coding: utf-8 -*-
import scrapy
from moviePro.items import MovieproItem

class MovieSpider(scrapy.Spider):
    name = 'movie'
    #allowed_domains = ['www.id97.com']
    start_urls = ['http://www.id97.com/movie']

    #專門用於解析二級子頁面中的數據值
    def parseBySecondPage(self,response):
        actor = response.xpath('/html/body/div[1]/div/div/div[1]/div[1]/div[2]/table/tbody/tr[1]/td[2]/a/text()').extract_first()
        language = response.xpath('/html/body/div[1]/div/div/div[1]/div[1]/div[2]/table/tbody/tr[6]/td[2]/text()').extract_first()
        longTime = response.xpath('/html/body/div[1]/div/div/div[1]/div[1]/div[2]/table/tbody/tr[8]/td[2]/text()').extract_first()

        #取出Request方法的meta參數傳遞過來的字典(response.meta)
        item = response.meta['item']
        item['actor'] = actor
        item['language'] = language
        item['longTime'] = longTime
        #將item提交給管道
        yield item
    def parse(self, response):
        #名稱，類型，導演，語言，片長
        div_list = response.xpath('/html/body/div[1]/div[1]/div[2]/div')
        for div in div_list:
            name = div.xpath('.//div[@class="meta"]/h1/a/text()').extract_first()
            #以下xpath方法返回的是一個列表，切列表元素爲4
            kind = div.xpath('.//div[@class="otherinfo"]//text()').extract()
            #將kind列表轉化成字符串
            kind = "".join(kind)
            url = div.xpath('.//div[@class="meta"]/h1/a/@href').extract_first()

            print(kind)
            #建立items對象
            item = MovieproItem()
            item['name'] = name
            item['kind'] = kind
            #問題：如何將剩下的電影詳情數據存儲到item對象（meta）
            #須要對url發起請求，獲取頁面數據，進行指定數據解析
            #meta參數只能夠賦值一個字典（將item對象先封裝到字典）
            yield scrapy.Request(url=url,callback=self.parseBySecondPage,meta={'item':item})


"""
items.py
"""
# -*- coding: utf-8 -*-

# Define here the models for your scraped items
#
# See documentation in:
# https://doc.scrapy.org/en/latest/topics/items.html

import scrapy


class MovieproItem(scrapy.Item):
    # define the fields for your item here like:
    # name = scrapy.Field()
    name = scrapy.Field()
    kind = scrapy.Field()
    actor = scrapy.Field()
    language = scrapy.Field()
    longTime = scrapy.Field()

"""
pipelines.py
"""
# -*- coding: utf-8 -*-

# Define your item pipelines here
#
# Don't forget to add your pipeline to the ITEM_PIPELINES setting
# See: https://doc.scrapy.org/en/latest/topics/item-pipeline.html


class MovieproPipeline(object):
    fp = None
    def open_spider(self,spider):
        self.fp = open('movie.txt','w',encoding='utf-8')
    def process_item(self, item, spider):
        detail = item['name']+':'+item['kind']+':'+item['actor']+':'+item['language']+':'+item['longTime']+'\n\n\n'
        self.fp.write(detail)
        return item
    def close_spider(self,spider):
        self.fp.close()


"""
settings.py
19行
22行
68行 開啓管道
"""
# Crawl responsibly by identifying yourself (and your website) on the user-agent
#USER_AGENT = 'qiubaiPro (+http://www.yourdomain.com)'
USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.106 Safari/537.36'

# Obey robots.txt rules
ROBOTSTXT_OBEY = False

ITEM_PIPELINES = {
    'moviePro.pipelines.MovieproPipeline': 300,
}

請求傳參

5、CrawlSpider

CrawlSpider實際上是Spider的一個子類，除了繼承到Spider的特性和功能外，還派生除了其本身獨有的更增強大的特性和功能。其中最顯著的功能就是」LinkExtractors連接提取器「。Spider是全部爬蟲的基類，其設計原則只是爲了爬取start_url列表中網頁，而從爬取到的網頁中提取出的url進行繼續的爬取工做使用CrawlSpider更合適。
爬取全站方法1：基於Scrapy框架中的Spider的遞歸爬取進行實現（Request模塊遞歸回調parse方法）【手動請求的發送】。
爬取全站方法2：基於CrawlSpider的自動爬取進行實現（更加簡潔和高效）。【推薦】

一、使用

建立scrapy工程：scrapy startproject projectName
建立爬蟲文件：scrapy genspider -t crawl spiderName www.xxx.com (scrapy genspider -t crawl 爬蟲名稱起始url)
此指令對比之前的指令多了 "-t crawl"，表示建立的爬蟲文件是基於CrawlSpider這個類的，而再也不是Spider這個基類。

二、CrawlSpider總體爬取流程

a):爬蟲文件首先根據起始url，獲取該url的網頁內容
b):連接提取器會根據指定提取規則將步驟a中網頁內容中的連接進行提取
c):規則解析器會根據指定解析規則將連接提取器中提取到的連接中的網頁內容根據指定的規則進行解析
d):將解析數據封裝到item中，而後提交給管道進行持久化存儲
LinkExtractor：連接提取器。- 做用：提取response中符合規則的連接。
Rule : 規則解析器。根據連接提取器中提取到的連接，根據指定規則提取解析器連接網頁中的內容。

三、selenium在scrapy中的使用流程

a):重寫爬蟲文件的構造方法，在該方法中使用selenium實例化一個瀏覽器對象（由於瀏覽器對象只須要被實例化一次）
b):重寫爬蟲文件的closed(self,spider)方法，在其內部關閉瀏覽器對象。該方法是在爬蟲結束時被調用
c):重寫下載中間件的process_response方法，讓該方法對響應對象進行攔截，並篡改response中存儲的頁面數據
d):在配置文件中開啓下載中間件
原理分析：當引擎將url對應的請求提交給下載器後，下載器進行網頁數據的下載，而後將下載到的頁面數據，封裝到response中，提交給引擎，引擎將response在轉交給Spiders。 Spiders接受到的response對象中存儲的頁面數據裏是沒有動態加載的新聞數據的。要想獲取動態加載的新聞數據，則須要在下載中間件中對下載器提交給引擎的response響應對象進行攔截，切對其內部存儲的頁面數據進行篡改，修改爲攜帶了動態加載出的新聞數據，而後將被篡改的response對象最終交給Spiders進行解析操做。

四、下載中間件（Downloader Middlewares）

下載中間件（Downloader Middlewares）位於scrapy引擎和下載器之間的一層組件。
做用：引擎將請求傳遞給下載器過程當中，下載中間件能夠對請求進行一系列處理。好比設置請求的 User-Agent，設置代理等
做用：在下載器完成將Response傳遞給引擎中，下載中間件能夠對響應進行一系列處理。好比進行gzip解壓等。
咱們主要使用下載中間件處理請求，通常會對請求設置隨機的User-Agent ，設置隨機的代理。目的在於防止爬取網站的反爬蟲策略。

五、UA池：User-Agent池

做用：儘量多的將scrapy工程中的請求假裝成不一樣類型的瀏覽器身份。
操做流程：
1. 在下載中間件中攔截請求
2. 將攔截到的請求的請求頭信息中的UA進行篡改假裝
3. 在配置文件中開啓下載中間件

六、代理池

做用：儘量多的將scrapy工程中的請求的IP設置成不一樣的。
操做流程：
1. 在下載中間件中攔截請求
2. 將攔截到的請求的IP修改爲某一代理IP
3. 在配置文件中開啓下載中間件

"""
CrawlSpider

LinkExtractor：顧名思義，連接提取器。 - 做用：提取response中符合規則的連接。
LinkExtractor(
　　　　　　　  allow=r'Items/'，# 知足括號中「正則表達式」的值會被提取，若是爲空，則所有匹配。
　　　　　　　　deny=xxx,  # 知足正則表達式的則不會被提取。
             restrict_xpaths=xxx, # 知足xpath表達式的值會被提取
　　　　　　　　restrict_css=xxx, # 知足css表達式的值會被提取
　　　　　　　　deny_domains=xxx, # 不會被提取的連接的domains。　
　　  )
　　　　
Rule : 規則解析器。根據連接提取器中提取到的連接，根據指定規則提取解析器連接網頁中的內容。
　　　　 Rule(LinkExtractor(allow=r'Items/'), callback='parse_item', follow=True)
　　　　- 參數介紹：
　　　　　　參數1：指定連接提取器
　　　　　　參數2：指定規則解析器解析數據的規則（回調函數）
　　　　　　參數3：是否將連接提取器繼續做用到連接提取器提取出的連接網頁中。當callback爲None,參數3的默認值爲true。
rules=( ):指定不一樣規則解析器。一個Rule對象表示一種提取規則。

"""
# -*- coding: utf-8 -*-
import scrapy
#導入CrawlSpider相關模塊
from scrapy.linkextractors import LinkExtractor
from scrapy.spiders import CrawlSpider, Rule

#表示該爬蟲程序是基於CrawlSpider類的
class ChoutiSpider(CrawlSpider):
    name = 'chouti'
    #allowed_domains = ['dig.chouti.com']
    start_urls = ['https://dig.chouti.com/']

    #連接提取器：用來提取指定的連接（url）
    #allow參數：賦值一個正則表達式
    #連接提取器就能夠根據正則表達式在頁面中提取指定的連接
    #提取到的連接會所有交給規則解析器

    # 實例化了一個連接提取器對象，且指定其提取規則
    link = LinkExtractor(allow=r'/all/hot/recent/\d+')

    #定義規則解析器，且指定解析規則經過callback回調函數
    rules = (
        #實例化了一個規則解析器對象
        #規則解析器接受了連接提取器發送的連接後，就會對這些連接發起請求，獲取連接對應的頁面內容，就會根據指定的規則對頁面內容中指定的數據值進行解析
        #callback：指定一個解析規則（方法/函數）
        #follow:是否將連接提取器繼續做用到鏈接提取器提取出的連接所表示的頁面數據中
        Rule(link, callback='parse_item', follow=True),
    )

    #自定義規則解析器的解析規則函數
    def parse_item(self, response):
        print(response)

"""
settings.py
19行
22行
"""
# Crawl responsibly by identifying yourself (and your website) on the user-agent
#USER_AGENT = 'qiubaiPro (+http://www.yourdomain.com)'
USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.106 Safari/537.36'

# Obey robots.txt rules
ROBOTSTXT_OBEY = False

CrawlSpider

# -*- coding: utf-8 -*-
import scrapy
from newsPro.items import NewsproItem
from scrapy.linkextractors import LinkExtractor
from scrapy.spiders import CrawlSpider, Rule


class Chinanews(CrawlSpider):
    name = 'chinanews'
    # allowed_domains = ['http://www.chinanews.com/scroll-news/news1.html'] #中國新聞網（滾動新聞）
    start_urls = ['http://www.chinanews.com/scroll-news/news1.html',
                  'http://finance.chinanews.com/cj/gd.shtml'
                  ]
    custom_settings = {
        "ITEM_PIPELINES": {'newsPro.pipelines.NewsproPipeline': 300}
    }

    link = LinkExtractor(allow=r'http://www.chinanews.com/scroll-news/news\d+.html')
    link2 = LinkExtractor(allow=r'http://finance.chinanews.com/cj/gd.shtml')  # 中國新聞網（財經新聞）

    rules = (
        Rule(link, callback='parse_first', follow=True),
        Rule(link2, callback='parse_two', follow=True),
    )
    n=0

    def parse_first(self, response):
        li_list = response.xpath('/html/body//div[@class="content_list"]/ul/li')
        # print(len(li_list))
        for li in li_list:
            url = li.xpath('./div[@class="dd_bt"]/a/@href').extract_first()
            url="http:%s"%url
            # print(url)
            yield scrapy.Request(url=url, callback=self.parse_con,)

    def parse_two(self, response):
        li_list = response.xpath('/html/body//div[@class="content_list"]/ul/li')
        # print(len(li_list))
        for li in li_list:
            url = li.xpath('./div[@class="dd_bt"]/a/@href').extract_first()
            url="http://finance.chinanews.com%s"%url
            # print(url)
            yield scrapy.Request(url=url, callback=self.parse_con,)


    def parse_con(self, response):
        # self.n+=1
        # print(self.n)
        # print(response)
        div= response.xpath('/html/body//div[@id="cont_1_1_2"]')
        title =div.xpath('./h1/text()').extract_first()
        ctime_s =div.xpath('//div[@class="left-t"]/text()').extract_first().split("來源：")
        editor =div.xpath('./div[@class="left_name"]/div[@class="left_name"]/text()').extract_first()

        source =ctime_s[-1]
        ctime = ctime_s[0]

        content_list =div.xpath('./div[@class="left_zw"]/p/text()').extract()
        content = "".join(content_list)
        # print('=======', title, '=======')
        # print('=======', ctime,'=======')
        # print('=======', source, '=======')
        # print('=======', editor,  '=======')
        # print('=======',content, '=======')

        item = NewsproItem()
        item['title'] =title.strip()
        item['source'] =source.strip()
        item['content'] =content.strip()
        item['ctime'] =ctime.strip()
        item['editor'] =editor.strip()

        yield item

應用Chinanews

6、基於redis的分佈式爬蟲

一、分佈式爬蟲

概念：多臺機器上能夠執行同一個爬蟲程序，實現網站數據的分佈爬取。
原生的scrapy框架是否能夠本身實現分佈式？
1. 不能夠。
2. 緣由1：由於多臺機器上部署的scrapy會各自擁有各自的調度器，這樣就使得多臺機器沒法分配start_urls列表中的url。（多臺機器沒法共享同一個調度器）
3. 緣由2：多臺機器爬取到的數據沒法經過同一個管道對數據進行統一的數據持久出存儲。（多臺機器沒法共享同一個管道）
安裝scrapy-redis組件：
- pip install scrapy-redis
scrapy-redis組件：
- scrapy-redis是基於scrapy框架開發出的一套組件，其做用就是可讓scrapy實現分佈式爬蟲。
- 使用scrapy-redis組件中封裝好的調度器，將全部的url存儲到該指定的調度器中，從而實現了多臺機器的調度器共享。
- 使用scrapy-redis組件中封裝好的管道，將每臺機器爬取到的數據存儲經過該管道存儲到redis數據庫中，從而實現了多臺機器的管道共享。

二、基於RedisCrawlSpider分佈式爬取的流程

redis配置文件的配置：
1. win:redis.windows.conf linux:redis.conf
2. 註釋該行：bind 127.0.0.1，表示可讓其餘ip訪問redis
3. 將yes該爲no：protected-mode no，表示可讓其餘ip操做redis,關閉保護模式
redis服務器的開啓：
1. 基於配置配置文件
爬蟲文件【區別】：
1. 建立scrapy工程後，建立基於crawlSpider的爬蟲文件
2. 導入RedisCrawlSpider類(from scrapy_redis.spiders import RedisCrawlSpider)，而後將爬蟲文件修改爲基於該類的源文件(class QiubaiSpider(RedisCrawlSpider):)
3. 將start_url修改爲redis_key = 'qiubaispider' # 調度器隊列的名稱表示跟start_urls含義是同樣
管道文件：
1. 在配置文件中進行相應配置：將管道配置成scrapy-redis集成的管道
2. 在scrapy-redis組件中已經幫助咱們封裝好了一個專門用於鏈接存儲redis數據庫的管道（RedisPipeline），所以咱們直接使用便可，無需本身編寫管道文件。
調度器：
1. 在配置文件中將調度器切換成scrapy-redis集成好的調度器
配置文件：
- 在settings.py中開啓管道且將管道配置成scrapy-redis集成的管道。
- 在settings.py中將調度器切換成scrapy-redis集成好的調度器
- 該管道默認會鏈接且將數據存儲到本機的redis服務中，若是想要鏈接存儲到其餘redis服務中須要在settings.py中進行配置
開啓redis數據庫的服務：
1. redis-server 配置文件
執行爬蟲程序：
1. cd 到存放xxx.py的spiders目錄
2. scrapy runspider xxx.py
redis客戶端：
1. 向調度器的隊列中扔一個起始url （lpush 調度器隊列的名稱「起始url」）lpush wangyi https://news.163.com
2. ctrl + c 中止爬取
3. keys * 查看
4. lrange wangyi:items 0 -1 查看

三、基於RedisSpider的第二種形式的分佈式爬蟲（網易新聞）

其餘配置和上面同樣，只有爬蟲文件不同
爬蟲文件【區別】：
1. 建立scrapy工程後，建立基於Spider的爬蟲文件
2. 導入RedisSpider類(from scrapy_redis.spiders import RedisSpider)，而後將爬蟲文件修改爲基於該類的源文件(class WangyiSpider(RedisSpider):)
3. 將start_url修改爲redis_key = 'wangyi' 調度器隊列名稱

四、UA池：

在中間件類中進行導包 from scrapy.contrib.downloadermiddleware.useragent import UserAgentMiddleware
封裝一個基於UserAgentMiddleware的類，且重寫該類的process_requests方法

五、代理池：

注意請求url的協議後究竟是http仍是https

六、selenium如何被應用到scrapy：

在爬蟲文件中導入webdriver類
在爬蟲文件的爬蟲類的構造方法中進行了瀏覽器實例化的操做
在爬蟲類的closed方法中進行瀏覽器關閉的操做
在下載中間件的process_response方法中編寫執行瀏覽器自動化的操做

"""
redis實現分佈式基本流程
"""
# -*- coding: utf-8 -*-
import scrapy
from scrapy.linkextractors import LinkExtractor
from scrapy.spiders import CrawlSpider, Rule
from redisPro.items import RedisproItem
#導入scrapy-redis中的模塊
from scrapy_redis.spiders import RedisCrawlSpider
from redisPro.items import RedisproItem

class QiubaiSpider(RedisCrawlSpider):
    name = 'qiubai'
    #allowed_domains = ['https://www.qiushibaike.com/pic/']
    #start_urls = ['https://www.qiushibaike.com/pic/']

    #調度器隊列的名稱
    redis_key = 'qiubaispider'  #表示跟start_urls含義是同樣

    #【注意】近期糗事百科更新了糗圖板塊的反爬機制，更新後該板塊的頁碼連接/pic/page/2/s=5135066，
    # 末尾的數字每次頁面刷新都會變化，所以正則不可寫爲/pic/page/\d+/s=5135066而應該修改爲/pic/page/\d+
    link = LinkExtractor(allow=r'/pic/page/\d+')
    rules = (
        Rule(link, callback='parse_item', follow=True),
    )

    def parse_item(self, response):
       #將圖片的url進行解析

        div_list = response.xpath('//*[@id="content-left"]/div')
        for div in div_list:
            img_url = div.xpath('./div[@class="thumb"]/a/img/@src').extract_first()
            item = RedisproItem()
            item['img_url'] = img_url

            yield item



"""
items.py
"""
# -*- coding: utf-8 -*-

# Define here the models for your scraped items
#
# See documentation in:
# https://doc.scrapy.org/en/latest/topics/items.html

import scrapy


class RedisproItem(scrapy.Item):
    # define the fields for your item here like:
    # name = scrapy.Field()
    img_url = scrapy.Field()


"""
pipelines.py
"""
# -*- coding: utf-8 -*-

# Define your item pipelines here
#
# Don't forget to add your pipeline to the ITEM_PIPELINES setting
# See: https://doc.scrapy.org/en/latest/topics/item-pipeline.html


class RedisproPipeline(object):
    def process_item(self, item, spider):
        return item



"""
settings.py
19行
22行
...管道
...調度器
"""
# Crawl responsibly by identifying yourself (and your website) on the user-agent
#USER_AGENT = 'qiubaiPro (+http://www.yourdomain.com)'
USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.106 Safari/537.36'

# Obey robots.txt rules
ROBOTSTXT_OBEY = False


ITEM_PIPELINES = {
    #'redisPro.pipelines.RedisproPipeline': 300,
    'scrapy_redis.pipelines.RedisPipeline': 400,
}


# 使用scrapy-redis組件的去重隊列
DUPEFILTER_CLASS = "scrapy_redis.dupefilter.RFPDupeFilter"
# 使用scrapy-redis組件本身的調度器
SCHEDULER = "scrapy_redis.scheduler.Scheduler"
# 是否容許暫停
SCHEDULER_PERSIST = True

#若是redis服務器不在本身本機，則須要配置redis服務的ip和端口
REDIS_HOST = '172.20.10.7'  #redis數據庫所在的機器上的ip地址
REDIS_PORT = 6379
#REDIS_PARAMS = {‘password’:’123456’}

RedisCrawlSpider實現分佈式基本流程

"""
selenium在scrapy中的應用

from scrapy.http import HtmlResponse
    #參數介紹：
    #攔截到響應對象（下載器傳遞給Spider的響應對象）
    #request：響應對象對應的請求對象
    #response：攔截到的響應對象
    #spider：爬蟲文件中對應的爬蟲類的實例
    def process_response(self, request, response, spider):
        #響應對象中存儲頁面數據的篡改
        if request.url in['http://news.163.com/domestic/','http://news.163.com/world/','http://news.163.com/air/','http://war.163.com/']:
            spider.bro.get(url=request.url)
            js = 'window.scrollTo(0,document.body.scrollHeight)'
            spider.bro.execute_script(js)
            time.sleep(2)  #必定要給與瀏覽器必定的緩衝加載數據的時間
            #頁面數據就是包含了動態加載出來的新聞數據對應的頁面數據
            page_text = spider.bro.page_source
            #篡改響應對象
            return HtmlResponse(url=spider.bro.current_url,body=page_text,encoding='utf-8',request=request)
        else:
            return response

"""
# -*- coding: utf-8 -*-
import scrapy
from selenium import webdriver
from wangyiPro.items import WangyiproItem
from scrapy_redis.spiders import RedisSpider
class WangyiSpider(RedisSpider):
    name = 'wangyi'
    #allowed_domains = ['www.xxxx.com']
    #start_urls = ['https://news.163.com']
    redis_key = 'wangyi'

    def __init__(self):
        #實例化一個瀏覽器對象(實例化一次)
        self.bro = webdriver.Chrome(executable_path='/Users/bobo/Desktop/chromedriver')

    #必須在整個爬蟲結束後，關閉瀏覽器
    def closed(self,spider):
        print('爬蟲結束')
        self.bro.quit()

    def parse(self, response):
        lis = response.xpath('//div[@class="ns_area list"]/ul/li')
        indexs = [3,4,6,7]
        li_list = []  #存儲的就是國內，國際，軍事，航空四個板塊對應的li標籤對象
        for index in indexs:
            li_list.append(lis[index])
        #獲取四個板塊中的連接和文字標題
        for li in li_list:
            url = li.xpath('./a/@href').extract_first()
            title = li.xpath('./a/text()').extract_first()

            #print(url+":"+title)

            #對每個板塊對應的url發起請求，獲取頁面數據（標題，縮略圖，關鍵字，發佈時間，url）
            yield scrapy.Request(url=url,callback=self.parseSecond,meta={'title':title})


    def parseSecond(self,response):
        div_list = response.xpath('//div[@class="data_row news_article clearfix "]')
        #print(len(div_list))
        for div in div_list:
            head = div.xpath('.//div[@class="news_title"]/h3/a/text()').extract_first()
            url = div.xpath('.//div[@class="news_title"]/h3/a/@href').extract_first()
            imgUrl = div.xpath('./a/img/@src').extract_first()
            tag = div.xpath('.//div[@class="news_tag"]//text()').extract()
            tags = []
            for t in tag:
                t = t.strip(' \n \t')
                tags.append(t)
            tag = "".join(tags)

            #獲取meta傳遞過來的數據值title
            title = response.meta['title']

            #實例化item對象，將解析到的數據值存儲到item對象中
            item = WangyiproItem()
            item['head'] = head
            item['url'] = url
            item['imgUrl'] = imgUrl
            item['tag'] = tag
            item['title'] = title

            #對url發起請求，獲取對應頁面中存儲的新聞內容數據
            yield scrapy.Request(url=url,callback=self.getContent,meta={'item':item})
            #print(head+":"+url+":"+imgUrl+":"+tag)


    def getContent(self,response):
        #獲取傳遞過來的item
        item = response.meta['item']

        #解析當前頁面中存儲的新聞數據
        content_list = response.xpath('//div[@class="post_text"]/p/text()').extract()
        content = "".join(content_list)
        item['content'] = content

        yield item


"""
items.py
"""
# -*- coding: utf-8 -*-

# Define here the models for your scraped items
#
# See documentation in:
# https://doc.scrapy.org/en/latest/topics/items.html

import scrapy


class WangyiproItem(scrapy.Item):
    # define the fields for your item here like:
    head = scrapy.Field()
    url = scrapy.Field()
    imgUrl = scrapy.Field()
    tag = scrapy.Field()
    title = scrapy.Field()
    content = scrapy.Field()


"""
pipelines.py
"""
# -*- coding: utf-8 -*-

# Define your item pipelines here
#
# Don't forget to add your pipeline to the ITEM_PIPELINES setting
# See: https://doc.scrapy.org/en/latest/topics/item-pipeline.html


class WangyiproPipeline(object):
    def process_item(self, item, spider):
        print(item['title']+':'+item['content'])
        return item


"""
middlewares.py
"""
# -*- coding: utf-8 -*-

# Define here the models for your spider middleware
#
# See documentation in:
# https://doc.scrapy.org/en/latest/topics/spider-middleware.html

from scrapy import signals

from scrapy.http import HtmlResponse
import time
from scrapy.contrib.downloadermiddleware.useragent import UserAgentMiddleware
import random
#UA池代碼的編寫（單獨給UA池封裝一個下載中間件的一個類）
#1，導包UserAgentMiddlware類
class RandomUserAgent(UserAgentMiddleware):

    def process_request(self, request, spider):
        #從列表中隨機抽選出一個ua值
        ua = random.choice(user_agent_list)
        #ua值進行當前攔截到請求的ua的寫入操做
        request.headers.setdefault('User-Agent',ua)

#批量對攔截到的請求進行ip更換
class Proxy(object):
    def process_request(self, request, spider):
        #對攔截到請求的url進行判斷（協議頭究竟是http仍是https）
        #request.url返回值：http://www.xxx.com
        h = request.url.split(':')[0]  #請求的協議頭
        if h == 'https':
            ip = random.choice(PROXY_https)
            request.meta['proxy'] = 'https://'+ip
        else:
            ip = random.choice(PROXY_http)
            request.meta['proxy'] = 'http://' + ip

class WangyiproDownloaderMiddleware(object):
    # Not all methods need to be defined. If a method is not defined,
    # scrapy acts as if the downloader middleware does not modify the
    # passed objects.



    def process_request(self, request, spider):
        # Called for each request that goes through the downloader
        # middleware.

        # Must either:
        # - return None: continue processing this request
        # - or return a Response object
        # - or return a Request object
        # - or raise IgnoreRequest: process_exception() methods of
        #   installed downloader middleware will be called
        return None
    #攔截到響應對象（下載器傳遞給Spider的響應對象）
    #request：響應對象對應的請求對象
    #response：攔截到的響應對象
    #spider：爬蟲文件中對應的爬蟲類的實例
    def process_response(self, request, response, spider):
        #響應對象中存儲頁面數據的篡改
        if request.url in['http://news.163.com/domestic/','http://news.163.com/world/','http://news.163.com/air/','http://war.163.com/']:
            spider.bro.get(url=request.url)
            js = 'window.scrollTo(0,document.body.scrollHeight)'
            spider.bro.execute_script(js)
            time.sleep(2)  #必定要給與瀏覽器必定的緩衝加載數據的時間
            #頁面數據就是包含了動態加載出來的新聞數據對應的頁面數據
            page_text = spider.bro.page_source
            #篡改響應對象
            return HtmlResponse(url=spider.bro.current_url,body=page_text,encoding='utf-8',request=request)
        else:
            return response

PROXY_http = [
    '153.180.102.104:80',
    '195.208.131.189:56055',
]
PROXY_https = [
    '120.83.49.90:9000',
    '95.189.112.214:35508',
]

user_agent_list = [
        "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.1 "
        "(KHTML, like Gecko) Chrome/22.0.1207.1 Safari/537.1",
        "Mozilla/5.0 (X11; CrOS i686 2268.111.0) AppleWebKit/536.11 "
        "(KHTML, like Gecko) Chrome/20.0.1132.57 Safari/536.11",
        "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.6 "
        "(KHTML, like Gecko) Chrome/20.0.1092.0 Safari/536.6",
        "Mozilla/5.0 (Windows NT 6.2) AppleWebKit/536.6 "
        "(KHTML, like Gecko) Chrome/20.0.1090.0 Safari/536.6",
        "Mozilla/5.0 (Windows NT 6.2; WOW64) AppleWebKit/537.1 "
        "(KHTML, like Gecko) Chrome/19.77.34.5 Safari/537.1",
        "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/536.5 "
        "(KHTML, like Gecko) Chrome/19.0.1084.9 Safari/536.5",
        "Mozilla/5.0 (Windows NT 6.0) AppleWebKit/536.5 "
        "(KHTML, like Gecko) Chrome/19.0.1084.36 Safari/536.5",
        "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.3 "
        "(KHTML, like Gecko) Chrome/19.0.1063.0 Safari/536.3",
        "Mozilla/5.0 (Windows NT 5.1) AppleWebKit/536.3 "
        "(KHTML, like Gecko) Chrome/19.0.1063.0 Safari/536.3",
        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_0) AppleWebKit/536.3 "
        "(KHTML, like Gecko) Chrome/19.0.1063.0 Safari/536.3",
        "Mozilla/5.0 (Windows NT 6.2) AppleWebKit/536.3 "
        "(KHTML, like Gecko) Chrome/19.0.1062.0 Safari/536.3",
        "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.3 "
        "(KHTML, like Gecko) Chrome/19.0.1062.0 Safari/536.3",
        "Mozilla/5.0 (Windows NT 6.2) AppleWebKit/536.3 "
        "(KHTML, like Gecko) Chrome/19.0.1061.1 Safari/536.3",
        "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.3 "
        "(KHTML, like Gecko) Chrome/19.0.1061.1 Safari/536.3",
        "Mozilla/5.0 (Windows NT 6.1) AppleWebKit/536.3 "
        "(KHTML, like Gecko) Chrome/19.0.1061.1 Safari/536.3",
        "Mozilla/5.0 (Windows NT 6.2) AppleWebKit/536.3 "
        "(KHTML, like Gecko) Chrome/19.0.1061.0 Safari/536.3",
        "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/535.24 "
        "(KHTML, like Gecko) Chrome/19.0.1055.1 Safari/535.24",
        "Mozilla/5.0 (Windows NT 6.2; WOW64) AppleWebKit/535.24 "
        "(KHTML, like Gecko) Chrome/19.0.1055.1 Safari/535.24"
]




"""
settings.py
19行
22行
56開啓下載中間件
...管道
"""
# Crawl responsibly by identifying yourself (and your website) on the user-agent
#USER_AGENT = 'qiubaiPro (+http://www.yourdomain.com)'
USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.106 Safari/537.36'

# Obey robots.txt rules
ROBOTSTXT_OBEY = False

DOWNLOADER_MIDDLEWARES = {
    'wangyiPro.middlewares.WangyiproDownloaderMiddleware': 543,
    'wangyiPro.middlewares.RandomUserAgent': 542,
    'wangyiPro.middlewares.Proxy': 541,
}

ITEM_PIPELINES = {
    #'wangyiPro.pipelines.WangyiproPipeline': 300,
    'scrapy_redis.pipelines.RedisPipeline': 400,
}



#配置redis服務的ip和端口
REDIS_HOST = '172.20.10.7'  #redis數據庫所在的機器上的ip地址
REDIS_PORT = 6379
#REDIS_PARAMS = {‘password’:’123456’}

# 使用scrapy-redis組件的去重隊列
DUPEFILTER_CLASS = "scrapy_redis.dupefilter.RFPDupeFilter"
# 使用scrapy-redis組件本身的調度器
SCHEDULER = "scrapy_redis.scheduler.Scheduler"
# 是否容許暫停
SCHEDULER_PERSIST = True