Scrapy

Scrapy框架(一)

简介

Scrapy是纯Python开发的一个高效,结构化的网页抓取框架；

Scrapy是一个为了爬取网站数据，提取结构性数据而编写的应用框架。 其最初是为了页面抓取 (更确切来说, 网络抓取 )所设计的，也可以应用在获取API所返回的数据(例如 Amazon Associates Web Services ) 或者通用的网络爬虫。 Scrapy用途广泛,可以用于数据挖掘、监测和自动化测试 Scrapy使用了Twisted 异步网络库来处理网络通讯。

使用原因：

1.为了更利于我们将精力集中在请求与解析上
2.企业级的要求

安装

scrapy支持Python2.7和python3.4以上版本。
python包可以用全局安装(也称为系统范围),也可以安装在用户空间中。

Windows

• 一.直接安装

  1. 在https://www.lfd.uci.edu/~gohlke/pythonlibs/ 下载对应的Twisted的版本文件
  2. 在命令行进入到Twisted的目录 执行pip install +Twisted文件名
  3. 执行pip install scrapy

• 二.annaconda 下安装

  1. 安装conda

     conda旧版本 https://docs.anaconda.com/anaconda/packages/oldpkglists/
     安装方法 https://blog.csdn.net/ychgyyn/article/details/82119201

  2. 安装scrapy conda install scrapy

Ubuntu 14.04或以上 安装

scrapy目前正在使用最新版的lxml，twisted和pyOpenSSL进行测试，并且与最近的Ubuntu发行版兼容。但它也支持旧版本的Ubuntu，比如Ubuntu14.04，尽管可能存在TLS连接问题。

Ubuntu安装注意事项
不要使用 python-scrapyUbuntu提供的软件包，它们通常太旧而且速度慢，无法赶上最新的Scrapy。

要在Ubuntu（或基于Ubuntu）系统上安装scrapy，您需要安装这些依赖项：

sudo apt-get install python-dev python-pip libxml2-dev libxslt1-dev zlib1g-dev libffi-dev libssl-dev

如果你想在python3上安装scrapy，你还需要Python3的开发头文件：

sudo apt-get install python3-dev

在virtualenv中，你可以使用pip安装Scrapy：

pip install scrapy

运行流程

（
spiders网页爬虫
items项目
engine引擎
scheduler调度器
downloader下载器
item pipelines项目管道
middleware中间设备，中间件
）

数据流：

上图显示了Scrapy框架的体系结构及其组件，以及系统内部发生的数据流（由红色的箭头显示。）
Scrapy中的数据流由执行引擎控制,流程如下：

1. 首先从网页爬虫获取初始的请求
2. 将请求放入调度模块，然后获取下一个需要爬取的请求
3. 调度模块返回下一个需要爬取的请求给引擎
4. 引擎将请求发送给下载器，依次穿过所有的下载中间件
5. 一旦页面下载完成，下载器会返回一个响应包含了页面数据，然后再依次穿过所有的下载中间件。
6. 引擎从下载器接收到响应，然后发送给爬虫进行解析，依次穿过所有的爬虫中间件
7. 爬虫处理接收到的响应，然后解析出item和生成新的请求，并发送给引擎
8. 引擎将已经处理好的item发送给管道组件，将生成好的新的请求发送给调度模块，并请求下一个请求
9. 该过程重复，直到调度程序不再有请求为止。

组件介绍

• Scrapy Engine(引擎)
  引擎负责控制系统所有组件之间的数据流，并在发生某些操作时触发事件。

• scheduler（调度器)
  调度程序接收来自引擎的请求，将它们排入队列，以便稍后引擎请求它们。

• Downloader（下载器)
  下载程序负责获取web页面并将它们提供给引擎，引擎再将它们提供给spider。

• spider（爬虫）
  爬虫是由用户编写的自定义的类，用于解析响应，从中提取数据，或其他要抓取的请求。

• Item pipeline（管道)
  管道负责在数据被爬虫提取后进行后续处理。典型的任务包括清理，验证和持久性（如将数据存储在数据库中）

