scrapy学习笔记5：框架介绍

框架图：

• Scrapy Engine(引擎): 负责Spider、ItemPipeline、Downloader、Scheduler中间的通讯，信号、数据传递等。

• Scheduler(调度器): 它负责接受引擎发送过来的Request请求，并按照一定的方式进行整理排列，入队，当引擎需要时，交还给引擎。

• Downloader（下载器）：负责下载Scrapy Engine(引擎)发送的所有Requests请求，并将其获取到的Responses交还给Scrapy Engine(引擎)，由引擎交给Spider来处理，

• Spider（爬虫）：它负责处理所有Responses,从中分析提取数据，获取Item字段需要的数据，并将需要跟进的URL提交给引擎，再次进入Scheduler(调度器)，

• Item Pipeline(管道)：它负责处理Spider中获取到的Item，并进行进行后期处理（详细分析、过滤、存储等）的地方.

• Downloader Middlewares（下载中间件）：你可以当作是一个可以自定义扩展下载功能的组件。

• Spider Middlewares（Spider中间件）：你可以理解为是一个可以自定扩展和操作引擎和Spider中间通信的功能组件（比如进入Spider的Responses;和从Spider出去的Requests）

Scrapy的运作流程

代码写好，程序开始运行...

1. 引擎：Hi！Spider, 你要处理哪一个网站？

2. Spider：老大要我处理xxxx.com。

3. 引擎：你把第一个需要处理的URL给我吧。

4. Spider：给你，第一个URL是xxxxxxx.com。

5. 引擎：Hi！调度器，我这有request请求你帮我排序入队一下。

6. 调度器：好的，正在处理你等一下。

7. 引擎：Hi！调度器，把你处理好的request请求给我。

8. 调度器：给你，这是我处理好的request

9. 引擎：Hi！下载器，你按照老大的下载中间件的设置帮我下载一下这个request请求

10. 下载器：好的！给你，这是下载好的东西。（如果失败：sorry，这个request下载失败了。然后引擎告诉调度器，这个request下载失败了，你记录一下，我们待会儿再下载）

11. 引擎：Hi！Spider，这是下载好的东西，并且已经按照老大的下载中间件处理过了，你自己处理一下（注意！这儿responses默认是交给def parse()这个函数处理的）

12. Spider：（处理完毕数据之后对于需要跟进的URL），Hi！引擎，我这里有两个结果，这个是我需要跟进的URL，还有这个是我获取到的Item数据。

13. 引擎：Hi ！管道 我这儿有个item你帮我处理一下！调度器！这是需要跟进URL你帮我处理下。然后从第四步开始循环，直到获取完老大需要全部信息。

14. 管道``调度器：好的，现在就做！

注意！只有当调度器中不存在任何request了，整个程序才会停止，（也就是说，对于下载失败的URL，Scrapy也会重新下载。）

制作 Scrapy 爬虫 一共需要4步：

• 新建项目 (scrapy startproject xxx)：新建一个新的爬虫项目
• 明确目标 （编写items.py）：明确你想要抓取的目标
• 制作爬虫 （spiders/xxspider.py）：制作爬虫开始爬取网页
• 存储内容 （pipelines.py）：设计管道存储爬取内容

下面来简单介绍一下各个主要文件的作用：

scrapy.cfg ：项目的配置文件

mySpider/ ：项目的Python模块，将会从这里引用代码

mySpider/items.py ：项目的目标文件

mySpider/pipelines.py ：项目的管道文件

mySpider/settings.py ：项目的设置文件

mySpider/spiders/ ：存储爬虫代码目录

详细编程步骤

