python 全栈开发，Day137(爬虫系列之第4章-scrapy框架)

一、scrapy框架简介

1. 介绍

Scrapy一个开源和协作的框架，其最初是为了页面抓取 (更确切来说, 网络抓取 )所设计的，使用它可以以快速、简单、可扩展的方式从网站中提取所需的数据。但目前Scrapy的用途十分广泛，可用于如数据挖掘、监测和自动化测试等领域，也可以应用在获取API所返回的数据(例如 Amazon Associates Web Services ) 或者通用的网络爬虫。Scrapy 是基于twisted框架开发而来，twisted是一个流行的事件驱动的python网络框架。因此Scrapy使用了一种非阻塞（又名异步）的代码来实现并发。

它是爬虫界最知名的框架。就好比web框架中的django

Scrapy之所以能实现异步，得益于twisted框架
twisted有事件队列，哪一个事件有活动，就会执行！

整体架构大致如下：

蓝条部分，表示中间件！

可以将SPIDERS，SCHEDULER，DOWNLOADER，ITEM PIPELINE理解为4个人。

它们不直接通讯，都是通过ENGINE来完成通讯的！

'''
Components：

1、引擎(EGINE)
引擎负责控制系统所有组件之间的数据流，并在某些动作发生时触发事件。有关详细信息，请参见上面的数据流部分。

2、调度器(SCHEDULER)
用来接受引擎发过来的请求, 压入队列中, 并在引擎再次请求的时候返回. 可以想像成一个URL的优先级队列, 由它来决定下一个要抓取的网址是什么, 同时去除重复的网址

3、下载器(DOWLOADER)
用于下载网页内容, 并将网页内容返回给EGINE，下载器是建立在twisted这个高效的异步模型上的

4、爬虫(SPIDERS)
SPIDERS是开发人员自定义的类，用来解析responses，并且提取items，或者发送新的请求

5、项目管道(ITEM PIPLINES)
在items被提取后负责处理它们，主要包括清理、验证、持久化（比如存到数据库）等操作
下载器中间件(Downloader Middlewares)位于Scrapy引擎和下载器之间，主要用来处理从EGINE传到DOWLOADER的请求request，已经从DOWNLOADER传到EGINE的响应response，
你可用该中间件做以下几件事：
  　　(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.

6、爬虫中间件(Spider Middlewares)
位于EGINE和SPIDERS之间，主要工作是处理SPIDERS的输入（即responses）和输出（即requests）
'''

官网链接

在调度器中，可以设置将重复的网址去重。如果爬取失败，需要再次爬取，那么就不能去重。

所以要不要去重，取决于项目需求而定。

如果访问5个url，当有一个url卡住了。那么它就会切换到队列中其他的url。因为它是异步请求，这里就可以高效利用CPU

2. scrapy 的工作流程

之前学习的 爬虫的基本流程

那么 scrapy是如何帮助我们抓取数据的呢？

3. 数据流

Scrapy中的数据流由执行引擎控制，其过程如下:

1.引擎打开一个网站(open adomain)，找到处理该网站的Spider并向该spider请求第一个要爬取的URL(s)。

2.引擎从Spider中获取到第一个要爬取的URL并在调度器(Scheduler)以Request调度。

3.引擎向调度器请求下一个要爬取的URL。

4.调度器返回下一个要爬取的URL给引擎，引擎将URL通过下载中间件(请求(request)方向)转发给下载器(Downloader)。

5.一旦页面下载完毕，下载器生成一个该页面的Response，并将其通过下载中间件(返回(response)方向)发送给引擎。

6.引擎从下载器中接收到Response并通过Spider中间件(输入方向)发送给Spider处理。

7.Spider处理Response并返回爬取到的Item及(跟进的)新的Request给引擎。

8.引擎将(Spider返回的)爬取到的Item给ItemPipeline，将(Spider返回的)Request给调度器。

9.(从第二步)重复直到调度器中没有更多地request，引擎关闭该网站。

上面的内容，参考链接：

https://blog.csdn.net/xun527/article/details/78450789

每访问一个url，就会经历上面列举的9个步骤，它是一个反复过程。

如果访问失败，可以再次请求访问！

spiders包含了爬取和解析这2步。

为什么要有中间件？

请求一个网页，有几十个cookie，每一次发送，都得带上cookie，很麻烦。
比如使用代理，需要换IP访问。封锁一个，换一个！
加上代理访问，需要使用中间件！那么无论任何请求，都可以带上cookie。

item就是解析好的数据

2. 安装

Windows平台

windows平台安装比较难搞，它不像linux一样，一条命令就搞定了！很多人学习scrapy，光安装就卡了半天。

为了不让 学习如痴如醉的你放弃scrapy，这里列举出详细的安装过程！

先说明一下安装环境。使用的是windows 10 家庭版，64位操作系统。已经安装好了Python 3.6

搜索cmd，必须使用管理员身份运行

安装 wheel

C:\Windows\system32>pip3 install wheel

安装 lxml

C:\Windows\system32>pip3 install lxml

安装 pyopenssl

C:\Windows\system32>pip3 install pyopenssl

安装 pywin32

打开网址：

https://sourceforge.net/projects/pywin32/files/pywin32/

点击 Build 221

下载pywin32-221.win-amd64-py3.6.exe

直接运行

点击下一步

点击下一步

最后就可以安装完成了！

安装 twisted

打开网页

https://pypi.org/project/Twisted/#files

这里不要下载，为什么呢？看文件名，它只支持Python 2.7。但我的是Python 3.6啊！

打开另外一个网页：

https://github.com/zerodhatech/python-wheels

下载文件 Twisted-17.9.0-cp36-cp36m-win_amd64.whl

点击下载

点击文件属性，复制路径

安装

C:\Windows\system32>pip3 install C:\Users\vr\Downloads\Twisted-17.9.0-cp36-cp36m-win_amd64.whl

安装 scrapy

C:\Windows\system32>pip3 install scrapy

到这里，scrapy就安装完成了！

Linux平台

Linux平台安装比较简单，一条命令就可以搞定了

pip3 install scrapy

3. 命令行工具

1. 查看帮助

scrapy -h
scrapy <command> -h

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压力测试

举例：

创建一个爬虫项目DianShang

C:\Users\xiao>e:
E:\>cd E:\python_script\爬虫\day3
E:\python_script\爬虫\day3>scrapy startproject DianShang

生成一个爬虫程序。注意：左边的jd表示模块名，右边的jd.com表示要访问的url。

一个项目还可以访问多个url

