Scrapy框架学习从基础到分布式搭建

一、什么是Scrapy？

Scrapy是一个为了爬取网站数据，提取结构性数据而编写的应用框架，非常出名，非常强悍。所谓的框架就是一个已经被集成了各种功能（高性能异步下载，队列，分布式，解析，持久化等）的具有很强通用性的项目模板。对于框架的学习，重点是要学习其框架的特性、各个功能的用法即可。

二、安装Scrapy:

Linux：
pip3 install scrapy

Windows：
a. pip3 install wheel
b. 下载twisted http://www.lfd.uci.edu/~gohlke/pythonlibs/#twisted
c. 进入下载目录，执行 pip3 install Twisted‑17.1.0‑cp35‑cp35m‑win_amd64.whl
d. pip3 install pywin32
e. pip3 install scrapy

三、Scrapy基础使用步骤:

1.创建项目：scrapy startproject 项目名称
　　项目结构：
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 爬虫目录，如：创建文件，编写爬虫解析规则
.
2.创建爬虫应用程序：
　　　cd project_name（进入项目目录）
　　　scrapy genspider 应用名称 爬取网页的起始url （例如：scrapy genspider qiubai www.qiushibaike.com）
.
3.编写爬虫文件:在步骤2执行完毕后，会在项目的spiders中生成一个应用名的py爬虫文件，文件源码如下：

Scrapy.png
4.设置修改settings.py配置文件相关配置:
相关配置
5.执行爬虫程序：scrapy crawl 应用名称

流程演示代码示例：

import scrapy

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

    def parse(self, response):
        // xpath为response中的方法，可以将xpath表达式直接作用于该函数中
        odiv = response.xpath('//div[@id="content-left"]/div')
        with open('./data.txt', 'w') as fp:
            for div in odiv:

                 // 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()

                 // 持久化存储爬取到的内容
                 fp.write(author + ':' + content + '\n')

上述代码表示的持久化操作是我们自己通过IO操作将数据进行的文件存储。在scrapy框架中已经为我们专门集成好了高效、便捷的持久化操作功能，我们直接使用即可。要想使用scrapy的持久化操作功能，我们首先来认识如下两个文件：
　　items.py：数据结构模板文件。定义数据属性。
　　pipelines.py：管道文件。接收数据（items），进行持久化操作。
.
持久化流程：
　　1.爬虫文件爬取到数据后，需要将数据封装到items对象中。
　　2.使用yield关键字将items对象提交给pipelines管道进行持久化操作。
　　3.settings.py配置文件中开启管道

小试牛刀：
将糗事百科首页中的段子和作者数据爬取下来，然后进行持久化存储

爬虫文件：qiubaiDemo.py

import scrapy
from secondblood.items import SecondbloodItem

class QiubaidemoSpider(scrapy.Spider):
    name = 'qiubaiDemo'
    allowed_domains = ['www.qiushibaike.com']
    start_urls = ['http://www.qiushibaike.com/']

    def parse(self, response):
        odiv = response.xpath('//div[@id="content-left"]/div')
        for div in odiv:
            //xpath函数返回的为列表，列表中存放的数据为Selector类型的数据。我们解析到的内
            //容被封装在了Selector对象中，需要调用extract()函数将解析的内容从Selecor中取出。
            author = div.xpath('.//div[@class="author clearfix"]//h2/text()').extract_first()
            author = author.strip('\n')#过滤空行
            content = div.xpath('.//div[@class="content"]/span/text()').extract_first()
            content = content.strip('\n')#过滤空行

            // 将解析到的数据封装至items对象中
            item = SecondbloodItem()
            item['author'] = author
            item['content'] = content
            // 提交item到管道文件（pipelines.py）
            yield item

items文件：items.py

import scrapy

class SecondbloodItem(scrapy.Item):
     //存储作者
    author = scrapy.Field() 
    //存储段子内容
    content = scrapy.Field() 

管道文件：pipelines.py

class SecondbloodPipeline(object):
    // 构造方法
    def __init__(self):
        self.fp = None  #定义一个文件描述符属性
　　// 下列都是在重写父类的方法：
    // 开始爬虫时，执行一次
    def open_spider(self,spider):
        print('爬虫开始')
        self.fp = open('./data.txt', 'w')