1.先到items里面定义好模型(比如我下面就定义了3个类型分别存放3种不同的数据），注意后面都是统一写=scrapy.Field。

import scrapy

class MyspiderItem(scrapy.Item):
    # define the fields for your item here like:
    # name = scrapy.Field()
    name=scrapy.Field()
    level=scrapy.Field()
    info=scrapy.Field()
    pass

2.定义好模型后我们可以在我们爬虫文件夹下的spiders里面新建一个叫itcast的爬虫，并指定爬的网址（当然我们直接在我们的爬虫目录下输入下面的命令也可以自己创建文件：scrapy genspider itcast "itcast.cn"前面是文件名，后面是要爬的网址）我们可以看到生成了下面的代码

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


class ItcastSpider(scrapy.Spider):
    name = 'itcast'
    allowed_domains = ['itcast.cn']
    start_urls = ['http://itcast.cn/']

    def parse(self, response):
        pass

要建立一个Spider， 你必须用scrapy.Spider类创建一个子类，并确定了三个强制的属性 和 一个方法。

• name = "" ：这个爬虫的识别名称，必须是唯一的，在不同的爬虫必须定义不同的名字。

• allow_domains = [] 是搜索的域名范围，也就是爬虫的约束区域，规定爬虫只爬取这个域名下的网页，不存在的URL会被忽略。

• start_urls = () ：爬取的URL元祖/列表。爬虫从这里开始抓取数据，所以，第一次下载的数据将会从这些urls开始。其他子URL将会从这些起始URL中继承性生成。

• parse(self, response) ：解析的方法，每个初始URL完成下载后将被调用，调用的时候传入从每一个URL传回的Response对象来作为唯一参数，主要作用如下：

  1. 负责解析返回的网页数据(response.body)，提取结构化数据(生成item)
  2. 生成需要下一页的URL请求。

将start_urls的值修改为需要爬取的第一个url：start_urls = ("http://www.itcast.cn/channel/teacher.shtml",)

然后我们修改一下parse代码：

    def parse(self, response):
        filename = "teacher.html"
        try:
            f = open(filename, 'w', encoding='utf-8')
            f.write(str(response.text))
        except:
            print("发生未知错误！")
        pass

然后我们运行一下爬虫：scrapy crawl itcast最后面那个是自己定义的爬虫的名字，就是class里面的那个名字。

然后我们我可以看到我们获取的网页源码保存到我们的爬虫目录下了

爬到了数据，那么我们可以对数据进行处理了，我们可以观察网页源码，然后可以发现它的目录结构：

好的，我们直接上xpath来提取数据（注意：我们需要把我们之前定义的模型引入进来：from myspider.items import MyspiderItem这里不同的文件有不同的写法，前面一个是自己项目的名字，后面那个是自己定义模型的类名）总的代码如下：

 # -*- coding: utf-8 -*-
import scrapy
from myspider.items import MyspiderItem
class ItcastSpider(scrapy.Spider):
    name = 'itcast'
    allowed_domains = ['itcast.cn']
    start_urls = ['http://www.itcast.cn/channel/teacher.shtml']

    def parse(self, response):
        items=[]#存放老师信息的集合
        print("---------------")
        for each in response.xpath("//div[@class='li_txt']"):
            # 将我们得到的数据封装到一个 `ItcastItem` 对象
            item = MyspiderItem()
            # extract()方法返回的都是unicode字符串
            name = each.xpath("h3/text()").extract()
            title = each.xpath("h4/text()").extract()
            info = each.xpath("p/text()").extract()

            # xpath返回的是包含一个元素的列表
            item['name'] = name[0]
            print(name[0])
            item['level'] = title[0]
            item['info'] = info[0]

            items.append(item)
         # 直接返回最后数据
        return items
        pass

保存数据

scrapy保存信息的最简单的方法主要有四种，-o 输出指定格式的文件，，命令如下：

# json格式，默认为Unicode编码
scrapy crawl itcast -o teachers.json

# json lines格式，默认为Unicode编码
scrapy crawl itcast -o teachers.jsonl

# csv 逗号表达式，可用Excel打开
scrapy crawl itcast -o teachers.csv

# xml格式
scrapy crawl itcast -o teachers.xml

我们运行完后就可以发现会多出一个excel文件，我们打开可以发现数据全部爬进来了。

当然，我们还可以修改一下代码：我们可以去掉return items，直接yield item就可以了。

Scrapy Shell

Scrapy终端是一个交互终端，我们可以在未启动spider的情况下尝试及调试代码，也可以用来测试XPath或CSS表达式，查看他们的工作方式，方便我们爬取的网页中提取的数据。

如果安装了 IPython ，Scrapy终端将使用 IPython (替代标准Python终端)。 IPython 终端与其他相比更为强大，提供智能的自动补全，高亮输出，及其他特性。（推荐安装IPython）

使用方法:进入项目的根目录，执行下列命令来启动shell:scrapy shell "http://www.itcast.cn/channel/teacher.shtml"

Scrapy Shell根据下载的页面会自动创建一些方便使用的对象，例如 Response 对象，以及 Selector 对象 (对HTML及XML内容)。

• 当shell载入后，将得到一个包含response数据的本地 response 变量，输入 response.body将输出response的包体，输出 response.headers 可以看到response的包头。

• 输入 response.selector 时， 将获取到一个response 初始化的类 Selector 的对象，此时可以通过使用 response.selector.xpath()或response.selector.css() 来对 response 进行查询。

• Scrapy也提供了一些快捷方式, 例如 response.xpath()或response.css()同样可以生效（如之前的案例）。

Selectors选择器

Scrapy Selectors 内置 XPath 和 CSS Selector 表达式机制

Selector有四个基本的方法，最常用的还是xpath:

• xpath(): 传入xpath表达式，返回该表达式所对应的所有节点的selector list列表
• extract(): 序列化该节点为Unicode字符串并返回list
• css(): 传入CSS表达式，返回该表达式所对应的所有节点的selector list列表，语法同 BeautifulSoup4
• re(): 根据传入的正则表达式对数据进行提取，返回Unicode字符串list列表

至于用法，可以查看我之前的那个项目介绍（传送门），也可以看一下官方文档：http://scrapy-chs.readthedocs.io/zh_CN/latest/topics/shell.html

Item Pipeline

当Item在Spider中被收集之后，它将会被传递到Item Pipeline，这些Item Pipeline组件按定义的顺序处理Item。

每个Item Pipeline都是实现了简单方法的Python类，比如决定此Item是丢弃而存储。以下是item pipeline的一些典型应用：

• 验证爬取的数据(检查item包含某些字段，比如说name字段)
• 查重(并丢弃)
• 将爬取结果保存到文件或者数据库中

那么我们开始编写item pipeline吧（我们需要在pipelines.py文件里面修改）：

这里有pipeline的几个函数，其中process_items函数必须要写，其他的可以不写

import something
class SomethingPipeline(object):
    def __init__(self):    
        # 可选实现，做参数初始化等
        # doing something

    def process_item(self, item, spider):
        # item (Item 对象) – 被爬取的item
        # spider (Spider 对象) – 爬取该item的spider
        # 这个方法必须实现，每个item pipeline组件都需要调用该方法，
        # 这个方法必须返回一个 Item 对象，被丢弃的item将不会被之后的pipeline组件所处理。
        return item

    def open_spider(self, spider):
        # spider (Spider 对象) – 被开启的spider
        # 可选实现，当spider被开启时，这个方法被调用。

    def close_spider(self, spider):
        # spider (Spider 对象) – 被关闭的spider
        # 可选实现，当spider被关闭时，这个方法被调用

那么我们可以把我们刚才爬的老师数据保存为json文件吧（以下pipeline将所有(从所有'spider'中)爬取到的item，存储到一个独立地items.json 文件，每行包含一个序列化为'JSON'格式的'item':）：

# -*- 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  json
class MyspiderPipeline(object):
    def __init__(self):
        self.file=open('teacher.json','w',encoding='utf-8')
    def process_item(self, item, spider):
        content=json.dumps(dict(item),ensure_ascii=False)+",
"
        # print(content)
        self.file.write(content)
        return item

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

注意，这里写好了管道文件后我们还需要到设置里面打开下面的注释

打开后我们运行爬虫，数据就被我们保存到json文件了，实际效果：

Spider

Spider类定义了如何爬取某个(或某些)网站。包括了爬取的动作(例如:是否跟进链接)以及如何从网页的内容中提取结构化数据(爬取item)。 换句话说，Spider就是您定义爬取的动作及分析某个网页(或者是有些网页)的地方。

class scrapy.Spider是最基本的类，所有编写的爬虫必须继承这个类。

主要用到的函数及调用顺序为：

__init__() : 初始化爬虫名字和start_urls列表

start_requests() 调用make_requests_from url():生成Requests对象交给Scrapy下载并返回response

parse() : 解析response，并返回Item或Requests（需指定回调函数）。Item传给Item pipline持久化 ， 而Requests交由Scrapy下载，并由指定的回调函数处理（默认parse())，一直进行循环，直到处理完所有的数据为止。