E:\python_script\爬虫\day3>cd DianShang
E:\python_script\爬虫\day3\DianShang>scrapy genspider jd jd.com

注意：项目名和爬虫程序名不能重复！

运行scrapy项目。注意：这里指定的模块名必须和上面一致！

E:\python_script\爬虫\day3\DianShang>scrapy crawl jd

一个项目，也可以启动多个模块

主要用到命令，就是上面演示的3个！

1 scrapy startproject DianShang   # 创建爬虫项目
2 scrapy genspider jd jd.com      # 生成一个爬虫程序
3 scrapy crawl jd                 # 运行scrapy项目

3. 官网链接

https://docs.scrapy.org/en/latest/topics/commands.html

4. 目录结构

project_name/
    scrapy.cfg              #  项目的主配置信息，用来部署scrapy时使用
    project_name/           #  爬虫项目名称
       __init__.py
       items.py            #  数据存储模板，用于结构化数据，如：Django的Model
       pipelines.py        #  数据持久化
       settings.py         #  用户级配置文件
       spiders/            #  爬虫程序的目录
           __init__.py
           爬虫1.py        # 爬虫程序1
           爬虫2.py
           爬虫3.py

文件说明：

• scrapy.cfg  项目的主配置信息，用来部署scrapy时使用，爬虫相关的配置信息在settings.py文件中。
• items.py    设置数据存储模板，用于结构化数据，如：Django的Model
• pipelines    数据处理行为，如：一般结构化的数据持久化
• settings.py 配置文件，如：递归的层数、并发数，延迟下载等。强调:配置文件的选项必须大写否则视为无效，正确写法USER_AGENT='xxxx'
• spiders      爬虫目录，如：创建文件，编写爬虫规则

注意：

1、一般创建爬虫文件时，以网站域名命名

2、默认只能在终端执行命令，为了更便捷操作：

#在项目根目录下新建：entrypoint.py
from scrapy.cmdline import execute
execute(['scrapy', 'crawl', 'xiaohua'])

框架基础：spider类，选择器

举例：

上面已经创建好了DianShang项目，修改settings.py，将下面的配置改为False

ROBOTSTXT_OBEY = False

这是配置是否遵循robots协议，一般情况下，是不遵循的。为啥呢？你要真的遵循的话，还怎么爬呀！

涉及到金融，影响国家安全，影响社会和谐稳定...的信息，切莫爬取，否则后果不堪设想！

每次使用命令行运行 scrapy crawl jd  太麻烦了。

在项目根目录新建一个文件 bin.py。注意，它和scrapy.cfg是同级的！

#在项目根目录下新建：bin.py
from scrapy.cmdline import execute
# 最后一个参数是：爬虫程序名
execute(['scrapy', 'crawl', 'jd'])

直接执行bin.py，就可以启动爬虫程序了！

执行之后，会输出一段红色字符串。注意：它不是报错！

也可以关闭掉，修改 bin.py

#在项目根目录下新建：bin.py
from scrapy.cmdline import execute
# 第三个参数是：爬虫程序名
execute(['scrapy', 'crawl', 'jd','--nolog'])

再次执行，就不会输出了！

二、Spider类

Spiders是定义如何抓取某个站点（或一组站点）的类，包括如何执行爬行（即跟随链接）以及如何从其页面中提取结构化数据（即抓取项目）。换句话说，Spiders是您为特定站点（或者在某些情况下，一组站点）爬网和解析页面定义自定义行为的地方。

1、 生成初始的Requests来爬取第一个URLS，并且标识一个回调函数
     第一个请求定义在start_requests()方法内默认从start_urls列表中获得url地址来生成Request请求，
     默认的回调函数是parse方法。回调函数在下载完成返回response时自动触发

2、 在回调函数中，解析response并且返回值
     返回值可以4种：
          包含解析数据的字典
          Item对象
          新的Request对象（新的Requests也需要指定一个回调函数）
          或者是可迭代对象（包含Items或Request）

3、在回调函数中解析页面内容
   通常使用Scrapy自带的Selectors，但很明显你也可以使用Beutifulsoup，lxml或其他你爱用啥用啥。

4、最后，针对返回的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）

举例：

打开DianShang项目，修改DianShang-->spiders-->jd.py

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

class JdSpider(scrapy.Spider):
    name = 'jd'
    allowed_domains = ['jd.com']
    start_urls = ['http://jd.com/']

    def parse(self, response):
        print(response,type(response))

执行bin.py，输出如下：

<200 https://www.jd.com/> <class 'scrapy.http.response.html.HtmlResponse'>

start_requests

使用Ctrl+鼠标左键，点击这一段代码中的Spider，查看源代码

class JdSpider(scrapy.Spider):

查看start_requests方法，看最后2行代码。

def start_requests(self):
    cls = self.__class__
    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)

它执行了for循环，self.start_urls就是在JdSpider类中定义的start_urls变量，它是一个列表！

如果列表为空，不会执行yield

最后使用生成器返回了一个Request对象

再查看Request源码

class Request(object_ref):

    def __init__(self, url, callback=None, method='GET', headers=None, body=None,
                 cookies=None, meta=None, encoding='utf-8', priority=0,
                 dont_filter=False, errback=None, flags=None):

        self._encoding = encoding  # this one has to be set first
        self.method = str(method).upper()
        self._set_url(url)
        self._set_body(body)
        assert isinstance(priority, int), "Request priority not an integer: %r" % priority
        self.priority = priority

        if callback is not None and not callable(callback):
            raise TypeError('callback must be a callable, got %s' % type(callback).__name__)
        if errback is not None and not callable(errback):
            raise TypeError('errback must be a callable, got %s' % type(errback).__name__)
        assert callback or not errback, "Cannot use errback without a callback"
        self.callback = callback
        self.errback = errback

        self.cookies = cookies or {}
        self.headers = Headers(headers or {}, encoding=encoding)
        self.dont_filter = dont_filter

        self._meta = dict(meta) if meta else None
        self.flags = [] if flags is None else list(flags)

参数解释：

• url（string） - 此请求的网址
• callback（callable） - 将使用此请求的响应（一旦下载）作为其第一个参数调用的函数。有关更多信息，请参阅下面的将附加数据传递给回调函数。如果请求没有指定回调，parse()将使用spider的 方法。请注意，如果在处理期间引发异常，则会调用errback。
• method（string） - 此请求的HTTP方法。默认为'GET'。
• meta（dict） - 属性的初始值Request.meta。如果给定，在此参数中传递的dict将被浅复制。
• body（str或unicode） - 请求体。如果unicode传递了a，那么它被编码为 str使用传递的编码（默认为utf-8）。如果 body没有给出，则存储一个空字符串。不管这个参数的类型，存储的最终值将是一个str（不会是unicode或None）。
• headers（dict） - 这个请求的头。dict值可以是字符串（对于单值标头）或列表（对于多值标头）。如果 None作为值传递，则不会发送HTTP头。