• 下载中间件
  下载中间件是位于引擎和下载器之间的特定的钩子，它们处理从引擎传递到下载器的请求，以及下载器传递到引擎的响应。
  如果你要执行以下操作之一，请使用Downloader中间件：
  在请求发送到下载程序之前处理请求（即在scrapy将请求发送到网站之前）
  在响应发送给爬虫之前
  直接发送新的请求，而不是将收到的响应传递给蜘蛛
  将响应传递给爬行器而不获取web页面;
  默默的放弃一些请求

• 爬虫中间件
  爬虫中间件是位于引擎和爬虫之间的特定的钩子，能够处理传入的响应和传递出去的item和请求。
  如果你需要以下操作请使用爬虫中间件：
  处理爬虫回调之后的 请求或item
  处理start_requests
  处理爬虫异常
  根据响应内容调用errback而不是回调请

简单使用

一.项目命令

1.创建项目:
scrapy startproject <project_name> [project_dir]
ps: "<>“表示必填 ,”[]"表示可选
scrapy startproject db

2.cd 到项目下
scrapy genspider [options]
scrapy genspider example example.com
会创建在项目/spider下 ;其中example 是爬虫文件名, example.com 是 url
3.运行项目
scrapy crawl 爬虫文件名 #注重流程

​ scrapy crawl douban -o douban.csv

4.setting 里配置 ROBOTSTXT_OBEY;DEFAULT_REQUEST_HEADERS

二.shell 交互式平台

scrapy shell url (start_url) 获取我们项目中的response
测试 xpath进行匹配

项目文件介绍

db项目外文件夹

• db–>项目文件夹
  • spiders–>
    • .init..py–>spiders初始化文件夹
  • init.py–>-->项目初始化文件
  • items.py–>定义结构化数据字段数据存储模板,定制要保存的字段
  • middlewares.py–>中间件
  • pipelines.py–>管道文件编写数据持久化代码
  • settings.py–>设置文件例如:控制爬取速度,多大并发量,等
• scrapy.cfg–>项目配置文件

编写爬虫

项目创建一个Db250Spider的类，它必须继承scrapy.Spider类，需要定义一下三个属性：
name: spider的名字，必须且唯一
start_urls: 初始的url列表
parse(self, response) 方法：每个初始url完成之后被调用。这个函数要完成一下两个功能：
解析响应，封装成item对象并返回这个对象
提取新的需要下载的url，创建新的request，并返回它

命令如下

语法格式：scrapy genspider [-t template]
运行命令：scrapy genspider db250 movie.douban.com
会在spiders文件下生成db250.py文件，修改star_urls后
文件内容如左图：

import scrapy


class DuanziSpider(scrapy.Spider):
    name = 'db'  # 爬虫的名字，启动爬虫时需要一致，一般和文件名一致
    allowed_domains = ['movie.douban.com']  # 允许的域名，一般不用注释
    start_urls = ['https://movie.douban.com/top250/']  # 网页的起始名，一般是主页的URL

接下来，我们来完善这个爬虫，代码如下：

parse()会在请求完成时被调用。response是请求返回来的响应，可以通过xpath或者css方法很方便的解析。分析页面结构，提取课程需要的数据，生成一个字典，然后通过json模块，转成字符串，写入项目根目录下的film.txt 文件内。

运行爬虫

爬虫写好了，我们怎么启动爬虫，进行爬取呢？
首先进入项目根目录，然后运行命令：scrapy crawl db250就可以启动爬虫了。

追踪链接

上面的爬虫仅仅只爬取了一页，当然不符合我们的要求，我们需要爬取下一页，下一页，直到所有的信息都被下载。我们从页面中提取连接，或者根据规则构建。现在来看我们的爬虫修改为递归的爬取下一页的链接，从中提取数据。
我们创建了一个类变量page_num用来记录当前爬取到的页码，在parse函数中提取课程信息，然后通过爬虫对象给变量page__num自加1，构造下一页的url，然后创建scrapy.Request对象并返回。如果response中提取不到课程信息，我们判断已经到了最后一页，parse函数直接return结束。

定义item管道