主要属性和方法

• name

  定义spider名字的字符串。

  例如，如果spider爬取 mywebsite.com ，该spider通常会被命名为 mywebsite

• allowed_domains

  包含了spider允许爬取的域名(domain)的列表，可选。

• start_urls

  初始URL元祖/列表。当没有制定特定的URL时，spider将从该列表中开始进行爬取。

• start_requests(self)

  该方法必须返回一个可迭代对象(iterable)。该对象包含了spider用于爬取（默认实现是使用 start_urls 的url）的第一个Request。

  当spider启动爬取并且未指定start_urls时，该方法被调用。

• parse(self, response)

  当请求url返回网页没有指定回调函数时，默认的Request对象回调函数。用来处理网页返回的response，以及生成Item或者Request对象。

• log(self, message[, level, component])

  使用 scrapy.log.msg() 方法记录(log)message。 更多数据请参见 logging

1. 因为使用的yield，而不是return。parse函数将会被当做一个生成器使用。scrapy会逐一获取parse方法中生成的结果，并判断该结果是一个什么样的类型；
2. 如果是request则加入爬取队列，如果是item类型则使用pipeline处理，其他类型则返回错误信息。
3. scrapy取到第一部分的request不会立马就去发送这个request，只是把这个request放到队列里，然后接着从生成器里获取；
4. 取尽第一部分的request，然后再获取第二部分的item，取到item了，就会放到对应的pipeline里处理；
5. parse()方法作为回调函数(callback)赋值给了Request，指定parse()方法来处理这些请求 scrapy.Request(url, callback=self.parse)
6. Request对象经过调度，执行生成 scrapy.http.response()的响应对象，并送回给parse()方法，直到调度器中没有Request（递归的思路） 
7. 取尽之后，parse()工作结束，引擎再根据队列和pipelines中的内容去执行相应的操作；
8. 程序在取得各个页面的items前，会先处理完之前所有的request队列里的请求，然后再提取items。
9. 这一切的一切，Scrapy引擎和调度器将负责到底。