• cookie（dict或list） - 请求cookie。

• encoding（string） - 此请求的编码（默认为'utf-8'）。此编码将用于对URL进行百分比编码，并将正文转换为str（如果给定unicode）。
• priority（int） - 此请求的优先级（默认为0）。调度器使用优先级来定义用于处理请求的顺序。具有较高优先级值的请求将较早执行。允许负值以指示相对低优先级。
• dont_filter（boolean） - 表示此请求不应由调度程序过滤。当您想要多次执行相同的请求时忽略重复过滤器时使用。小心使用它，或者你会进入爬行循环。默认为False。

• errback（callable） - 如果在处理请求时引发任何异常，将调用的函数。这包括失败的404 HTTP错误等页面。它接收一个Twisted Failure实例作为第一个参数。有关更多信息，请参阅使用errbacks在请求处理中捕获异常。

• flags（list） - 是一个包含属性初始值的 Request.flags列表。如果给定，列表将被浅复制。

关于参数的更多信息，请参考链接：

https://blog.csdn.net/weixin_37947156/article/details/74974208

一般情况下，要自己定义start_requests方法。为什么呢？因为它不一定能够访问目标网站。

比如访问 https://github.com/  要获取我的个人信息。直接用GET请求，不带任何信息，是获取不到的。必须登录才行！

举例：

进入DianShang项目，修改 DianShang-->spiders-->jd.py，增加start_requests方法

# -*- coding: utf-8 -*-
import scrapy
from scrapy import Request  # 导入模块

class JdSpider(scrapy.Spider):
    name = 'jd'
    allowed_domains = ['jd.com']
    # start_urls = ['http://jd.com/']  # 占时没有用了

    def start_requests(self):
        r1 = Request(url="http://jd.com/")
        yield r1  # 务必使用yield 返回

    def parse(self, response):
        print(response,type(response))

重新执行bin.py，Pycharm输出如下：

<200 https://www.jd.com/> <class 'scrapy.http.response.html.HtmlResponse'>

注意：推荐使用yield返回，这样可以节省内存。它最后还是会调用for循环！

start_requests方法，虽然没有写callback参数，指定回调函数。它默认的回调函数就是parse

start_requests执行之后，并没有发送请求。它只是一个返回一个Request对象，放到一个请求列表中。由twisted进行异步请求！如果得到了响应信息，则调用parse函数！

上面的parse函数，还没有写return。所以它不会走架构图中的7,8步骤

三、选择器

为了解释如何使用选择器，我们将使用Scrapy shell（提供交互式测试）和Scrapy文档服务器中的示例页面，

这是它的HTML代码：

<html>
 <head>
  <base href='http://example.com/' />
  <title>Example website</title>
 </head>
 <body>
  <div id='images'>
   <a href='image1.html'>Name: My image 1 <br /><img src='image1_thumb.jpg' /></a>
   <a href='image2.html'>Name: My image 2 <br /><img src='image2_thumb.jpg' /></a>
   <a href='image3.html'>Name: My image 3 <br /><img src='image3_thumb.jpg' /></a>
   <a href='image4.html'>Name: My image 4 <br /><img src='image4_thumb.jpg' /></a>
   <a href='image5.html'>Name: My image 5 <br /><img src='image5_thumb.jpg' /></a>
  </div>
 </body>
</html>

首先，让我们打开shell：

scrapy shell https://doc.scrapy.org/en/latest/_static/selectors-sample1.html

然后，在shell加载之后，您将获得响应作为response shell变量，并在response.selector属性中附加选择器。

让我们构建一个XPath来选择title标签内的文本：

>>> response.selector.xpath('//title/text()')
[<Selector xpath='//title/text()' data='Example website'>]

使用XPath和CSS查询响应非常常见，响应包括两个便捷快捷方式：response.xpath()和response.css()：

>>> response.xpath('//title/text()')
[<Selector xpath='//title/text()' data='Example website'>]
>>> response.css('title::text')
[<Selector xpath='descendant-or-self::title/text()' data='Example website'>]

正如你所看到的，.xpath()并且.css()方法返回一个 SelectorList实例，这是新的选择列表。此API可用于快速选择嵌套数据：

>>> response.css('img').xpath('@src').extract()
['image1_thumb.jpg', 'image2_thumb.jpg', 'image3_thumb.jpg', 'image4_thumb.jpg', 'image5_thumb.jpg']

要实际提取文本数据，必须调用selector .extract() 方法，如下所示：

>>> response.xpath('//title/text()').extract()
['Example website']

如果只想提取第一个匹配的元素，可以调用选择器 .extract_first()

>>> response.xpath('//div[@id="images"]/a/text()').extract_first()
'Name: My image 1 '

现在我们将获得基本URL和一些图像链接：

>>> response.xpath('//base/@href').extract()
['http://example.com/']
>>>
>>> response.css('base::attr(href)').extract()
['http://example.com/']
>>>
>>> response.xpath('//a[contains(@href, "image")]/@href').extract()
['image1.html', 'image2.html', 'image3.html', 'image4.html', 'image5.html']
>>>
>>> response.css('a[href*=image]::attr(href)').extract()
['image1.html', 'image2.html', 'image3.html', 'image4.html', 'image5.html']
>>>
>>> response.xpath('//a[contains(@href, "image")]/img/@src').extract()
['image1_thumb.jpg', 'image2_thumb.jpg', 'image3_thumb.jpg', 'image4_thumb.jpg', 'image5_thumb.jpg']
>>>
>>> response.css('a[href*=image] img::attr(src)').extract()
['image1_thumb.jpg', 'image2_thumb.jpg', 'image3_thumb.jpg', 'image4_thumb.jpg', 'image5_thumb.jpg']
>>>

四、DupeFilter(去重)

默认使用方式：

DUPEFILTER_CLASS = 'scrapy.dupefilter.RFPDupeFilter'
Request(...,dont_filter=False) ，如果dont_filter=True则告诉Scrapy这个URL不参与去重。

源码解析：

from scrapy.core.scheduler import Scheduler
见Scheduler下的enqueue_request方法：self.df.request_seen(request)　　

自定义去重规则：

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

五、Item(项目)