　　 // 因为该方法会被执行调用多次，所以文件的开启和关闭操作写在了另外两个只会各自执行一次的方法中。
    def process_item(self, item, spider):
        // 将爬虫程序提交的item进行持久化存储
        self.fp.write(item['author'] + ':' + item['content'] + '\n')
        return item

    // 结束爬虫时，执行一次
    def close_spider(self,spider):
        self.fp.close()
        print('爬虫结束')

配置文件：settings.py

// 开启管道
ITEM_PIPELINES = {
    'secondblood.pipelines.SecondbloodPipeline': 300, #300表示为优先级，值越小优先级越高
}

四、Scrapy递归爬取多页数据：

需求：将糗事百科所有页码的作者和段子内容数据进行爬取且持久化存储:

import scrapy
from qiushibaike.items import QiushibaikeItem

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

    // 爬取多页
    pageNum = 1 #起始页码
    url = 'https://www.qiushibaike.com/text/page/%s/' #每页的url

    def parse(self, response):
        div_list=response.xpath('//*[@id="content-left"]/div')
        for div in div_list:
            // //*[@id="qiushi_tag_120996995"]/div[1]/a[2]/h2
            author=div.xpath('.//div[@class="author clearfix"]//h2/text()').extract_first()
            author=author.strip('\n')
            content=div.xpath('.//div[@class="content"]/span/text()').extract_first()
            content=content.strip('\n')
            item=QiushibaikeItem()
            item['author']=author
            item['content']=content

            yield item #提交item到管道进行持久化

         // 爬取所有页码数据
        if self.pageNum <= 13: #一共爬取13页（共13页）
            self.pageNum += 1
            url = format(self.url % self.pageNum)

            //递归爬取数据：callback参数的值为回调函数（将url请求后，
            //得到的相应数据继续进行parse解析），递归调用parse函数
            yield scrapy.Request(url=url,callback=self.parse)

五、Scrapy核心组件介绍：

Scrapy核心组件
引擎(Scrapy)
用来处理整个系统的数据流处理, 触发事务(框架核心)
调度器(Scheduler)
用来接受引擎发过来的请求, 压入队列中, 并在引擎再次请求的时候返回. 可以想像成一个URL（抓取网页的网址或者说是链接）的优先队列, 由它来决定下一个要抓取的网址是什么, 同时去除重复的网址
下载器(Downloader)
用于下载网页内容, 并将网页内容返回给蜘蛛(Scrapy下载器是建立在twisted这个高效的异步模型上的)
爬虫(Spiders)
爬虫是主要干活的, 用于从特定的网页中提取自己需要的信息, 即所谓的实体(Item)。用户也可以从中提取出链接,让Scrapy继续抓取下一个页面
项目管道(Pipeline)
负责处理爬虫从网页中抽取的实体，主要的功能是持久化实体、验证实体的有效性、清除不需要的信息。当页面被爬虫解析后，将被发送到项目管道，并经过几个特定的次序处理数据。

面试题：
如果最终需要将爬取到的数据值一份存储到磁盘文件，一份存储到数据库中，则应该如何操作scrapy？

答案：
管道文件中的代码为:

管道文件
在settings.py开启管道操作代码为：
settings配置代码

六、Scrapy发起post请求：

- 问题：在之前代码中，我们从来没有手动的对start_urls列表中存储的起始url进行过请求的发送，但是起始url的确是进行了请求的发送，那这是如何实现的呢？

- 解答：其实是因为爬虫文件中的爬虫类继承到了Spider父类中的start_requests（self）这个方法，该方法就可以对start_urls列表中的url发起请求 屏幕快照 2018-11-02 下午4.29.33.png

【注意】该方法默认的实现，是对起始的url发起get请求，如果想发起post请求，则需要子类重写该方法。

-方法： 重写start_requests方法，让其发起post请求： 屏幕快照 2018-11-02 下午4.36.19.png

七、scrapy框架之日志等级和请求传参