我们这里来实现一下内涵段子自动翻页爬取的效果：

我们可以直接在原来的项目的基础上新建一个叫neihan的爬虫：scrapy genspider neihan "https://www.neihan-8.com"然后我们添加模型（自己到items里面新建一个类），我这里就不写了。

然后我们可以在我们新建的爬虫文件里面写好代码：

# -*- coding: utf-8 -*-
import scrapy
from myspider.items import Nihan


class NeihanSpider(scrapy.Spider):
    name = 'neihan'
    allowed_domains = ['www.neihan-8.com']
    start_urls = ['https://www.neihan-8.com/article/index.html',]

    def parse(self, response):
        for each in response.xpath("//div[@class='text-column-item box box-790']"):
            item = Nihan()
            item['title']=each.xpath("h3//text()").extract()[0]
            item['content'] = each.xpath("div//text()").extract()[0]
            yield item#把获取到的数据交给管道
        url ="https://www.neihan-8.com"+response.xpath("//a[@class='next']//@href").extract()[0]
        print(url)
        # 把我们获得的新连接加到待爬队列，然后调用parse函数，就是继续爬的意思
        yield scrapy.Request(url, callback=self.parse)

写好后，我们就可以到管道处理那里处理保存我们爬取的信息，主要需要到设置里面启动我们的管道文件（这里我们需要新建一个文件）