抓取的主要目标是从非结构化源（通常是网页）中提取结构化数据。Scrapy蜘蛛可以像Python一样返回提取的数据。虽然方便和熟悉，但P很容易在字段名称中输入拼写错误或返回不一致的数据，尤其是在具有许多蜘蛛的较大项目中。

为了定义通用输出数据格式，Scrapy提供了Item类。 Item对象是用于收集抓取数据的简单容器。它们提供类似字典的 API，并具有用于声明其可用字段的方便语法。

1. 声明项目

使用简单的类定义语法和Field 对象声明项。这是一个例子：

import scrapy

class Product(scrapy.Item):
name = scrapy.Field()
price = scrapy.Field()
stock = scrapy.Field()
last_updated = scrapy.Field(serializer=str)

注意那些熟悉Django的人会注意到Scrapy Items被宣告类似于Django Models，除了Scrapy Items更简单，因为没有不同字段类型的概念。

2. 项目字段

Field对象用于指定每个字段的元数据。例如，last_updated上面示例中说明的字段的序列化函数。

您可以为每个字段指定任何类型的元数据。Field对象接受的值没有限制。出于同样的原因，没有所有可用元数据键的参考列表。

Field对象中定义的每个键可以由不同的组件使用，只有那些组件知道它。您也可以根据Field自己的需要定义和使用项目中的任何其他键。

Field对象的主要目标是提供一种在一个地方定义所有字段元数据的方法。通常，行为取决于每个字段的那些组件使用某些字段键来配置该行为。

3. 使用项目

以下是使用上面声明的Product项目对项目执行的常见任务的一些示例 。您会注意到API与dict API非常相似。

创建项目
>>> product = Product(name='Desktop PC', price=1000)
>>> print product
Product(name='Desktop PC', price=1000)
获取字段值
>>> product['name']
Desktop PC
>>> product.get('name')
Desktop PC

>>> product['price']
1000

>>> product['last_updated']
Traceback (most recent call last):
...
KeyError: 'last_updated'

>>> product.get('last_updated', 'not set')
not set

>>> product['lala'] # getting unknown field
Traceback (most recent call last):
...
KeyError: 'lala'

>>> product.get('lala', 'unknown field')
'unknown field'

>>> 'name' in product # is name field populated?
True

>>> 'last_updated' in product # is last_updated populated?
False

>>> 'last_updated' in product.fields # is last_updated a declared field?
True

>>> 'lala' in product.fields # is lala a declared field?
False
设定字段值
>>> product['last_updated'] = 'today'
>>> product['last_updated']
today

>>> product['lala'] = 'test' # setting unknown field
Traceback (most recent call last):
...
KeyError: 'Product does not support field: lala'
访问所有填充值
要访问所有填充值，只需使用典型的dict API：

>>> product.keys()
['price', 'name']

>>> product.items()
[('price', 1000), ('name', 'Desktop PC')]
其他常见任务
复制项目：

>>> product2 = Product(product)
>>> print product2
Product(name='Desktop PC', price=1000)

>>> product3 = product2.copy()
>>> print product3
Product(name='Desktop PC', price=1000)
从项目创建dicts：

>>> dict(product) # create a dict from all populated values
{'price': 1000, 'name': 'Desktop PC'}
从dicts创建项目：

>>> Product({'name': 'Laptop PC', 'price': 1500})
Product(price=1500, name='Laptop PC')

>>> Product({'name': 'Laptop PC', 'lala': 1500}) # warning: unknown field in dict
Traceback (most recent call last):
...
KeyError: 'Product does not support field: lala'

4. 扩展项目

您可以通过声明原始Item的子类来扩展Items（以添加更多字段或更改某些字段的某些元数据）。

例如：

class DiscountedProduct(Product):
      discount_percent = scrapy.Field(serializer=str)
      discount_expiration_date = scrapy.Field()

六、Item PipeLine

在一个项目被蜘蛛抓取之后，它被发送到项目管道，该项目管道通过顺序执行的几个组件处理它。

每个项目管道组件（有时简称为“项目管道”）是一个实现简单方法的Python类。他们收到一个项目并对其执行操作，同时决定该项目是否应该继续通过管道或被丢弃并且不再处理。

项目管道的典型用途是：

• cleansing HTML data
• validating scraped data (checking that the items contain certain fields)
• checking for duplicates (and dropping them)
• storing the scraped item in a database

1. 编写自己的项目管道

每个项管道组件都是一个必须实现以下方法的Python类：

process_item（self，项目，蜘蛛）
为每个项目管道组件调用此方法。process_item() 

必须要么：返回带数据的dict，返回一个Item （或任何后代类）对象，返回Twisted Deferred或引发 DropItem异常。丢弃的项目不再由其他管道组件处理。

此外，他们还可以实现以下方法：

open_spider（self，蜘蛛）
打开蜘蛛时会调用此方法。

close_spider（self，蜘蛛）
当蜘蛛关闭时调用此方法。

from_crawler（cls，crawler ）
如果存在，则调用此类方法以从a创建管道实例Crawler。它必须返回管道的新实例。Crawler对象提供对所有Scrapy核心组件的访问，
如设置和信号; 它是管道访问它们并将其功能挂钩到Scrapy的一种方式。

2. 项目管道示例

(1) 价格验证和丢弃物品没有价格

让我们看看下面的假设管道，它调整 price那些不包含增值税（price_excludes_vat属性）的项目的属性，并删除那些不包含价格的项目：

from scrapy.exceptions import DropItem

class PricePipeline(object):

    vat_factor = 1.15

    def process_item(self, item, spider):
        if item['price']:
            if item['price_excludes_vat']:
                item['price'] = item['price'] * self.vat_factor
            return item
        else:
            raise DropItem("Missing price in %s" % item)

(2) 将项目写入JSON文件

以下管道将所有已删除的项目（来自所有蜘蛛）存储到一个items.jl文件中，每行包含一个以JSON格式序列化的项目：

import json

class JsonWriterPipeline(object):

    def open_spider(self, spider):
        self.file = open('items.jl', 'w')

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

    def process_item(self, item, spider):
        line = json.dumps(dict(item)) + "\n"
        self.file.write(line)
        return item

注意JsonWriterPipeline的目的只是介绍如何编写项目管道。如果您确实要将所有已删除的项目存储到JSON文件中，则应使用Feed导出。

(3) 将项目写入数据库

在这个例子中，我们将使用pymongo将项目写入MongoDB。MongoDB地址和数据库名称在Scrapy设置中指定; MongoDB集合以item类命名。

这个例子的要点是展示如何使用from_crawler() 方法以及如何正确地清理资源：