Scrapy的日志等级
　　- 在使用scrapy crawl spiderFileName运行程序时，在终端里打印输出的就是scrapy的日志信息。
　　- 日志信息的种类：
　　　　　　　　ERROR ： 一般错误
　　　　　　　　WARNING : 警告
　　　　　　　　INFO : 一般的信息
　　　　　　　　DEBUG ： 调试信息
　　　　　　　　默认的显示级别是DEBUG
　　- 设置日志信息指定输出：
　　　　在settings.py配置文件中，加入LOG_LEVEL = ‘指定日志信息种类’即可。LOG_FILE = 'log.txt'则表示将日志信息写入到指定文件中进行存储。

请求传参
　　- 在某些情况下，我们爬取的数据不在同一个页面中，例如，我们爬取一个电影网站，电影的名称，评分在一级页面，而要爬取的其他电影详情在其二级子页面中。这时我们就需要用到请求传参。
传参代码示例：

// spider.py文件
import scrapy
from moviePro.items import MovieproItem

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

   def parse(self, response):
       div_list = response.xpath('//div[@class="col-xs-1-5 movie-item"]')

       for div in div_list:
           item = MovieproItem()
           item['name'] = div.xpath('.//h1/a/text()').extract_first()
           item['score'] = div.xpath('.//h1/em/text()').extract_first()
           #xpath(string(.))表示提取当前节点下所有子节点中的数据值（.）表示当前节点
           item['kind'] = div.xpath('.//div[@class="otherinfo"]').xpath('string(.)').extract_first()
           item['detail_url'] = div.xpath('./div/a/@href').extract_first()
           #请求二级详情页面，解析二级页面中的相应内容,通过meta参数进行Request的数据传递
           yield scrapy.Request(url=item['detail_url'],callback=self.parse_detail,meta={'item':item})

   def parse_detail(self,response):
       #通过response获取item
       item = response.meta['item']
       item['actor'] = response.xpath('//div[@class="row"]//table/tr[1]/a/text()').extract_first()
       item['time'] = response.xpath('//div[@class="row"]//table/tr[7]/td[2]/text()').extract_first()
       item['long'] = response.xpath('//div[@class="row"]//table/tr[8]/td[2]/text()').extract_first()
       #提交item到管道
       yield item

//items.py文件

import scrapy

class MovieproItem(scrapy.Item):
    # define the fields for your item here like:
    name = scrapy.Field()
    score = scrapy.Field()
    time = scrapy.Field()
    long = scrapy.Field()
    actor = scrapy.Field()
    kind = scrapy.Field()
    detail_url = scrapy.Field()

//pipelines.py文件
import json

class MovieproPipeline(object):
    def __init__(self):
        self.fp = open('data.txt','w')
    def process_item(self, item, spider):
        dic = dict(item)
        print(dic)
        json.dump(dic,self.fp,ensure_ascii=False)
        return item
    def close_spider(self,spider):
        self.fp.close()

八、scrapy框架之CrawlSpider操作

提问：如果想要通过爬虫程序去爬取”糗百“全站数据新闻数据的话，有几种实现方法？
　　方法一：基于Scrapy框架中的Spider的递归爬取进行实现（Request模块递归回调parse方法）。
　　方法二：基于CrawlSpider的自动爬取进行实现（更加简洁和高效）。

CrawlSpider简介
　　CrawlSpider其实是Spider的一个子类，除了继承到Spider的特性和功能外，还派生除了其自己独有的更加强大的特性和功能。其中最显著的功能就是”LinkExtractors链接提取器“。Spider是所有爬虫的基类，其设计原则只是为了爬取start_url列表中网页，而从爬取到的网页中提取出的url进行继续的爬取工作使用CrawlSpider更合适。

CrawSpider的使用
　　1.创建scrapy工程：scrapy startproject projectName
　　2.创建爬虫文件：scrapy genspider -t crawl spiderName www.xxx.com
　　　　--此指令对比以前的指令多了 "-t crawl"，表示创建的爬虫文件是
　　　　基于CrawlSpider这个类的，而不再是Spider这个基类。
　　3.settings.py文件配置：
　　　　USER_AGENT、ROBOTSTXT_OBEY、ITEM_PIPELINES

爬虫文件示例：

from scrapy.linkextractors import LinkExtractor
from scrapy.spiders import CrawlSpider, Rule
from redisScrapyPro.items import RedisscrapyproItem