然后我们到管道文件那里新建一个类：

 

class Neihanpipeline(object):
    def __init__(self):
        self.file=open('内涵段子.txt','w',encoding='utf-8')
    def process_item(self, item, spider):
        content=item['title']+'
'+item['content']
        # print(content)
        self.file.write(content)
        return item
    def close_spider(self,spider):
        self.file.close()

运行爬虫文件，我们可以看到，现在爬虫在不断工作了：

CrawlSpiders

通过下面的命令可以快速创建 CrawlSpider模板 的代码：

scrapy genspider -t crawl tencent tencent.com

上一个案例中，我们通过正则表达式，制作了新的url作为Request请求参数，现在我们可以换个花样...

class scrapy.spiders.CrawlSpider

它是Spider的派生类，Spider类的设计原则是只爬取start_url列表中的网页，而CrawlSpider类定义了一些规则(rule)来提供跟进link的方便的机制，从爬取的网页中获取link并继续爬取的工作更适合。

CrawlSpider继承于Spider类，除了继承过来的属性外（name、allow_domains），还提供了新的属性和方法

LinkExtractors

class scrapy.linkextractors.LinkExtractor

Link Extractors 的目的很简单: 提取链接｡

每个LinkExtractor有唯一的公共方法是 extract_links()，它接收一个 Response 对象，并返回一个 scrapy.link.Link 对象。

Link Extractors要实例化一次，并且 extract_links 方法会根据不同的 response 调用多次提取链接｡

class scrapy.linkextractors.LinkExtractor(
    allow = (),
    deny = (),
    allow_domains = (),
    deny_domains = (),
    deny_extensions = None,
    restrict_xpaths = (),
    tags = ('a','area'),
    attrs = ('href'),
    canonicalize = True,
    unique = True,
    process_value = None
)

主要参数：

• allow：满足括号中“正则表达式”的值会被提取，如果为空，则全部匹配。

• deny：与这个正则表达式(或正则表达式列表)不匹配的URL一定不提取。

• allow_domains：会被提取的链接的domains。

• deny_domains：一定不会被提取链接的domains。

• restrict_xpaths：使用xpath表达式，和allow共同作用过滤链接。

rules

在rules中包含一个或多个Rule对象，每个Rule对爬取网站的动作定义了特定操作。如果多个rule匹配了相同的链接，则根据规则在本集合中被定义的顺序，第一个会被使用。

class scrapy.spiders.Rule(
        link_extractor, 
        callback = None, 
        cb_kwargs = None, 
        follow = None, 
        process_links = None, 
        process_request = None
)

• link_extractor：是一个Link Extractor对象，用于定义需要提取的链接。

• callback： 从link_extractor中每获取到链接时，参数所指定的值作为回调函数，该回调函数接受一个response作为其第一个参数。

  注意：当编写爬虫规则时，避免使用parse作为回调函数。由于CrawlSpider使用parse方法来实现其逻辑，如果覆盖了 parse方法，crawl spider将会运行失败。

• follow：是一个布尔(boolean)值，指定了根据该规则从response提取的链接是否需要跟进。 如果callback为None，follow 默认设置为True ，否则默认为False。

• process_links：指定该spider中哪个的函数将会被调用，从link_extractor中获取到链接列表时将会调用该函数。该方法主要用来过滤。

• process_request：指定该spider中哪个的函数将会被调用， 该规则提取到每个request时都会调用该函数。 (用来过滤request)

爬取规则(Crawling rules)

腾讯招聘为例，给出配合rule使用CrawlSpider的例子:

1.先运行调试模式：scrapy shell "http://hr.tencent.com/position.php?&start=0#a"