import pymongo

class MongoPipeline(object):

    collection_name = 'scrapy_items'

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

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

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

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

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

(4) 重复过滤

一个过滤器，用于查找重复项目，并删除已处理的项目。假设我们的项目具有唯一ID，但我们的蜘蛛会返回具有相同ID的多个项目：

from scrapy.exceptions import DropItem

class DuplicatesPipeline(object):

    def __init__(self):
        self.ids_seen = set()

    def process_item(self, item, spider):
        if item['id'] in self.ids_seen:
            raise DropItem("Duplicate item found: %s" % item)
        else:
            self.ids_seen.add(item['id'])
            return item

3. 激活项目管道组件

要激活Item Pipeline组件，必须将其类添加到 ITEM_PIPELINES设置中，如下例所示：

ITEM_PIPELINES = {
    'myproject.pipelines.PricePipeline': 300,
    'myproject.pipelines.JsonWriterPipeline': 800,
}

您在此设置中为类分配的整数值决定了它们运行的​​顺序：项目从较低值到较高值类进行。习惯上在0-1000范围内定义这些数字。

pymongo操作，请参考链接：

https://www.cnblogs.com/yuanchenqi/articles/9602847.html

本文参考链接：

https://www.cnblogs.com/yuanchenqi/articles/9509793.html

七、爬取亚马逊

新建一个爬虫程序

scrapy genspider amazon amazon.cn

修改 DianShang-->spiders-->amazon.py，打印响应信息

# -*- coding: utf-8 -*-
import scrapy
from scrapy import Request  # 导入模块

class AmazonSpider(scrapy.Spider):
    name = 'amazon'
    allowed_domains = ['amazon.cn']
    # start_urls = ['http://amazon.cn/']

    def start_requests(self):
        r1 = Request(url="http://amazon.cn/")
        yield r1

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

修改bin.py

#在项目根目录下新建：bin.py
from scrapy.cmdline import execute
# 第三个参数是：爬虫程序名
execute(['scrapy', 'crawl', 'amazon'])

执行bin.py，发现有一个503错误

2018-10-01 14:47:19 [scrapy.core.engine] DEBUG: Crawled (503) <GET https://www.amazon.cn/> (referer: None)

说明，被亚马逊给拦截了！怎么办呢？加1个请求头

修改 DianShang-->spiders-->amazon.py

# -*- coding: utf-8 -*-
import scrapy
from scrapy import Request  # 导入模块

class AmazonSpider(scrapy.Spider):
    name = 'amazon'
    allowed_domains = ['amazon.cn']
    # start_urls = ['http://amazon.cn/']
    # 自定义配置，注意：变量名必须是custom_settings
    custom_settings = {
        'REQUEST_HEADERS': {
            'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.75 Safari/537.36',
        }
    }

    def start_requests(self):
        r1 = Request(url="http://amazon.cn/",headers=self.settings.get('REQUEST_HEADERS'),)
        yield r1

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

再次运行bin.py，发现拿到了网页html

<!doctype html><html class="a-no-js" data-19ax5a9jf="dingo">
...
</html> 

先来搜索ipone x，跳转页面如下：

在地址栏中的url太长了，它真正的地址应该是

https://www.amazon.cn/s/ref=nb_sb_ss_i_3_6?field-keywords=iphone+x

修改 DianShang-->spiders-->amazon.py，更改url

# -*- coding: utf-8 -*-
import scrapy
from scrapy import Request  # 导入模块

class AmazonSpider(scrapy.Spider):
    name = 'amazon'
    allowed_domains = ['amazon.cn']
    # start_urls = ['http://amazon.cn/']
    # 自定义配置，注意：变量名必须是custom_settings
    custom_settings = {
        'REQUEST_HEADERS': {
            'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.75 Safari/537.36',
        }
    }

    def start_requests(self):
        r1 = Request(url="https://www.amazon.cn/s/ref=nb_sb_ss_i_3_6?field-keywords=iphone+x",headers=self.settings.get('REQUEST_HEADERS'),)
        yield r1

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

修改bin.py，关闭日志

#在项目根目录下新建：bin.py
from scrapy.cmdline import execute
# 第三个参数是：爬虫程序名
execute(['scrapy', 'crawl', 'amazon',"--nolog"])

再次运行bin.py，输出一段html

先来看搜索到ipone x的页面。我们需要爬取 ipone x的名称，价格，配送方式。

但是这个页面并没有配送方式，点击一个具体的商品。

删掉url后面多余参数，地址如下：

https://www.amazon.cn/dp/B075LGPY95

效果如下：

可以发现，这个页面，我们所需要的3个信息全有。那么直接访问这地址获取就可以了！

获取商品详情链接

第一步，应该先获取所有商品的详情链接。

看搜索到ipone x的页面，比如第一个商品，它有很多可以点击的地方。比如图片，标题，价格等等。都可以链接到商品详情页！

这里我只选择 标题部分，来获取商品的详情链接！

先copy Xpath规则

修改 DianShang-->spiders-->amazon.py，使用xpath规则解析

# -*- coding: utf-8 -*-
import scrapy
from scrapy import Request  # 导入模块

class AmazonSpider(scrapy.Spider):
    name = 'amazon'
    allowed_domains = ['amazon.cn']
    # start_urls = ['http://amazon.cn/']
    # 自定义配置，注意：变量名必须是custom_settings
    custom_settings = {
        'REQUEST_HEADERS': {
            'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.75 Safari/537.36',
        }
    }

    def start_requests(self):
        r1 = Request(url="https://www.amazon.cn/s/ref=nb_sb_ss_i_3_6?field-keywords=iphone+x",headers=self.settings.get('REQUEST_HEADERS'),)
        yield r1

    def parse(self, response):
        # 商品详细链接
        detail_urls = response.xpath('//*[@id="result_0"]/div/div[3]/div[1]/a/h2').extract()
        print(detail_urls)

执行bin.py，输出如下：

['<h2 data-attribute="Apple 苹果 手机 iPhone X 银色 64G" data-max-rows="0" class="a-size-base s-inline  s-access-title  a-text-normal">Apple 苹果 手机 iPhone X 银色 64G</h2>']

商品名都拿到了，获取href属性使用@href就可以了

修改 DianShang-->spiders-->amazon.py

# -*- coding: utf-8 -*-
import scrapy
from scrapy import Request  # 导入模块