到目前为止，我们通过scrapy写出的爬虫还看不出优越性在哪里，并且上面的爬虫还有个很严重的问题，就是对文件的操作。每次调用parse方法会打开文件关闭文件，这极大的浪费了资源。parse函数在解析出我们需要的信息之后，可以将这些信息打包成一个字典对象或scray.Item对象（一般都是item对象，下面我们再讲），然后返回。这个对象会被发送到item管道，该管道会通过顺序执行几个组件处理它。每个item管道组件是一个实现简单方法的Python类。他们收到一个item并对其执行操作，同时决定该item是否应该继续通过管道或者被丢弃并且不再处理。
item管道的典型用途是：
清理HTML数据
验证已删除的数据（检查项目是否包含某些字段）
检查重复项（并删除它们）
将已爬取的item进行数据持久化
我们先修改爬虫文件见左图：

定义item

抓取的主要目标是从非结构化数据源(通常是web页面)中提取结构化数据。Scrapy spider可以将提取的数据作为Python的dicts返回。虽然方便且熟悉，但Python的dicts缺乏结构:很容易在字段名中犯错误或返回不一致的数据，特别是在有许多爬虫的大型项目中。

若要定义公共输出数据格式，Scrapy提供了Item类。Item对象是用于收集剪贴数据的简单容器。它们提供了一个类似词典的API，提供了一种方便的语法来声明它们的可用字段。 scray.Item对象是用于收集抓取数据的简单容器，使用方法和python的字典类似。编辑项目目录下items.py文件。

然后我们只需要在爬虫中导入我们定义的Item类，实例化后用它进行数据结构化。

import scrapy


class DbItem(scrapy.Item):
    # define the fields for your item here like:
    # name = scrapy.Field()
    film_name = scrapy.Field()
    director_name = scrapy.Field()
    score = scrapy.Field()

爬取豆瓣电影

目标数据要求：

1. 豆瓣电影250个电影信息

2. 电影信息为：电影名字,导演信息(可以包含演员信息),评分

3. 将电影信息直接本地保存

4. 将电影信息通过管道进行保存

爬虫文件

# -*- coding: utf-8 -*-
import json

import scrapy

from ..items  import  DbItem   #是一个安全的字典
class Db250Spider(scrapy.Spider):#继承基础类
    name = 'db250'  #爬虫文件名字  必须存在且唯一
    # allowed_domains = ['movie.douban.com'] #允许的域名   可以不存在 不存在  任何域名都可以
    start_urls = ['https://movie.douban.com/top250']#初始url  必须要存在
    page_num=0
    def parse(self, response):#解析函数  处理响应数据
        node_list=response.xpath('//div[@class="info"]')
        with open("film.txt","w",encoding="utf-8") as f:
            for node  in  node_list:
                #电影名字
                film_name=node.xpath("./div/a/span/text()").extract()[0]
                #导演信息
                director_name=node.xpath("./div/p/text()").extract()[0].strip()
                #评分
                score=node.xpath('./div/div/span[@property="v:average"]/text()').extract()[0]

                #非管道存储
                item={
   }
                item["item_pipe"]=film_name
                item["director_name"]=director_name
                item["score"]=score
                content=json.dumps(item,ensure_ascii=False)
                f.write(content+"\n")

                #使用管道存储
                item_pipe=DbItem() #创建Dbitem对象  当成字典来使用
                item_pipe['film_name']=film_name
                item_pipe['director_name']=director_name
                item_pipe['score']=score
                yield item_pipe
        #发送新一页的请求
        #构造url
        self.page_num += 1
        if self.page_num==3:
            return
        page_url="https://movie.douban.com/top250?start={}&filter=".format(self.page_num*25)
        yield scrapy.Request(page_url)
        
#page页规律
"https://movie.douban.com/top250?start=25&filter="
"https://movie.douban.com/top250?start=50&filter="
"https://movie.douban.com/top250?start=75&filter="

items文件

import scrapy

class DbItem(scrapy.Item):
    # define the fields for your item here like:
    # name = scrapy.Field()
    film_name=scrapy.Field()
    director_name=scrapy.Field()
    score=scrapy.Field()

piplines文件

import json

