爬虫之scrapy框架

Posted zzbj

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了爬虫之scrapy框架相关的知识,希望对你有一定的参考价值。

一、scrapy框架介绍

1、介绍

Scrapy,Python开发的一个快速、高层次的屏幕抓取和web抓取框架,用于抓取web站点并从页面中提取结构化的数据。Scrapy用途广泛,可以用于数据挖掘、监测和自动化测试。

Scrapy吸引人的地方在于它是一个框架,任何人都可以根据需求方便的修改。它也提供了多种类型爬虫的基类,如BaseSpider、sitemap爬虫等,最新版本又提供了web2.0爬虫的支持。

Scrap,是碎片的意思,这个Python的爬虫框架叫Scrapy。

Scrapy 是基于twisted框架开发而来,twisted是一个流行的事件驱动的python网络框架。因此Scrapy使用了一种非阻塞(又名异步)的代码来实现并发。

 

2、scrapy架构图

1. 这是官方给出的架构图

技术图片

 

2. 各个组件的作用

引擎(Engine)
引擎负责控制数据流在系统中所有组件中流动,并在相应动作发生时触发事件。


调度器(Scheduler)
用来接收引擎发过来的请求, 压入队列中, 并在引擎再次请求的时候返回. 相当于一个URL的优先级队列, 由它来决定下一个要抓取的网址是什么, 同时去除重复的网址


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


下载器中间件(Downloader middlewares)
下载器中间件是在引擎及下载器之间的特定钩子(specific hook),处理Downloader传递给引擎的response(也包括引擎传递给下载器的Request)。 其提供了一个简便的机制,通过插入自定义代码来扩展Scrapy功能。


爬虫(Spiders)
Spider是Scrapy用户编写用于分析response并提取item(即获取到的item)或额外跟进的URL的类。 每个spider负责处理一个特定(或一些)网站


爬虫中间件(Spider middlewares)
Spider中间件是在引擎及Spider之间的特定钩子(specific hook),处理spider的输入(response)和输出(items及requests)。 其提供了一个简便的机制,通过插入自定义代码来扩展Scrapy功能。


项目管道(Item Pipeline)
Item Pipeline负责处理被spider提取出来的item。典型的处理有清理、 验证及持久化(例如存取到数据库中)。

 

3、scrapy框架的基本流程

0. 程序开始运行

1. Spiders用yeild将url发送给Engine(引擎)

2. Engine把url发送给调度器(Scheduler)

3. 调度器(Scheduler)会将url生成request返回给Engine(引擎)

4. Engine(引擎)拿到request,通过下载器中间件(Downloader middlewares)进行层层过滤发送给下载器(Downloader)

5. 下载器(Downloader)在网上获取到response数据之后,又经过下载器中间件(Downloader middlewares)进行层层过滤发送给Engine(引擎)

6. Engine(引擎)获取到response数据之后,返回给Spiders,Spiders的parse()方法对获取到的response数据进行处理,解析出items或者requests

7. 将解析出来的items或者requests发送给Engine(引擎)

8. Engine(引擎)获取到items或者requests,将items发送给Item Pipeline进行数据的存储

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

 

4、scrapy框架主要的几个方法

1. process_request(request, spider)
当每个request通过下载中间件时,该方法被调用,这里可以修改UA,代理,Refferer

2. process_response(request, response, spider)
这里可以看返回是否是200加入重试机制

3. process_exception(request, exception, spider)
这里可以处理超时

4. SpiderMiddleware主要处理解析Item的相关逻辑修正,比如数据不完整要添加默认,增加其他额外信息等
process_spider_input(response, spider)
当response通过spider中间件时,该方法被调用,处理该response。


rocess_spider_output(response, result, spider)
当Spider处理response返回result时,该方法被调用。

process_spider_exception(response, exception, spider)
当spider或(其他spider中间件的) process_spider_input()
抛出异常时, 该方法被调用。

 

二、scrapy的基础

1、安装

1. Linux系统
    pip3 install scrapy  # 从官网下载
    pip3 install -i https://pypi.douban.com/simple/ scrapy  # 从豆瓣源下载


2. Windows
    1. pip install -i https://pypi.douban.com/simple/ wheel

    2. 下载twisted: http://www.lfd.uci.edu/~gohlke/pythonlibs/#twisted

    3. 进入下载目录,执行命令:pip3 install Twisted-18.9.0-cp36-cp36m-win_amd64.whl

    4. pip3 install -i https://pypi.douban.com/simple/ pywin32

    5. pip3 install -i https://pypi.douban.com/simple/ scrapy

 