class AmazonSpider(scrapy.Spider):
    name = 'amazon'
    allowed_domains = ['amazon.cn']
    # start_urls = ['http://amazon.cn/']
    # 自定义配置，注意：变量名必须是custom_settings
    custom_settings = {
        'REQUEST_HEADERS': {
            'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.75 Safari/537.36',
        }
    }

    def start_requests(self):
        r1 = Request(url="https://www.amazon.cn/s/ref=nb_sb_ss_i_3_6?field-keywords=iphone+x",headers=self.settings.get('REQUEST_HEADERS'),)
        yield r1

    def parse(self, response):
        # 商品详细链接
        detail_urls = response.xpath('//*[@id="result_0"]/div/div[3]/div[1]/a/@href').extract()
        print(detail_urls)

执行bin.py，输出如下：

['https://www.amazon.cn/dp/B075LGPY95']

这只是获取一个商品，获取整页的商品呢？

先来找规律，每一个商品都是一个li标签。并且还有一个id属性为result_数字。

可以发现，id属性的前缀都是result_ 。那么使用xpath的模拟匹配就可以了！

修改 DianShang-->spiders-->amazon.py，使用模糊匹配

# -*- coding: utf-8 -*-
import scrapy
from scrapy import Request  # 导入模块

class AmazonSpider(scrapy.Spider):
    name = 'amazon'
    allowed_domains = ['amazon.cn']
    # start_urls = ['http://amazon.cn/']
    # 自定义配置，注意：变量名必须是custom_settings
    custom_settings = {
        'REQUEST_HEADERS': {
            'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.75 Safari/537.36',
        }
    }

    def start_requests(self):
        r1 = Request(url="https://www.amazon.cn/s/ref=nb_sb_ss_i_3_6?field-keywords=iphone+x",headers=self.settings.get('REQUEST_HEADERS'),)
        yield r1

    def parse(self, response):
        # 商品详细链接
        detail_urls = response.xpath('//li[contains(@id,"result_")]/div/div[3]/div[1]/a/@href').extract()
        print(detail_urls)

再次执行bin.py，输出了一堆链接，效果如下：

['https://www.amazon.cn/dp/B075LGPY95', 'https://www.amazon.cn/dp/B0763KX27G', ...]

随便点击一个，就是商品详情链接。那么如何让scrapy去访问这些链接呢？

注意：只要parse函数返回一个Request对象，那么就会放到异步请求列表里面，由twisted发送异步请求！

修改 DianShang-->spiders-->amazon.py，yield Request对象

# -*- coding: utf-8 -*-
import scrapy
from scrapy import Request  # 导入模块

class AmazonSpider(scrapy.Spider):
    name = 'amazon'
    allowed_domains = ['amazon.cn']
    # start_urls = ['http://amazon.cn/']
    # 自定义配置，注意：变量名必须是custom_settings
    custom_settings = {
        'REQUEST_HEADERS': {
            'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.75 Safari/537.36',
        }
    }

    def start_requests(self):
        r1 = Request(url="https://www.amazon.cn/s/ref=nb_sb_ss_i_3_6?field-keywords=iphone+x",
                     headers=self.settings.get('REQUEST_HEADERS'),)
        yield r1

    def parse(self, response):
        # 商品详细链接
        detail_urls = response.xpath('//li[contains(@id,"result_")]/div/div[3]/div[1]/a/@href').extract()
        # print(detail_urls)
        for url in detail_urls:
            yield Request(url=url,
                          headers=self.settings.get('REQUEST_HEADERS'),  # 请求头
                          callback=self.parse_detail,  # 回调函数
                          dont_filter=True  # 不去重
                          )

    def parse_detail(self, response):  # 获取商品详细信息
        print(response.text)

执行bin.py，输出一堆字符串。那些都是商品详情页的信息！

获取商品名

先来获取商品的名字

修改 DianShang-->spiders-->amazon.py，修改parse_detail，增加XPath规则

# -*- coding: utf-8 -*-
import scrapy
from scrapy import Request  # 导入模块

class AmazonSpider(scrapy.Spider):
    name = 'amazon'
    allowed_domains = ['amazon.cn']
    # start_urls = ['http://amazon.cn/']
    # 自定义配置，注意：变量名必须是custom_settings
    custom_settings = {
        'REQUEST_HEADERS': {
            'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.75 Safari/537.36',
        }
    }

    def start_requests(self):
        r1 = Request(url="https://www.amazon.cn/s/ref=nb_sb_ss_i_3_6?field-keywords=iphone+x",
                     headers=self.settings.get('REQUEST_HEADERS'),)
        yield r1

    def parse(self, response):
        # 商品详细链接
        detail_urls = response.xpath('//li[contains(@id,"result_")]/div/div[3]/div[1]/a/@href').extract()
        # print(detail_urls)
        for url in detail_urls:
            yield Request(url=url,
                          headers=self.settings.get('REQUEST_HEADERS'),  # 请求头
                          callback=self.parse_detail,  # 回调函数
                          dont_filter=True  # 不去重
                          )

    def parse_detail(self, response):  # 获取商品详细信息
        # 商品名
        name = response.xpath('//*[@id="productTitle"]/text()').extract()
        print(name)

执行输出：

\n                        Apple 苹果 手机 iPhone X 深空灰色 64G\n

发现它有很多换行符，怎么去除呢？使用strip

# -*- coding: utf-8 -*-
import scrapy
from scrapy import Request  # 导入模块

class AmazonSpider(scrapy.Spider):
    name = 'amazon'
    allowed_domains = ['amazon.cn']
    # start_urls = ['http://amazon.cn/']
    # 自定义配置，注意：变量名必须是custom_settings
    custom_settings = {
        'REQUEST_HEADERS': {
            'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.75 Safari/537.36',
        }
    }

    def start_requests(self):
        r1 = Request(url="https://www.amazon.cn/s/ref=nb_sb_ss_i_3_6?field-keywords=iphone+x",
                     headers=self.settings.get('REQUEST_HEADERS'),)
        yield r1

    def parse(self, response):
        # 商品详细链接
        detail_urls = response.xpath('//li[contains(@id,"result_")]/div/div[3]/div[1]/a/@href').extract()
        # print(detail_urls)
        for url in detail_urls:
            yield Request(url=url,
                          headers=self.settings.get('REQUEST_HEADERS'),  # 请求头
                          callback=self.parse_detail,  # 回调函数
                          dont_filter=True  # 不去重
                          )

    def parse_detail(self, response):  # 获取商品详细信息
        # 商品名
        name = response.xpath('//*[@id="productTitle"]/text()').extract()
        if name:
            name = name.strip()

        print(name)

执行bin.py，发现输出为空！

修改bin.py，去除关闭日志