class DbPipeline(object):

    def  open_spider(self,spider):
        #爬虫文件开启,此方法执行
        self.f=open("film_pipe.txt","w",encoding="utf-8")

    def process_item(self, item, spider):
        json_data=json.dumps(dict(item),ensure_ascii=False)+"\n"
        self.f.write(json_data)
        return item
    def  close_spider(self,spider):
        # 爬虫文件关闭,此方法执行
        self.f.close() #关闭文件

settings文件

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

# Scrapy settings for db project
#
# For simplicity, this file contains only settings considered important or
# commonly used. You can find more settings consulting the documentation:
#
#     https://docs.scrapy.org/en/latest/topics/settings.html
#     https://docs.scrapy.org/en/latest/topics/downloader-middleware.html
#     https://docs.scrapy.org/en/latest/topics/spider-middleware.html

BOT_NAME = 'db'

SPIDER_MODULES = ['db.spiders']
NEWSPIDER_MODULE = 'db.spiders'


# Crawl responsibly by identifying yourself (and your website) on the user-agent
#USER_AGENT = 'db (+http://www.yourdomain.com)'

# Obey robots.txt rules
ROBOTSTXT_OBEY = False

# Configure maximum concurrent requests performed by Scrapy (default: 16)
#CONCURRENT_REQUESTS = 32

# Configure a delay for requests for the same website (default: 0)
# See https://docs.scrapy.org/en/latest/topics/settings.html#download-delay
# See also autothrottle settings and docs
#DOWNLOAD_DELAY = 3
# The download delay setting will honor only one of:
#CONCURRENT_REQUESTS_PER_DOMAIN = 16
#CONCURRENT_REQUESTS_PER_IP = 16

# Disable cookies (enabled by default)
#COOKIES_ENABLED = False

# Disable Telnet Console (enabled by default)
#TELNETCONSOLE_ENABLED = False

# Override the default request headers:
DEFAULT_REQUEST_HEADERS = {
   
  'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
  'Accept-Language': 'en',
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.138 Safari/537.36"
}



# Enable or disable spider middlewares
# See https://docs.scrapy.org/en/latest/topics/spider-middleware.html
#SPIDER_MIDDLEWARES = {
   
#    'db.middlewares.DbSpiderMiddleware': 543,
#}

# Enable or disable downloader middlewares
# See https://docs.scrapy.org/en/latest/topics/downloader-middleware.html
#DOWNLOADER_MIDDLEWARES = {
   
#    'db.middlewares.DbDownloaderMiddleware': 543,
#}

# Enable or disable extensions
# See https://docs.scrapy.org/en/latest/topics/extensions.html
#EXTENSIONS = {
   
#    'scrapy.extensions.telnet.TelnetConsole': None,
#}

# Configure item pipelines
# See https://docs.scrapy.org/en/latest/topics/item-pipeline.html
ITEM_PIPELINES = {
   
   'db.pipelines.DbPipeline': 300,
}

# Enable and configure the AutoThrottle extension (disabled by default)
# See https://docs.scrapy.org/en/latest/topics/autothrottle.html
#AUTOTHROTTLE_ENABLED = True
# The initial download delay
#AUTOTHROTTLE_START_DELAY = 5
# The maximum download delay to be set in case of high latencies
#AUTOTHROTTLE_MAX_DELAY = 60
# The average number of requests Scrapy should be sending in parallel to
# each remote server
#AUTOTHROTTLE_TARGET_CONCURRENCY = 1.0
# Enable showing throttling stats for every response received:
#AUTOTHROTTLE_DEBUG = False

# Enable and configure HTTP caching (disabled by default)
# See https://docs.scrapy.org/en/latest/topics/downloader-middleware.html#httpcache-middleware-settings
#HTTPCACHE_ENABLED = True
#HTTPCACHE_EXPIRATION_SECS = 0
#HTTPCACHE_DIR = 'httpcache'
#HTTPCACHE_IGNORE_HTTP_CODES = []
#HTTPCACHE_STORAGE = 'scrapy.extensions.httpcache.FilesystemCacheStorage'

项目注意事项

1. settings文件中 项目默认的是 ROBOTSTXT_OBEY = True,即遵循robots协议,则不能爬取到数据