2.导入LinkExtractor，创建LinkExtractor实例对象。：from scrapy.linkextractors import LinkExtractor然后在输入：page_lx = LinkExtractor(allow=('position.php?&start=d+'))

allow : LinkExtractor对象最重要的参数之一，这是一个正则表达式，必须要匹配这个正则表达式(或正则表达式列表)的URL才会被提取，如果没有给出(或为空), 它会匹配所有的链接｡

deny : 用法同allow，只不过与这个正则表达式匹配的URL不会被提取)｡它的优先级高于 allow 的参数，如果没有给出(或None), 将不排除任何链接｡

3.调用LinkExtractor实例的extract_links()方法查询匹配结果：page_lx.extract_links(response)这时我们发现没有匹配到，这是因为我们的字符串没有转义，我们这里转义一下：page_lx = LinkExtractor(allow=('position.php?&start=d+'))然后输入： page_lx.extract_links(response)

这里可能是因为网站改版的原因，我这里匹配没有用，所以这里我测试是没有用的，但是可以展示一下别人的测试结果图：

CrawlSpider 版本

那么，scrapy shell测试完成之后，修改以下代码

下面是改版后的爬虫文件（这里因为前面测试没过，所以我也就不自己写了，直接贴别人的代码），这里大家可以和前面那个爬内涵段子的对比一下，看一下这个版本有哪些不同

#tencent.py

import scrapy
from scrapy.spiders import CrawlSpider, Rule
from scrapy.linkextractors import LinkExtractor
from mySpider.items import TencentItem

class TencentSpider(CrawlSpider):
    name = "tencent"
    allowed_domains = ["hr.tencent.com"]
    start_urls = [
        "http://hr.tencent.com/position.php?&start=0#a"
    ]

    page_lx = LinkExtractor(allow=("start=d+"))

    rules = [
        Rule(page_lx, callback = "parseContent", follow = True)
    ]

    def parseContent(self, response):
        for each in response.xpath('//*[@class="even"]'):
            name = each.xpath('./td[1]/a/text()').extract()[0]
            detailLink = each.xpath('./td[1]/a/@href').extract()[0]
            positionInfo = each.xpath('./td[2]/text()').extract()[0]

            peopleNumber = each.xpath('./td[3]/text()').extract()[0]
            workLocation = each.xpath('./td[4]/text()').extract()[0]
            publishTime = each.xpath('./td[5]/text()').extract()[0]
            #print name, detailLink, catalog,recruitNumber,workLocation,publishTime

            item = TencentItem()
            item['name']=name.encode('utf-8')
            item['detailLink']=detailLink.encode('utf-8')
            item['positionInfo']=positionInfo.encode('utf-8')
            item['peopleNumber']=peopleNumber.encode('utf-8')
            item['workLocation']=workLocation.encode('utf-8')
            item['publishTime']=publishTime.encode('utf-8')

            yield item

    # parse() 方法不需要写     
    # def parse(self, response):                                              
    #     pass

Logging

Scrapy提供了log功能，可以通过 logging 模块使用。

可以修改配置文件settings.py，任意位置添加下面两行，效果会清爽很多。

LOG_FILE = "TencentSpider.log" LOG_LEVEL = "INFO"

这样配置后，我们的输出都会输出到日志文件里面

Log levels

• Scrapy提供5层logging级别:

• CRITICAL - 严重错误(critical)

• ERROR - 一般错误(regular errors)
• WARNING - 警告信息(warning messages)
• INFO - 一般信息(informational messages)
• DEBUG - 调试信息(debugging messages)

logging设置

通过在setting.py中进行以下设置可以被用来配置logging:

1. LOG_ENABLED 默认: True，启用logging
2. LOG_ENCODING 默认: 'utf-8'，logging使用的编码
3. LOG_FILE 默认: None，在当前目录里创建logging输出文件的文件名
4. LOG_LEVEL 默认: 'DEBUG'，log的最低级别
5. LOG_STDOUT 默认: False 如果为 True，进程所有的标准输出(及错误)将会被重定向到log中。例如，执行 print "hello" ，其将会在Scrapy log中显示。