#在项目根目录下新建：bin.py
from scrapy.cmdline import execute
# 第三个参数是：爬虫程序名
execute(['scrapy', 'crawl', 'amazon'])

再次执行，发现有一个错误

AttributeError: 'list' object has no attribute 'strip'

哦，原来name是一个list对象。那么使用extract就不合适了，修改为extract_first。匹配第一个结果！

修改 DianShang-->spiders-->amazon.py，修改parse_detail，使用extract_first

# -*- coding: utf-8 -*-
import scrapy
from scrapy import Request  # 导入模块

class AmazonSpider(scrapy.Spider):
    name = 'amazon'
    allowed_domains = ['amazon.cn']
    # start_urls = ['http://amazon.cn/']
    # 自定义配置，注意：变量名必须是custom_settings
    custom_settings = {
        'REQUEST_HEADERS': {
            'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.75 Safari/537.36',
        }
    }

    def start_requests(self):
        r1 = Request(url="https://www.amazon.cn/s/ref=nb_sb_ss_i_3_6?field-keywords=iphone+x",
                     headers=self.settings.get('REQUEST_HEADERS'),)
        yield r1

    def parse(self, response):
        # 商品详细链接
        detail_urls = response.xpath('//li[contains(@id,"result_")]/div/div[3]/div[1]/a/@href').extract()
        # print(detail_urls)
        for url in detail_urls:
            yield Request(url=url,
                          headers=self.settings.get('REQUEST_HEADERS'),  # 请求头
                          callback=self.parse_detail,  # 回调函数
                          dont_filter=True  # 不去重
                          )

    def parse_detail(self, response):  # 获取商品详细信息
        # 商品名,获取第一个结果
        name = response.xpath('//*[@id="productTitle"]/text()').extract_first()
        if name:
            name = name.strip()

        print(name)

再次执行，输出：

...
Apple 苹果 手机 iPhone X 深空灰色 64G
...

这下就正常了！

获取商品价格

商品价格，和商品名称，也是同样的道理。使用谷歌浏览器直接复制XPath规则，就可以了！

修改 DianShang-->spiders-->amazon.py，修改parse_detail

# -*- coding: utf-8 -*-
import scrapy
from scrapy import Request  # 导入模块

class AmazonSpider(scrapy.Spider):
    name = 'amazon'
    allowed_domains = ['amazon.cn']
    # start_urls = ['http://amazon.cn/']
    # 自定义配置，注意：变量名必须是custom_settings
    custom_settings = {
        'REQUEST_HEADERS': {
            'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.75 Safari/537.36',
        }
    }

    def start_requests(self):
        r1 = Request(url="https://www.amazon.cn/s/ref=nb_sb_ss_i_3_6?field-keywords=iphone+x",
                     headers=self.settings.get('REQUEST_HEADERS'),)
        yield r1

    def parse(self, response):
        # 商品详细链接
        detail_urls = response.xpath('//li[contains(@id,"result_")]/div/div[3]/div[1]/a/@href').extract()
        # print(detail_urls)
        for url in detail_urls:
            yield Request(url=url,
                          headers=self.settings.get('REQUEST_HEADERS'),  # 请求头
                          callback=self.parse_detail,  # 回调函数
                          dont_filter=True  # 不去重
                          )

    def parse_detail(self, response):  # 获取商品详细信息
        # 商品名,获取第一个结果
        name = response.xpath('//*[@id="productTitle"]/text()').extract_first()
        if name:
            name = name.strip()

        # 商品价格
        price = response.xpath('//*[@id="priceblock_ourprice"]/text()').extract_first()

        print(name,price)

执行bin.py，输出如下：

...
Apple 苹果 手机 iPhone X 深空灰色 64G ￥7,288.00
...

获取商品配送方式

使用谷歌浏览器直接复制XPath规则

修改 DianShang-->spiders-->amazon.py，修改parse_detail

# -*- coding: utf-8 -*-
import scrapy
from scrapy import Request  # 导入模块

class AmazonSpider(scrapy.Spider):
    name = 'amazon'
    allowed_domains = ['amazon.cn']
    # start_urls = ['http://amazon.cn/']
    # 自定义配置，注意：变量名必须是custom_settings
    custom_settings = {
        'REQUEST_HEADERS': {
            'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.75 Safari/537.36',
        }
    }

    def start_requests(self):
        r1 = Request(url="https://www.amazon.cn/s/ref=nb_sb_ss_i_3_6?field-keywords=iphone+x",
                     headers=self.settings.get('REQUEST_HEADERS'),)
        yield r1

    def parse(self, response):
        # 商品详细链接
        detail_urls = response.xpath('//li[contains(@id,"result_")]/div/div[3]/div[1]/a/@href').extract()
        # print(detail_urls)
        for url in detail_urls:
            yield Request(url=url,
                          headers=self.settings.get('REQUEST_HEADERS'),  # 请求头
                          callback=self.parse_detail,  # 回调函数
                          dont_filter=True  # 不去重
                          )

    def parse_detail(self, response):  # 获取商品详细信息
        # 商品名,获取第一个结果
        name = response.xpath('//*[@id="productTitle"]/text()').extract_first()
        if name:
            name = name.strip()

        # 商品价格
        price = response.xpath('//*[@id="priceblock_ourprice"]/text()').extract_first()
        # 配送方式
        delivery = response.xpath('//*[@id="ddmMerchantMessage"]/a/text()').extract_first()
        print(name,price,delivery)

执行bin.py，输出如下：

...
Apple iPhone X 全网通 移动联通电信4G 热销中 (深空灰, 64G) ￥7,288.00 新思维官方旗舰店
X-Doria 461238 Apple iPhone X，14.73 厘米（5.8 英寸）灰色 ￥173.70 了解更多。
...

发现了一个问题，如果是手机壳，比如这个链接：

https://www.amazon.cn/dp/B0787HGXQX

使用Xpath获取时，输出： 了解更多

为什么呢？因为我们获取的是a标签的值！

所以获取时，就是了解更多了！看上面，有一个亚马逊中国，这个才是我们想要的！

在span标签id=ddmMerchantMessage，这标签中，它里面包含了2个标签，分别是b标签和a标签。

那么我们取b标签的text()值，就可以了！

修改 DianShang-->spiders-->amazon.py，修改parse_detail

# -*- coding: utf-8 -*-
import scrapy
from scrapy import Request  # 导入模块