则更改为 ROBOTSTXT_OBEY = False

2. settings中,有些网站需要添加User-Agent ,才能获取到数据 (伪装成客户端)
3. settings中,需要将管道打开,才可以将数据传递到pipelines文件中
4. items中需要设置相应的字段,使用Item对象传递数据,(可以理解为mysql先定义字段,才能写入数据一样)

example.py

import scrapy
import json
from ..items import DbItem  # 是一个安全的字典


class ExampleSpider(scrapy.Spider):
    name = 'example'
    allowed_domains = ['movie.douban.com']  # 限制域名站点URL
    start_urls = ['https://movie.douban.com/top250/']  # 爬取URL
    page_num = 0

    def parse(self, response):
        node_list = response.xpath('//div[@class="info"]')
        with open("film.txt", "w", encoding="utf-8") as f:
            for node in node_list:
                # 电影名字
                film_name = node.xpath("./div/a/span/text()").extract()[0]
                # 导演信息
                director_name = node.xpath("./div/p/text()").extract()[0].strip()
                # 评分
                score = node.xpath('./div/div/span[@property="v:average"]/text()').extract()[0]

                # 非管道存储
                item = {}
                item["item_pipe"] = film_name
                item["director_name"] = director_name
                item["score"] = score
                content = json.dumps(item, ensure_ascii=False)
                f.write(content + "\n")

                # 使用管道存储
                item_pipe = DbItem()  # 创建Dbitem对象  当成字典来使用
                item_pipe['film_name'] = film_name
                item_pipe['director_name'] = director_name
                item_pipe['score'] = score
                yield item_pipe
        # 发送新一页的请求
        # 构造url
        self.page_num += 1
        if self.page_num == 3:
            return
        page_url = "https://movie.douban.com/top250?start={}&filter=".format(self.page_num * 25)
        yield scrapy.Request(page_url)

items.py

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

import scrapy


class DbItem(scrapy.Item):
    # define the fields for your item here like:
    # name = scrapy.Field()
    film_name = scrapy.Field()
    director_name = scrapy.Field()
    score = scrapy.Field()

pipelines.py

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


# useful for handling different item types with a single interface
from itemadapter import ItemAdapter
import json


class DbPipeline:
    def open_spider(self, spider):
        # 爬虫文件开启,此方法执行
        self.f = open("film_pipe.txt", "w", encoding="utf-8")

    def process_item(self, item, spider):
        json_data = json.dumps(dict(item), ensure_ascii=False) + "\n"
        self.f.write(json_data)
        return item

    def close_spider(self, spider):
        # 爬虫文件关闭,此方法执行
        self.f.close()  # 关闭文件

settings.py

ROBOTSTXT_OBEY = False
DEFAULT_REQUEST_HEADERS = {
    'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
    'Accept-Language': 'en',
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.138 Safari/537.36"
}
ITEM_PIPELINES = {
    'db.pipelines.DbPipeline': 300,
}

Scrapy框架(二)

次级页面抓取及数据传递拼接（豆瓣电影）

1.详情页抓取（次级页面）的主要方法是get_detail 方法

def  get_detail(self,response):
	pass

2.参数的传递拼接 的关键参数是 meta参数

spider文件

# -*- coding: utf-8 -*-
import json

import scrapy