2、cmd下的命令行工具

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

3. 官网链接
    https://docs.scrapy.org/en/latest/topics/commands.html

 

3、目录结构

project_name/
   scrapy.cfg
   project_name/
       __init__.py
       items.py
       middlewares.py
       pipelines.py
       settings.py
       spiders/
           __init__.py
           爬虫1.py
           爬虫2.py
           爬虫3.py

文件说明:
    scrapy.cfg     项目的主配置信息,用来部署scrapy时使用,爬虫相关的配置信息在settings.py文件中。
    items.py       设置数据存储模板,用于结构化数据,如:Django的Model
    middlewares.py 中间件是处于引擎(crawler.engine)和下载器(crawler.engine.download())之间的一层组件
    pipelines      数据处理行为,如:一般结构化的数据持久化
    settings.py    配置文件,如:递归的层数、并发数,延迟下载等。强调:配置文件的选项必须大写否则视为无效
    spiders        爬虫目录,如:创建文件,编写爬虫规则

注意:
1、一般创建爬虫文件时,以网站域名命名
2、默认只能在终端执行命令,为了更便捷操作:
# 在项目根目录下新建:entrypoint.py
from scrapy.cmdline import execute
execute([scrapy, crawl, qsbk, --nolog])

 

如何在pycharm中运行scrapy程序

1、一般创建爬虫文件时,以网站域名命名
2、默认只能在终端执行命令,为了更便捷操作:
# 在项目根目录下新建:entrypoint.py
from scrapy.cmdline import execute
execute([scrapy, crawl, qsbk, --nolog])

 

4、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)

 

5、Scrapy自带的选择器Selectors(xpath)

使用Scrapy自带的选择器,获取到的数据都是Selectors对象,
需要使用extract方法把Selectors对象的内容提取出来。