class AmazonSpider(scrapy.Spider):
    name = 'amazon'
    allowed_domains = ['amazon.cn']
    # start_urls = ['http://amazon.cn/']
    # 自定义配置，注意：变量名必须是custom_settings
    custom_settings = {
        'REQUEST_HEADERS': {
            'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.75 Safari/537.36',
        }
    }

    def start_requests(self):
        r1 = Request(url="https://www.amazon.cn/s/ref=nb_sb_ss_i_3_6?field-keywords=iphone+x",
                     headers=self.settings.get('REQUEST_HEADERS'),)
        yield r1

    def parse(self, response):
        # 商品详细链接
        detail_urls = response.xpath('//li[contains(@id,"result_")]/div/div[3]/div[1]/a/@href').extract()
        # print(detail_urls)
        for url in detail_urls:
            yield Request(url=url,
                          headers=self.settings.get('REQUEST_HEADERS'),  # 请求头
                          callback=self.parse_detail,  # 回调函数
                          dont_filter=True  # 不去重
                          )

    def parse_detail(self, response):  # 获取商品详细信息
        # 商品名,获取第一个结果
        name = response.xpath('//*[@id="productTitle"]/text()').extract_first()
        if name:
            name = name.strip()

        # 商品价格
        price = response.xpath('//*[@id="priceblock_ourprice"]/text()').extract_first()
        # 配送方式,*[1]表示取第一个标签,也就是b标签
        delivery = response.xpath('//*[@id="ddmMerchantMessage"]/*[1]/text()').extract_first()
        print(name,price,delivery)

执行bin.py，输出如下：

...
hayder iphone X 保护套透明 TPU 超薄电镀防护防撞手机壳适用于苹果 iPhone X 10 ￥149.09 亚马逊美国
Apple iPhone X 移动联通电信4G手机 (256GB, 银色) ￥8,448.00 新思维官方旗舰店
...

发现手机壳的配送方式，也是正确的！

保存到MongoDB

Item

要想将数据保存到MongoDB中，需要使用item

修改 DianShang-->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 AmazonItem(scrapy.Item):

    name = scrapy.Field()  # 商品名
    price= scrapy.Field()  # 价格
    delivery=scrapy.Field()  # 配送方式

修改 DianShang-->spiders-->amazon.py，使用item

# -*- coding: utf-8 -*-
import scrapy
from scrapy import Request  # 导入模块
from DianShang.items import AmazonItem  # 导入item

class AmazonSpider(scrapy.Spider):
    name = 'amazon'
    allowed_domains = ['amazon.cn']
    # start_urls = ['http://amazon.cn/']
    # 自定义配置，注意：变量名必须是custom_settings
    custom_settings = {
        'REQUEST_HEADERS': {
            'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.75 Safari/537.36',
        }
    }

    def start_requests(self):
        r1 = Request(url="https://www.amazon.cn/s/ref=nb_sb_ss_i_3_6?field-keywords=iphone+x",
                     headers=self.settings.get('REQUEST_HEADERS'),)
        yield r1

    def parse(self, response):
        # 商品详细链接
        detail_urls = response.xpath('//li[contains(@id,"result_")]/div/div[3]/div[1]/a/@href').extract()
        # print(detail_urls)
        for url in detail_urls:
            yield Request(url=url,
                          headers=self.settings.get('REQUEST_HEADERS'),  # 请求头
                          callback=self.parse_detail,  # 回调函数
                          dont_filter=True  # 不去重
                          )

    def parse_detail(self, response):  # 获取商品详细信息
        # 商品名,获取第一个结果
        name = response.xpath('//*[@id="productTitle"]/text()').extract_first()
        if name:
            name = name.strip()

        # 商品价格
        price = response.xpath('//*[@id="priceblock_ourprice"]/text()').extract_first()
        # 配送方式,*[1]表示取第一个标签,也就是b标签
        delivery = response.xpath('//*[@id="ddmMerchantMessage"]/*[1]/text()').extract_first()
        print(name,price,delivery)

        # 生成标准化数据
        item = AmazonItem()  # 执行函数,默认是一个空字典
        # 增加键值对
        item["name"] = name
        item["price"] = price
        item["delivery"] = delivery

        return item  # 必须要返回

Item PipeLine

上面的item只是返回了一个字典，并没有真正存储到MongoDB中。需要PipeLine将数据储存到MongoDB中

修改 DianShang-->pipelines.py。注意：from_crawler，open_spider，close_spider，process_item这4个方法，必须要定义才行！

# -*- 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

from pymongo import MongoClient

class MongodbPipeline(object):

    def __init__(self, host, port, db, table):
        self.host = host
        self.port = port
        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')
        DB = crawler.settings.get('DB')
        TABLE = crawler.settings.get('TABLE')
        return cls(HOST, PORT, DB, TABLE)

    def open_spider(self, spider):
        """
        爬虫刚启动时执行一次
        """
        # self.client = MongoClient('mongodb://%s:%s@%s:%s' %(self.user,self.pwd,self.host,self.port))
        self.client = MongoClient(host=self.host, port=self.port)

    def close_spider(self, spider):
        """
        爬虫关闭时执行一次
        """
        self.client.close()

    def process_item(self, item, spider):
        # 操作并进行持久化
        d = dict(item)
        if all(d.values()):
            self.client[self.db][self.table].insert(d)
            print("添加成功一条")

open_spider，close_spider这2个方法，只会执行一次。

process_item呢？就不一定了。有多少次请求，就执行多少次！每次会插入一条记录

修改 DianShang\settings.py，增加MongoDB连接信息。

最后一行增加以下信息：

# MongoDB连接信息
HOST="127.0.0.1"
PORT=27017
DB="amazon"  # 数据库名
TABLE="goods"  # 表名

再修改 DianShang\settings.py，开启MongoDB的PipeLine

这里的300，表示优先级

ITEM_PIPELINES = {
    'DianShang.pipelines.MongodbPipeline': 300,
}

注意：由于在pipelines.py中，定义的是MongodbPipeline。所以配置文件这里，必须要一一匹配，否则报错：

raise NameError("Module '%s' doesn't define any object named '%s'" % (module, name))

先启动MongoDB，打开cmd窗口，输入命令

C:\Users\xiao>mongod

如果输出：

[thread1] waiting for connections on port 27017

则表示启动成功了！

Pipeline是不会帮你自动创建数据库的，所以需要手动创建。

进入数据库，创建数据库amazon

C:\Users\xiao>mongo

> use amazon
switched to db amazon
>

重新运行 bin.py，输出：

...
Apple 苹果 手机 iPhone X 深空灰色 64G ￥7,288.00 新思维官方旗舰店
添加成功一条
...

使用 MongoDB客户端打开表goods，效果如下：