from ..items  import  DbItem   #是一个安全的字典
class Db250Spider(scrapy.Spider):#继承基础类
    name = 'db250'  #爬虫文件名字  必须存在且唯一
    # allowed_domains = ['movie.douban.com'] #允许的域名   可以不存在 不存在  任何域名都可以
    start_urls = ['https://movie.douban.com/top250']#初始url  必须要存在
    page_num=0
    def parse(self, response):#解析函数  处理响应数据
        node_list=response.xpath('//div[@class="info"]')
        for node  in  node_list:
            #电影名字
            film_name=node.xpath("./div/a/span/text()").extract()[0]
            #导演信息
            director_name=node.xpath("./div/p/text()").extract()[0].strip()
            #评分
            score=node.xpath('./div/div/span[@property="v:average"]/text()').extract()[0]

            #使用管道存储
            item_pipe=DbItem() #创建Dbitem对象  当成字典来使用
            item_pipe['film_name']=film_name
            item_pipe['director_name']=director_name
            item_pipe['score']=score
            # yield item_pipe
            # print("电影信息",dict(item_pipe))
            # 电影简介
            detail_url = node.xpath('./div/a/@href').extract()[0]
            yield scrapy.Request(detail_url,callback=self.get_detail,meta={
   "info":item_pipe})

        #发送新一页的请求
        #构造url
        self.page_num += 1
        if self.page_num==4:
            return
        page_url="https://movie.douban.com/top250?start={}&filter=".format(self.page_num*25)
        yield scrapy.Request(page_url)
    def  get_detail(self,response):
        item=DbItem()
        #解析详情页的response
        #1.meta 会跟随response 一块返回  2.通过response.meta接收 3.通过update  添加到新的item对象中
        info = response.meta["info"]
        item.update(info)
        #简介内容
        description=response.xpath('//div[@id="link-report"]//span[@property="v:summary"]/text()').extract()[0].strip()
        # print('description',description)

        item["description"]=description
        #通过管道保存
        yield  item

#目标数据  电影信息+ 获取电影简介数据  次级页面的网页源代码里
#请求流程   访问一级页面  提取电影信息+次级页面的url    访问次级页面url 从次级的数据中提取电影简介

#存储的问题   数据没有次序  需要使用  meta传参 保证 同一电影的信息在一起

items文件

import scrapy


class DbItem(scrapy.Item):
    # define the fields for your item here like:
    # name = scrapy.Field()
    film_name=scrapy.Field()
    director_name=scrapy.Field()
    score=scrapy.Field()
    description=scrapy.Field()

pipelines 文件

import json
class DbPipeline(object):

    def  open_spider(self,spider):
        #爬虫文件开启,此方法执行
        self.f=open("film_pipe.txt","w",encoding="utf-8")

    def process_item(self, item, spider):
        json_data=json.dumps(dict(item),ensure_ascii=False)+"\n"
        self.f.write(json_data)
        return item
    def  close_spider(self,spider):
        # 爬虫文件关闭,此方法执行
        self.f.close() #关闭文件

settings 文件

此处删除了大部分注释

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

# Scrapy settings for db project

BOT_NAME = 'db'

SPIDER_MODULES = ['db.spiders']
NEWSPIDER_MODULE = 'db.spiders'

# Crawl responsibly by identifying yourself (and your website) on the user-agent
#USER_AGENT = 'db (+http://www.yourdomain.com)'

# Obey robots.txt rules
ROBOTSTXT_OBEY = False

# Override the default request headers:
DEFAULT_REQUEST_HEADERS = {
   
  'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
  'Accept-Language': 'en',
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.138 Safari/537.36"
}

# Configure item pipelines
# See https://docs.scrapy.org/en/latest/topics/item-pipeline.html
ITEM_PIPELINES = {
   
   'db.pipelines.DbPipeline': 300,
}

Scrapy shell

scrapy shell的作用是用于调试，

在项目 目录下输入scrapy shell https://movie.douban.com/top250 得到下列信息：

scrapy shell 会自动加载settings里的配置，即robots协议，请求头等都可以加载，从而发起请求可以得到正确的响应信息。

[s] Available Scrapy objects:
[s]   scrapy     scrapy module (contains scrapy.Request, scrapy.Selector, etc)  #scrapy  模块
[s]   crawler    <scrapy.crawler.Crawler object at 0x000002624C415F98>  #爬虫对象
[s]   item       {
   }                                                    #item对象
[s]   request    <GET https://movie.douban.com/top250>                 # 请求对象
[s]   response   <200 https://movie.douban.com/top250>                  #响应对象
[s]   settings   <scrapy.settings.Settings object at 0x000002624C415EB8>  #配置文件
[s]   spider     <DefaultSpider 'default' at 0x2624c8ed3c8>               #spider文件
[s] Useful shortcuts:
[s]   fetch(url[, redirect=True]) Fetch URL and update local objects (by default, redirects are followed)  #通过url  获取response
[s]   fetch(req)                  Fetch a scrapy.Request and update local objects  #通过请求对象  获取response
[s]   shelp()           Shell help (print this help)    #列出命令
[s]   view(response)    View response in a browser     #response  界面    本地浏览器环境下使用