class RedisdemoSpider(CrawlSpider):
    name = 'redisDemo'
    start_urls = ['https://dig.chouti.com/r/scoff/hot/1']

    # 实例化了一个链接提取器对象：allow：正则表达式
    # 作用：将起始url对应的页面数据中符合allow指定的正则表达式的链接进行提取
    link = LinkExtractor(allow=r'/r/scoff/hot/\d+')
    rules = (
        # Rule规则解析器
        # 作用：可以将连接提取器提取到的链接对应的页面数据进行指定规则的数据进行解析
        # 参数follow作用：将连接提取器继续作用到连接提取器提取出的链接所对应的页面中
        Rule(link, callback='parse_item', follow=True),
    )
    def parse_item(self, response):
        div_list = response.xpath('//*[@id="content-list"]/div')
        for div in div_list:
            text = div.xpath('./*[@class="news-content"]/div/a/text()').extract_first().strip("\n")
            item = RedisscrapyproItem()
            item['text'] = text
            yield item

items.py

import scrapy

class RedisscrapyproItem(scrapy.Item):
    text = scrapy.Field()

pipelines.py

class RedisscrapyproPipeline(object):
    def process_item(self, item, spider):
        print(item['text'])

CrawlSpider类和Spider类的最大不同是CrawlSpider多了一个rules属性，其作用是定义”提取动作“。在rules中可以包含一个或多个Rule对象，在Rule对象中包含了LinkExtractor对象。
参数介绍：
　　LinkExtractor：顾名思义，链接提取器。提取response中符合规则的链接。
　　Rule: 规则解析器。根据链接提取器中提取到的链接，根据指定规则提取解析器链接网页中的内容。 Rule(LinkExtractor(allow=r'Items/'), callback='parse_item', follow=True)
　　　　- 参数介绍：
　　　　　　参数1：指定链接提取器
　　　　　　参数2：指定规则解析器解析数据的规则（回调函数）
　　　　　　参数3：是否将链接提取器继续作用到链接提取器提取出的链接网页中。当callback为None,参数3的默认值为true。
　　rules=( ):指定不同规则解析器。一个Rule对象表示一种提取规则。
　　
CrawlSpider整体爬取流程：
　　a)爬虫文件首先根据起始url，获取该url的网页内容
　　b)链接提取器会根据指定提取规则将步骤a中网页内容中的链接进行提取
　　c)规则解析器会根据指定解析规则将链接提取器中提取到的链接中的网页内容根据指定的规则进行解析
　　d)将解析数据封装到item中，然后提交给管道进行持久化存储

九、Scrapy框架链接数据库操作：

数据持久化：
1.对数据做持久化可以直接将数据写入文件中，可以在pipelines.py中做IO操作，也可以直接使用终端指令存储指定文件格式：
　　　　scrapy crawl qiubai -o qiubai.json
　　　　scrapy crawl qiubai -o qiubai.xml
　　　　scrapy crawl qiubai -o qiubai.csv
2.可以通过mysql、redis、mongodb等数据库来存储数据，注意配置settings文件！

Mysql数据库的使用pipelines.py示例：

import pymysql
class QiubaiproPipeline(object):

    conn = None
    cursor = None
    def open_spider(self,spider):
        print('开始爬虫')
        #1. 链接数据库
        self.conn = pymysql.Connect(host='127.0.0.1',port=3306,user='root',
            password='123456',db='qiubai')
    #编写向数据库中存储数据的相关代码
    def process_item(self, item, spider):
        #2. 执行sql语句
        sql = 'insert into qiubai values("%s","%s")'%(item['author'],item['content'])
        self.cursor = self.conn.cursor()
        # 3.提交事务
        try:
            self.cursor.execute(sql)
            self.conn.commit()
        except Exception as e:
            print(e)
            self.conn.rollback()
        return item
    def close_spider(self,spider):
        print('爬虫结束')
        self.cursor.close()
        self.conn.close()

redis数据库的使用pipelines.py示例：

import redis

class QiubaiproPipeline(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']
        }
        self.conn.lpush('data', dict)
        return item

十、Scrapy框架的中间件：