Request

这里就是scrapy的一个请求函数，我们在爬内涵段子的时候用过这个函数，这里介绍一下几个比较常用的函数：

url: 就是需要请求，并进行下一步处理的url

callback: 指定该请求返回的Response，由那个函数来处理。

method: 请求一般不需要指定，默认GET方法，可设置为"GET", "POST", "PUT"等，且保证字符串大写

headers: 请求时，包含的头文件。一般不需要。内容一般如下：
# 自己写过爬虫的肯定知道
Host: media.readthedocs.org
User-Agent: Mozilla/5.0 (Windows NT 6.2; WOW64; rv:33.0) Gecko/20100101 Firefox/33.0
Accept: text/css,*/*;q=0.1
Accept-Language: zh-cn,zh;q=0.8,en-us;q=0.5,en;q=0.3
Accept-Encoding: gzip, deflate
Referer: http://scrapy-chs.readthedocs.org/zh_CN/0.24/
Cookie: _ga=GA1.2.1612165614.1415584110;
Connection: keep-alive
If-Modified-Since: Mon, 25 Aug 2014 21:59:35 GMT
Cache-Control: max-age=0

meta: 比较常用，在不同的请求之间传递数据使用的。字典dict型

request_with_cookies = Request(
url="http://www.example.com",
cookies={'currency': 'USD', 'country': 'UY'},
meta={'dont_merge_cookies': True}
)

encoding: 使用默认的 'utf-8' 就行。

dont_filter: 表明该请求不由调度器过滤。这是当你想使用多次执行相同的请求,忽略重复的过滤器。默认为False。

errback: 指定错误处理函数

Response

这大部分和上面的差不多。

status: 响应码
_set_body(body)： 响应体
_set_url(url)：响应url
self.request = request

发送POST请求

• 可以使用 yield scrapy.FormRequest(url, formdata, callback)方法发送POST请求。

• 如果希望程序执行一开始就发送POST请求，可以重写Spider类的start_requests(self)方法，并且不再调用start_urls里的url。

class mySpider(scrapy.Spider):
    # start_urls = ["http://www.example.com/"]

    def start_requests(self):
        url = 'http://www.renren.com/PLogin.do'

        # FormRequest 是Scrapy发送POST请求的方法
        yield scrapy.FormRequest(
            url = url,
            formdata = {"email" : "mr_mao_hacker@163.com", "password" : "axxxxxxxe"},
            callback = self.parse_page
        )
    def parse_page(self, response):
        # do something

模拟登陆

使用FormRequest.from_response()方法模拟用户登录

通常网站通过 实现对某些表单字段（如数据或是登录界面中的认证令牌等）的预填充。

使用Scrapy抓取网页时，如果想要预填充或重写像用户名、用户密码这些表单字段， 可以使用 FormRequest.from_response() 方法实现。

下面是使用这种方法的爬虫例子:

import scrapy

class LoginSpider(scrapy.Spider):
    name = 'example.com'
    start_urls = ['http://www.example.com/users/login.php']

    def parse(self, response):
        return scrapy.FormRequest.from_response(
            response,
            formdata={'username': 'john', 'password': 'secret'},
            callback=self.after_login
        )

    def after_login(self, response):
        # check login succeed before going on
        if "authentication failed" in response.body:
            self.log("Login failed", level=log.ERROR)
            return

        # continue scraping with authenticated session...

反反爬虫相关机制

(有些些网站使用特定的不同程度的复杂性规则防止爬虫访问，绕过这些规则是困难和复杂的，有时可能需要特殊的基础设施，如果有疑问，请联系商业支持。)

通常防止爬虫被反主要有以下几个策略：

• 动态设置User-Agent（随机切换User-Agent，模拟不同用户的浏览器信息）

• 禁用Cookies（也就是不启用cookies middleware，不向Server发送cookies，有些网站通过cookie的使用发现爬虫行为）

  • 可以通过COOKIES_ENABLED 控制 CookiesMiddleware 开启或关闭

• 设置延迟下载（防止访问过于频繁，设置为 2秒 或更高）

• Google Cache 和 Baidu Cache：如果可能的话，使用谷歌/百度等搜索引擎服务器页面缓存获取页面数据。

• 使用IP地址池：VPN和代理IP，现在大部分网站都是根据IP来ban的。

• 使用 Crawlera（专用于爬虫的代理组件），正确配置和设置下载中间件后，项目所有的request都是通过crawlera发出。

DOWNLOADER_MIDDLEWARES = {

  'scrapy_crawlera.CrawleraMiddleware': 600

}

CRAWLERA_ENABLED = True
CRAWLERA_USER = ‘注册/购买的UserKey’
CRAWLERA_PASS = ‘注册/购买的Password’

设置下载中间件（Downloader Middlewares）

下载中间件是处于引擎(crawler.engine)和下载器(crawler.engine.download())之间的一层组件，可以有多个下载中间件被加载运行。

1. 当引擎传递请求给下载器的过程中，下载中间件可以对请求进行处理 （例如增加http header信息，增加proxy信息等）；

2. 在下载器完成http请求，传递响应给引擎的过程中， 下载中间件可以对响应进行处理（例如进行gzip的解压等）

要激活下载器中间件组件，将其加入到 DOWNLOADER_MIDDLEWARES 设置中。 该设置是一个字典(dict)，键为中间件类的路径，值为其中间件的顺序(order)。

具体大家只需要把那段代码取消注释就可以了。

process_request(self, request, spider)

• 当每个request通过下载中间件时，该方法被调用。

• process_request() 必须返回以下其中之一：一个 None 、一个 Response 对象、一个 Request 对象或 raise IgnoreRequest:

  • 如果其返回 None ，Scrapy将继续处理该request，执行其他的中间件的相应方法，直到合适的下载器处理函数(download handler)被调用， 该request被执行(其response被下载)。

  • 如果其返回 Response 对象，Scrapy将不会调用 任何 其他的 process_request() 或 process_exception() 方法，或相应地下载函数； 其将返回该response。 已安装的中间件的 process_response() 方法则会在每个response返回时被调用。

  • 如果其返回 Request 对象，Scrapy则停止调用 process_request方法并重新调度返回的request。当新返回的request被执行后， 相应地中间件链将会根据下载的response被调用。

  • 如果其raise一个 IgnoreRequest 异常，则安装的下载中间件的 process_exception() 方法会被调用。如果没有任何一个方法处理该异常， 则request的errback(Request.errback)方法会被调用。如果没有代码处理抛出的异常， 则该异常被忽略且不记录(不同于其他异常那样)。

• 参数:

  • request (Request 对象) – 处理的request
  • spider (Spider 对象) – 该request对应的spider

process_response(self, request, response, spider)

当下载器完成http请求，传递响应给引擎的时候调用

• process_request() 必须返回以下其中之一: 返回一个 Response 对象、 返回一个 Request 对象或raise一个 IgnoreRequest 异常。

  • 如果其返回一个 Response (可以与传入的response相同，也可以是全新的对象)， 该response会被在链中的其他中间件的 process_response() 方法处理。

  • 如果其返回一个 Request 对象，则中间件链停止， 返回的request会被重新调度下载。处理类似于 process_request() 返回request所做的那样。

  • 如果其抛出一个 IgnoreRequest 异常，则调用request的errback(Request.errback)。 如果没有代码处理抛出的异常，则该异常被忽略且不记录(不同于其他异常那样)。

• 参数:

  • request (Request 对象) – response所对应的request
  • response (Response 对象) – 被处理的response
  • spider (Spider 对象) – response所对应的spider

看上面的估计也看不大明白，我们直接来一个实际的案例来实验一下：

我们需要新建一个middlewares.py文件（在setting.py的同级目录下新建）不过好像现在新建项目是直接有这个文件的。