Scrapy shell 本质上就是个普通的python shell
只不过提供了一些需要使用的对象，快捷方法便于我们调试。

• 快捷方法：
  shelp()
  fetch(url[,redirect=True])
  fetch(request)
  view(response)
• scrapy 对象：
  crawler
  spider
  request
  response
  setting

启动 shell

启动Scrapy shell的命令语法格式如下：
scrapy shell [option] [url|file]
url 就是你想要爬取的网址
注意：分析本地文件是一定要带上路径，scrapy shell默认当作url

Scrapy 选择器

Scrapy选择器是通过scrapy.Selector类，通过传递文本或者TextResonse对象构造的实例。它会根据输入类型自动选择最佳解析规则XML与HTML它的构造方式如下

from scrapy.selector import Selector
from scrapy.http import HtmlResponse

# 从文本构造
boby = '<html><boby><span>good</span></boby></html>'
select = Selector(text=boby)

# 从相应构造
response = HtmlResponse(url='http://www.example.com', body=boby, encoding='utf-8')
select1 = Selector(response=response)

# 为了方便，响应对象在select属性上公开选择器
# 在可能的情况下使用此快捷方式wnquankeyi
response.selector.xpath('//div')
print(isinstance(response.selector, Selector))

• Scrapy提供基于lxml库的解析机制，它们被称为选择器。
  因为，它们“选择”由XPath或CSS表达式指定的HTML文档的某部分。
  Scarpy选择器的API非常小，且非常简单。

• 选择器提供2个方法来提取标签

  xpath() 基于xpath的语法规则
  css() 基于css选择器的语法规则
  快捷方式
  response.xpath()
  response.css()
  它们返回的选择器列表
  提取文本：
  selector.extract() 返回文本列表
  selector.extract_first() 返回第一个selector的文本，没有返回None

• 嵌套选择器

  有时候我们获取标签需要多次调用选择方法（.xpath()或.css()）
  response.css(‘img’).xpath(’@src’)

  Selector还有一个.re()方法使用正则表达式提取数据的方法。
  它返回字符串。
  它一般使用在xpath()，css()方法之后，用来过滤文本数据。
  re_first()用来返回第一个匹配的字符串。

html_str="""
<div class="info">
                    <div class="hd">
                        <a href="https://movie.douban.com/subject/1292052/" class="">
                            <span class="title">肖申克的救赎</span>
                            <span class="title">&nbsp;/&nbsp;The Shawshank Redemption</span>
                            <span class="other">&nbsp;/&nbsp;月黑高飞(港)  /  刺激1995(台)</span>
                        </a>
                            <span class="playable">[可播放]</span>
                    </div>
                    <div class="bd">
                        <p class="">
                            导演: 弗兰克·德拉邦特 Frank Darabont&nbsp;&nbsp;&nbsp;主演: 蒂姆·罗宾斯 Tim Robbins /...<br>
                            1994&nbsp;/&nbsp;美国&nbsp;/&nbsp;犯罪 剧情
                        </p>
                        <div class="star">
                                <span class="rating5-t"></span>
                                <span class="rating_num" property="v:average">9.7</span>
                                <span property="v:best" content="10.0"></span>
                                <span>1980500人评价</span>
                        </div>

                            <p class="quote">
                                <span class="inq">希望让人自由。</span>
                            </p>
                    </div>
                </div>
            </div>
"""
# https://doc.scrapy.ory/en/lastde/static/selectors-sample1.html
from  scrapy.selector  import  Selector
#1.通过text 参数来构造对象
selc_text=Selector(text=html_str)

# print(selc_text.xpath('//div[@class="info"]//div/a/span/text()').extract()[0])
# print(selc_text.xpath('./body/div[@class="info"]//div/a/span/text()').extract()[0])
# print(selc_text.xpath('//div[@class="info"]//div/a/span/text()').extract_first())