中间件的作用
中间件可以拦截请求对象，可以将请求对象的UA进行伪装，也可以将请求对象的url进行篡改等。

settings.py文件配置
DOWNLOADER_MIDDLEWARES = {
　　'proxyPro.middlewares.Myproxy': 543,
}

middleware.py文件

from scrapy import signals

class Myproxy(object):
    #该方法被调用后可以拦截请求对象
    #将请求对象的UA进行伪装
    #将请求对象的url进行篡改
    def process_request(self, request, spider):
        #进行请求代理ip设置
        #参数request就是中间件拦截到的请求对象
        request.meta['proxy'] = "https://151.106.15.8:1080"

十一、scrapy框架之分布式操作

基于redis数据库实现分布式操作：

redis的准备工作：
　　1.启动redis：
　　　　mac/linux: redis-server redis.conf
　　　　windows: redis-server.exe redis-windows.conf
　　2.对redis配置文件进行配置：
　　　　- 注释该行：bind 127.0.0.1，表示可以让其他ip访问redis
　　　　- 将yes该为no：protected-mode no，表示可以让其他ip操作redis

实现分布式爬虫的操作步骤：
　　1. 将redis数据库的配置文件进行改动： 1⃣.修改值 protected-mode no 2⃣.注释 bind 127.0.0.1
　　2. 下载scrapy-redis
　　3. 创建工程 scrapy startproject 工程名
　　4. 创建基于scrawlSpider的爬虫文件 scrapy genspider 文件名 起始url
　　5. 导入RedisCrawlSpider类
　　6. 在现有代码的基础上进行连接提取和解析操作
　　7. 将解析的数据值封装到item中，然后将item对象提交到scrapy-redis组件中的管道里
　　8. 管道会将数据值写入到指定的redis数据库中（在配置文件中进行指定redis数据库ip的编写）
　　9. 在当前工程中使用scrapy-redis封装好的调度器（在配置文件中进行配置）
　　10. 将起始url扔到调度器队列（redis_key）中
　　11. 启动redis服务器：redis-server redis.windows.conf
　　12. 启动redis-cli
　　13. 执行当前爬虫文件：scrapy runspider 爬虫文件
　　14. 向队列中扔一个起始url：在redis-cli执行扔的操作（lpush redis_key的value值 起始url）

settings文件设置
UA设置
USER_AGENT = 'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.77 Safari/537.36'

robost设置
ROBOTSTXT_OBEY = False

pipe设置
ITEM_PIPELINES = {
　　　　使用的是scrapy-redis组件中封装好的管道文件
　　　　 'scrapy_redis.pipelines.RedisPipeline': 400,}

在配置文件中指定数据存储的redis数据库
REDIS_HOST = '192.168.12.11'
REDIS_PORT = 6379
REDIS_ENCODING = 'utf-8'
REDIS_PARAMS = {‘password’:’123456’}

进行指定调度器的使用
使用scrapy-redis组件的去重队列
DUPEFILTER_CLASS = "scrapy_redis.dupefilter.RFPDupeFilter"
使用scrapy-redis组件自己的调度器
SCHEDULER = "scrapy_redis.scheduler.Scheduler"
是否允许暂停
SCHEDULER_PERSIST = True

spider.py文件：

from scrapy.linkextractors import LinkExtractor
from scrapy.spiders import CrawlSpider, Rule
from scrapy_redis.spiders import RedisCrawlSpider
from redisScrapyPro.items import RedisscrapyproItem

class RedisdemoSpider(RedisCrawlSpider):
    name = 'redisDemo'

    #scrapy_redis的调度器队列的名称，最终我们会根据该队列的名称向调度器队列中扔一个起始url
    redis_key = "redisQueue"

    link = LinkExtractor(allow=r'/pic/page/\d+\?s=\d+')
    link1 = LinkExtractor(allow=r'/pic/page/1')
    rules = (
        Rule(link, callback='parse_item', follow=True),
        Rule(link1, callback='parse_item', follow=True),
    )

    def parse_item(self, response):
        div_list = response.xpath('//div[@class="thumb"]')
        for div in div_list:
            img_url = "https:"+div.xpath('./a/img/@src').extract_first()
            item = RedisscrapyproItem()
            item['imgUrl'] = img_url

            yield item