1,div.xpath(.//div[@class="author clearfix"]/a/h2/text())
结果是Selector对象组成的列表:[<Selector xpath=xxx data=xxx>,]

2,div.xpath(.//div[@class="author clearfix"]/a/h2/text()).extract()
把Selector对象的内容提取出来,还是列表:[data的内容,]

3,div.xpath(.//div[@class="author clearfix"]/a/h2/text()).extract()[0]
把提取出来的列表按索引取出某一个值,若只提取一个,也可以使用extract_first()
div.xpath(.//div[@class="author clearfix"]/a/h2/text()).extract_first()

4,div.xpath(.//div[@class="author clearfix"]/a/h2/text())[0].extract()
先在列表中取出某个Selector对象,在把Selector对象的内容提取出来

 

6、DupeFilter(去重)

1. 默认使用方式
DUPEFILTER_CLASS = scrapy.dupefilter.RFPDupeFilter
Request(...,dont_filter=False)  # 如果dont_filter=True则告诉Scrapy这个URL不参与去重。


2. 自定义去重规则
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

 

三、scrapy的小Demo

1、创建并执行爬虫应用程序

1. 在cmd下输入命令
cd 工作目录
scrapy  startproject  项目名  # 创建项目
cd 项目名
scrapy  genspider  应用名称  爬取的起始url # 创建爬虫程序
scrapy crawl 应用名称  # 该种执行形式会显示执行的日志信息
scrapy crawl 应用名称 --nolog  # 该种执行形式不会显示执行的日志信息
scrapy crawl 应用名称 -o xxx.xml # 存储数据文本格式


2. 示例
# 爬取糗事百科
cd E:SpiderProject爬虫scrapy框架  # 进入工作目录
scrapy startproject QSBK  # 创建一个名为QSBK的项目
cd QSBK  # 进入项目目录
scrapy genspider qsbk www.qiushibaike.com  # 创建爬虫程序(会在项目下的spiders目录下创建qsbk.py程序)
scrapy  crawl  qsbk  # 执行应用程序
scrapy  crawl  qsbk -o qsbk.xml  # 将爬取到的数据解析后存储成xml格式的文件


3.spiders目录下创建的qsbk.py程序
# -*- coding: utf-8 -*-
import scrapy


class QsbkSpider(scrapy.Spider):
    name = qsbk  # 应用名称
    # 允许爬取的域名(如果遇到非该域名的url则爬取不到数据)
    allowed_domains = [www.qiushibaike.com]
    # 起始爬取的url
    start_urls = [http://www.qiushibaike.com/]
    
    # 访问起始URL并获取结果后的回调函数,该函数的response参数就是向起始的url发送请求后,获取的响应对象.
    # 该函数返回值必须为可迭代对象或者NUll
    def parse(self, response):
        print(response.text)  # 获取字符串类型的响应内容
        print(response.body)  # 获取字节类型的响应内容


4. 项目的配置文件(settings.py)相关配置
修改内容及其结果如下:
19行:伪装请求载体身份(伪装成浏览器)
USER_AGENT = Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.80 Safari/537.36

22行:可以忽略或者不遵守robots协议
ROBOTSTXT_OBEY = False

注意:settings.py的配置项的名称都要大写


5. 爬取糗百首页中文字段子的内容和作者
对qsbk.py进行修改
"""
注意:记得修改settings.py的配置哦!!!

类QsbkSpider是继承了scrapy.Spider这个类的,
scrapy.Spider中的start_requests方法是我们爬虫主逻辑、策略,
因为start_requests方法默认只是做了一些简单的爬取措施,
如果要爬取的网页有了很强的反爬措施,此时就需要我们重写start_requests方法,破解反爬措施。
start_requests方法必须yield Request对象,因此需要导入 from scrapy import Request
"""

import scrapy
from scrapy import Request
# from scrapy.http import Request  # 跟上面导入的Request是一样的


class QsbkSpider(scrapy.Spider):
    name = qsbk  # 应用名称
    # 允许爬取的域名(如果遇到非该域名的url则爬取不到数据)
    allowed_domains = [www.qiushibaike.com]
    # 起始爬取的url
    start_urls = [https://www.qiushibaike.com/text/]

    def start_requests(self):
        # 爬虫主逻辑 策略
        yield Request(
            url="https://www.qiushibaike.com/text/",
            callback=self.parse,  # 定义回调函数,不写默认就是 parse
        )

    def parse(self, response):
        # 用xpath或者BS或者 css selector进行数据解析
        # 这里的response自带xpath方法,可以将xpath表达式直接作用于该函数中
        odiv = response.xpath(//div[@id="content-left"]/div)
        content_list = []  # 用于存储解析到的数据
        # xpath函数返回的为列表,列表中存放的数据为Selector类型的数据
        # 我们解析到的内容被封装在了Selector对象中,需要调用extract()函数将解析的内容从Selecor中取出
        for div in odiv:
            # 1.获取用户名author
            author = div.xpath(.//div[@class="author clearfix"]/a/h2/text())
            if author:
                author = author[0].extract()
            else:
                author = "匿名用户"
            # 2.获取这个用户的段子的内容contents
            contents = div.xpath(.//div[@class="content"]/span/text())  # 遇到换行br就会生成一个Selector对象

            content_list.append({
                "author": author,
                "content": "".join([selector.extract().strip() for selector in contents])
            })
        print("content_list", content_list)
        return content_list

 

四、爬取亚马逊的iphoneXs商品

1.主爬虫程序
"""
登录亚马逊官方,搜索:iphone xs max
需要解析出来的数据:商品简介、价格、配送方
爬取前10页

注意在settings中设置UA反爬和不遵守robots
"""

import scrapy
from scrapy import Request


class AmazonSpider(scrapy.Spider):
    name = amazon
    allowed_domains = [www.amazon.cn]
    start_urls = [https://www.amazon.cn/]

    def start_requests(self):
        yield Request(
            url="https://www.amazon.cn/s/ref=nb_sb_noss_1?__mk_zh_CN=%E4%BA%9A%E9%A9%AC%E9%80%8A%E7%BD%91%E7%AB%99&url=search-alias%3Daps&field-keywords=iphone+xs+max",
            callback=self.parse_index,
            dont_filter=True
        )

    def parse_index(self, response):
        ‘‘‘
        解析商品首页获取几十个商品详情的url,发请求
        解析函数的返回值:
           (1) 字典或者迭代数据(比如列表套字典)
           (2) 请求Request对象
           (3) item对象(通过pipeline做持久化的)
        ‘‘‘

        # 商品列表页的所有商品的URL
        detail_urls = response.xpath(//*[contains(@id,"result_")]/div/div[3]/div[1]/a/@href).extract()
        for detail_url in detail_urls:
            print("detail_url", detail_url)
            yield Request(
                url=detail_url,
                callback=self.parse_detail,  # parse_detail解析详情页的函数
                dont_filter=True
            )

        # 解析一个下一页的URL,经过测试发现下面xpath解析出来的url是相对路径,因此需要我们拼接出完整的url
        # response.urljoin方法能帮我们把要爬取的网页域名和需要拼接的url进行拼接
        next_url = response.urljoin(response.xpath(//*[@id="pagnNextLink"]/@href).extract_first())
        yield Request(
            url=next_url,
            callback=self.parse_index,
            dont_filter=True
        )

    def parse_detail(self, response):
        ‘‘‘
        response: 某一个商品详情页的响应体
        ‘‘‘
        title = response.xpath(//*[@id="productTitle"]/text())[0].extract().strip()
        price = response.xpath(//*[@id="priceblock_ourprice"]/text())[0].extract().strip()
        delivery = response.xpath(//*[@id="ddmMerchantMessage"]/*[1]/text()).extract()

        print(title)
        print(price)
        print(delivery)


2.免费代理网站
http://www.goubanjia.com/


3.设置代理池
当你的ip访问亚马逊太过频繁的时候,亚马逊会对你进行反爬(暂封你的ip),
若你发现无法爬取亚马逊网页的时候,可设置代理池(下面会详细讲,现在先把网页爬下来)

步骤:
    1. 在免费代理网站上找一个能用的代理ip
    2. 在middlewares.py中找到AmazonDownloaderMiddleware类下的process_request方法
    3. 在process_request中写入如下几行
        proxy = http://77.70.115.104:8080
        request.meta[download_timeout] = 20
        request.meta[proxy] = proxy

 

五、Item

Item对象是用于收集抓取数据的简单容器。它们提供类似字典的 API,并具有用于声明其可用字段的方便语法。
Scrapy Items类似于Django Models,但是Scrapy Items更简单,因为没有不同字段类型的概念。

1.声明Item
在项目中找到items.py,使用简单的类定义语法和Field对象声明项目

import scrapy

class AmazonItem(scrapy.Item):
    # define the fields for your item here like:
    title = scrapy.Field()
    price = scrapy.Field()
    delivery = scrapy.Field()


2.使用Item
# 在需要使用的地方(爬虫主程序)导入这个类
from ..items import AmazonItem

# 实例化对象并添加数据
item = AmazonItem()
item["title"] = title
item["price"] = price
item["delivery"] = delivery


3. Demo
# 上面亚马逊的parse_detail可以这样写(先实例化再设置数据)
def parse_detail(self, response):
    ‘‘‘
    response: 某一个商品详情页的响应体
    ‘‘‘
    title = response.xpath(//*[@id="productTitle"]/text())[0].extract().strip()
    price = response.xpath(//*[@id="priceblock_ourprice"]/text())[0].extract().strip()
    delivery = response.xpath(//*[@id="ddmMerchantMessage"]/*[1]/text()).extract()

    print(title)
    print(price)
    print(delivery)

    item = AmazonItem()  # 先实例化
    item["title"] = title  # 再设置数据
    item["price"] = price
    item["delivery"] = delivery

    return item

# 还可以这样写(实例化的时候初始化数据)
def parse_detail(self, response):
    ‘‘‘
    response: 某一个商品详情页的响应体
    ‘‘‘
    title = response.xpath(//*[@id="productTitle"]/text())[0].extract().strip()
    price = response.xpath(//*[@id="priceblock_ourprice"]/text())[0].extract().strip()
    delivery = response.xpath(//*[@id="ddmMerchantMessage"]/*[1]/text()).extract()

    print(title)
    print(price)
    print(delivery)

    item = AmazonItem(title=title, price=price, delivery=delivery)  # 实例化的时候初始化数据
    # 获取字段值
    print(item[title])
    print(item.get(price))
    
    # 访问所有键
    print(item.keys())
    
    # 访问所有的键值对
    print(item.items())
    
    return item

 

六、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(排序存储)

PipeLine只接收Item对象,PipeLine在项目中的pipelines.py里面定义。
定义好的PipeLine类需要在settings里面进行声明,只要在主程序中return item就会自动去settings中找到声明的PipeLine类,
然后对item进行处理,存储。

# 大概在settings的67行设置pipeline类,
ITEM_PIPELINES = {
   Amazon.pipelines.AmazonPipeline: 300,
}

 

1、编写自己的项目管道

每个项管道组件都是一个以下方法的Python类:

# item进入pipeline前会调用这个方法
open_spider(self,蜘蛛)
打开蜘蛛时会调用此方法。

# 必须实现的方法,用来处理item数据的方法(核心方法)
process_item(self,项目,蜘蛛)
为每个项目管道组件调用此方法。process_item() 
返回带数据的dict,返回一个Item (或任何后代类)对象,返回Twisted Deferred或引发 DropItem异常。丢弃的项目不再由其他管道组件处理。

# item处理完毕后调用这个方法
close_spider(self,蜘蛛)
当蜘蛛关闭时调用此方法。

# 当pipeline类实例化的时候,如果有from_crawler方法会先执行这个方法,再执行init方法
# 参数crawler代表这个爬虫程序,可以在此拿到爬虫的名字、域名、配置参数等,都可以从这里拿到
from_crawler(cls,crawler)
如果存在,则调用此类方法以从a创建管道实例Crawler。它必须返回管道的新实例。Crawler对象提供对所有Scrapy核心组件的访问,
如设置和信号; 它是管道访问它们并将其功能挂钩到Scrapy的一种方式。

 

2、使用MongoDB存储item

1. settings中的配置
# 与Mongodb数据库相关配置
HOST = "127.0.0.1"
PORT = 27017
USER = "root"
PWD = ""
DB = "amazon"
TABLE = "goods"

# 声明pipeline类
ITEM_PIPELINES = {
   Amazon.pipelines.MongodbPipeline: 300,
}


2. 定义pipeline类
from pymongo import MongoClient


class MongodbPipeline(object):
    def __init__(self, host, port, user, pwd, db, table):
        self.host = host
        self.port = port
        self.user = user
        self.pwd = pwd
        self.db = db
        self.table = table

    @classmethod
    def from_crawler(cls, crawler):
        """
        Scrapy会先通过getattr判断我们是否自定义了from_crawler,有则调它来完成实例化
        从爬虫程序crawler中的settings配置拿到我们需要的数据,返回给这个类,然后调用init实例化
        """
        HOST = crawler.settings.get(HOST)
        PORT = crawler.settings.get(PORT)
        USER = crawler.settings.get(USER)
        PWD = crawler.settings.get(PWD)
        DB = crawler.settings.get(DB)
        TABLE = crawler.settings.get(TABLE)
        # 必须返回这个类的对象
        return cls(HOST, PORT, USER, PWD, DB, TABLE)

    def open_spider(self, spider):
        """
        爬虫刚启动时执行一次
        """
        # self.client = MongoClient(‘mongodb://%s:%[email protected]%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)  # 把item转换成字典类型
        if all(d.values()):  # 当字典不为空的时候插入数据
            self.client[self.db][self.table].save(d)  # save方法也等于插入数据并保存
        return item

 

3、item流向多个pipeline

1. 基于上面的settings再进行配置
# 声明pipeline类
ITEM_PIPELINES = {
   Amazon.pipelines.MongodbPipeline: 300,
   Amazon.pipelines.FilePipeline: 400,
}


2. 再定义一个pipeline类
class FilePipeline(object):
    def open_spider(self, spider):
        """
        爬虫刚启动时执行一次
        """
        print("文件写入一个item")
        # self.client = MongoClient(‘mongodb://%s:%[email protected]%s:%s‘ %(self.user,self.pwd,self.host,self.port))
        self.file = open("file_pipeline.txt", "w")

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

    def process_item(self, item, spider):
        # 操作并进行持久化
        d = dict(item)
        import json
        self.file.write(json.dumps(d) + "
")

3. 多个管道的流程
ITEM_PIPELINES = {
   Amazon.pipelines.MongodbPipeline: 300,
   Amazon.pipelines.FilePipeline: 400,
}
300和400是权重,设置多少都行,看自己喜好,权重小的管道先执行,
因此MongodbPipeline先执行,执行完毕后,process_item方法必须return item,
return item后会把item传给下一个管道FilePipeline进行处理。

如果你想处理完后不再给别人处理了,那么可以
from scrapy.exceptions import DropItem

def process_item(self, item, spider):
    if 某种情况:
        raise DropItem("Duplicate item found: %s" % item)

 

七、下载中间件

scrapy的下载中间件个Django的中间件类似,
process_request、process_response等方法也是类似的

不同的是:
Django中process_request返回一个对象后,process_response是从process_request对应的process_response开始返回,
而scrapy的下载中间件process_request返回一个对象后,process_response是从第一个process_response开始返回,


1. settings中的配置
# 大概在settings的55行
DOWNLOADER_MIDDLEWARES = {
   Amazon.middlewares.MyDownMiddleware: 543,
}

2. 权重
process_request权重小的先执行
process_response权重大的先执行
process_request权重小的先执行

3. 各个方法的作用
class MyDownMiddleware(object):
    def process_request(self, request, spider):
        """
        请求需要被下载时,经过所有下载器中间件的process_request调用
        :param request: 
        :param spider: 
        :return:  
            None,继续后续中间件去下载;
            Response对象,停止process_request的执行,开始执行process_response
            Request对象,停止中间件的执行,将Request重新调度
            raise IgnoreRequest异常,停止process_request的执行,开始执行process_exception
        """
        pass

    def process_response(self, request, response, spider):
        """
        spider处理完成,返回时调用
        :param response:
        :param result:
        :param spider:
        :return: 
            Response 对象:转交给其他中间件process_response
            Request 对象:停止中间件,request会被重新调度下载
            raise IgnoreRequest 异常:调用Request.errback
        """
        print(response1)
        return response

    def process_exception(self, request, exception, spider):
        """
        当下载处理器(download handler)或 process_request() (下载中间件)抛出异常
        :param response:
        :param exception:
        :param spider:
        :return: 
            None:继续交给后续中间件处理异常;
            Response对象:停止后续process_exception方法
            Request对象:停止中间件,request将会被重新调用下载
        """
        return None


因此我们更换代理的时候,应该放在process_exception中
def process_exception(self, request, exception, spider):
    # Called when a download handler or a process_request()
    # (from other downloader middleware) raises an exception.

    # Must either:
    # - return None: continue processing this exception
    # - return a Response object: stops process_exception() chain
    # - return a Request object: stops process_exception() chain
    proxy = http://77.70.115.104:8080
    request.meta[download_timeout] = 20
    request.meta[proxy] = proxy
    return request  # 返回request,即把请求返回给调度器,调度器再重新去发请求

 

八、代理池

1、原理

我们跟换代理的时候,应该是在某个代理网站上,把可用的代理全部爬下来,
当出现异常的时候就去代理池中把真正能用的ip跟换到我的程序中,
因此还需要写一个爬代理ip网站的程序,这个不用担心,去github中搜就可以,
把搜到的应用结合到我们的爬虫程序中

 

2、步骤

1. 把下载到的程序放到我们爬虫程序中
2. 读README.md文件,根据步骤进行一些初始化配置
3. 把爬ip的程序启动后,把爬取到的代理ip存到MongoDB中
    [DB]
    ;Configure the database information
    ;type: SSDB/MONGODB if use redis, only modify the host port,the type should be SSDB
    type = MONGODB
    host = 127.0.0.1
    port = 27017
    name = proxy

4. 如果要在爬虫代码中使用的话, 可以将此api封装成函数直接使用,例如:
import requests

def get_proxy():
    return requests.get("http://127.0.0.1:5010/get/").content

def delete_proxy(proxy):
    requests.get("http://127.0.0.1:5010/delete/?proxy={}".format(proxy))

开发的api接口在这里设置
[API]
# API config http://127.0.0.1:5010
# The ip specified when starting the web API
ip = 0.0.0.0
# he port on which to run the web API
port = 5010

 

3、代码实现

1. 首先确保已经把代理ip的那个网站爬下来了

2. 确保DB和API设置好了

3. 在我们的爬虫程序中新建一个proxy.py文件
代码如下:
import requests

def get_proxy():
    return requests.get("http://127.0.0.1:5010/get/").content

def delete_proxy(proxy):
    requests.get("http://127.0.0.1:5010/delete/?proxy={}".format(proxy))

4. 我们爬虫程序的下载中间件代码
from .proxy import get_proxy,delete_proxy

class AmazonDownloaderMiddleware(object):
    def process_exception(self, request, exception, spider):
        # Called when a download handler or a process_request()
        # (from other downloader middleware) raises an exception.

        # Must either:
        # - return None: continue processing this exception
        # - return a Response object: stops process_exception() chain
        # - return a Request object: stops process_exception() chain
        proxy = "http://"+get_proxy()
        request.meta[download_timeout] = 20
        request.meta["proxy"] = proxy
        return request

 

以上是关于爬虫之scrapy框架的主要内容,如果未能解决你的问题,请参考以下文章

Python之Scrapy安装

走近代码之Python--爬虫框架Scrapy

爬虫框架Scrapy 之 --- scrapy文件

Python编程基础之(五)Scrapy爬虫框架

Python爬虫之Scrapy框架结构

Scrapy框架之基于RedisSpider实现的分布式爬虫