#2.通过 response  构造selector对象
from  scrapy.http import   HtmlResponse
response=HtmlResponse(url="http://www.example.com",body=html_str.encode())
Selector(response=response)
# print(response.selector.xpath('//div[@class="info"]//div/a/span/text()').extract()[0])
# print(response.xpath('//div[@class="info"]//div/a/span/text()').extract()[0])

#3.嵌套表达式  selector  可以任意使用 css   xpath  re
# print(response.css("a").xpath('./span[1]/text()').extract()[0])
print(response.css("a").xpath('./span[1]/text()').re("的..")[0])
print(response.css("a").xpath('./span[1]/text()').re_first("的.."))

scrapy.Spider

首先生成初始请求以爬取第一个URL，并指定要使用从这些请求下载的响应调用的回调函数。

在回调函数中，解析响应（网页）并返回，Item对象， Request对象或这些对象的可迭代的dicts。

在回调函数中，通常使用选择器解析页面内容 （但您也可以使用BeautifulSoup，lxml或您喜欢的任何机制）并使用解析的数据生成item。

最后，从蜘蛛返回的项目通常会持久保存到数据库（在某些项目管道中）或使用Feed导出写入文件。

• spider 的名称 name

  一个字符串，用于定义此蜘蛛的名称。蜘蛛名称是Scrapy如何定位（并实例化）蜘蛛，因此它必须是唯一的。这是最重要的蜘蛛属性，它是必需的。

• 起始urls

  蜘蛛将开始爬取的URL列表。因此，下载的第一页将是此处列出的页面。后续Request将从起始URL中包含的数据连续生成。

• 自定义设置

  运行此蜘蛛时将覆盖项目范围的设置。必须将其定义为类属性，因为在实例化之前更新了设置。

class Spider(object_ref):
    """Base class for scrapy spiders. All spiders must inherit from this
    class.
    """

    name = None
    custom_settings = None

    def __init__(self, name=None, **kwargs):
        if name is not None:
            self.name = name
        elif not getattr(self, 'name', None):
            raise ValueError("%s must have a name" % type(self).__name__)
        self.__dict__.update(kwargs)
        if not hasattr(self, 'start_urls'):
            self.start_urls = []

• logger

使用Spider创建的Python日志器。您可以使用它来发送日志消息。

@property
def logger(self):
    logger = logging.getLogger(self.name)
    return logging.LoggerAdapter(logger, {
   'spider': self})

def log(self, message, level=logging.DEBUG, **kw):
    """Log the given message at the given log level

    This helper wraps a log call to the logger within the spider, but you
    can use it directly (e.g. Spider.logger.info('msg')) or use any other
    Python logger too.
    """
    self.logger.log(level, message, **kw)

• from_crawler

  这是Scrapy用于创建spider的类方法。一般不用覆盖。

@classmethod
def from_crawler(cls, crawler, *args, **kwargs):
    spider = cls(*args, **kwargs)
    spider._set_crawler(crawler)
    return spider

def _set_crawler(self, crawler):
    self.crawler = crawler
    self.settings = crawler.settings
    crawler.signals.connect(self.close, signals.spider_closed)

• start_requests() 开始请求

  此方法必须返回一个iterable，其中包含第一个要爬网的请求。它只会被调用一次

def start_requests(self):
    cls = self.__class__
    if not self.start_urls and hasattr(self, 'start_url'):
        raise AttributeError(
            "Crawling could not start: 'start_urls' not found "
            "or empty (but found 'start_url' attribute instead, "
            "did you miss an 's'?)")
    if method_is_overridden(cls, Spider, 'make_requests_from_url'):
        warnings.warn(
            "Spider.make_requests_from_url method is deprecated; it "
            "won't be called in future Scrapy releases. Please "
            "override Spider.start_requests method instead (see %s.%s)." % (
                cls.__module__, cls.__name__
            ),
        )
        for url in self.start_urls:
            yield self.make_requests_from_url(url)
    else:
        for url in self.start_urls:
            yield Request(url, dont_filter=True)

• parse 默认回调函数方法

  这是Scrapy在其请求未指定回调时处理下载的响应时使用的默认回调

def parse(self, response):
    raise NotImplementedError('{}.parse callback is