97、爬虫框架scrapy

本篇导航：

介绍与安装
命令行工具
项目结构以及爬虫应用简介
Spiders
其它介绍
爬取亚马逊商品信息

一、介绍与安装

Scrapy一个开源和协作的框架，其最初是为了页面抓取 (更确切来说, 网络抓取 )所设计的，使用它可以以快速、简单、可扩展的方式从网站中提取所需的数据。但目前Scrapy的用途十分广泛，可用于如数据挖掘、监测和自动化测试等领域，也可以应用在获取API所返回的数据(例如 Amazon Associates Web Services ) 或者通用的网络爬虫。

Scrapy 是基于twisted框架开发而来，twisted是一个流行的事件驱动的python网络框架。因此Scrapy使用了一种非阻塞（又名异步）的代码来实现并发。整体架构大致如下

1、在Scrapy的数据流是由执行引擎控制，并且是这样的：（看官方文档见下面官方链接）

引擎（Engine ）获得从爬虫（Spider）的初始请求。.
引擎（Engine ）调度调度程序（Scheduler）中的请求，并请求下一个爬虫请求。
调度程序（Scheduler）返回引擎（Engine ）的下一个请求。
引擎（Engine ）发出的下载请求，通过下载中间件（Downloader Middlewares）（即process_request()）。
一旦页面完成下载下载器（Downloader ）产生一个响应（与页面）并把它发送到引擎（Engine ），通过下载中间件（即process_response()）。
引擎（Engine ）从下载器（Downloader ）接收响应并将其发送到处理的爬虫（Spider），通过爬虫中间件（ Spider Middleware）（即process_spider_input()）。
爬虫（Spider）程序的返回响应并和新的请求（跟随）到引擎（Engine ），通过爬虫中间件（ Spider Middleware）（即process_spider_output()）
引擎（Engine ）将处理过的项目发送到项目管道（ Item Pipelines），然后将处理过的请求发送给调度程序（Scheduler），并请求下一个爬虫请求。
进程重复（从步骤1），直到不再有来自调度器（Scheduler）的请求。

2、Components：

引擎(EGINE)

引擎负责控制系统所有组件之间的数据流，并在某些动作发生时触发事件。有关详细信息，请参见上面的数据流部分。
调度器(SCHEDULER)
用来接受引擎发过来的请求, 压入队列中, 并在引擎再次请求的时候返回. 可以想像成一个URL的优先级队列, 由它来决定下一个要抓取的网址是什么, 同时去除重复的网址
下载器(DOWLOADER)
用于下载网页内容, 并将网页内容返回给EGINE，下载器是建立在twisted这个高效的异步模型上的
爬虫(SPIDERS)
SPIDERS是开发人员自定义的类，用来解析responses，并且提取items，或者发送新的请求
项目管道(ITEM PIPLINES)
在items被提取后负责处理它们，主要包括清理、验证、持久化（比如存到数据库）等操作
下载器中间件(Downloader Middlewares)
位于Scrapy引擎和下载器之间，主要用来处理从EGINE传到DOWLOADER的请求request，已经从DOWNLOADER传到EGINE的响应response，你可用该中间件做以下几件事爬虫中间件(Spider Middlewares)
1. 处理一个请求之前，它被发送到下载器（即右scrapy的请求发送到网站之前）；
2. 在将它传递给爬虫之前更改接收的响应；
3. 发送一个新请求，而不是将接收的响应传递给一个爬虫；
4. 在不抓取网页的情况下对爬虫传递响应；
5. 默默地放弃一些请求。
位于EGINE和SPIDERS之间，主要工作是处理SPIDERS的输入（即responses）和输出（即requests）

3、官网链接：

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

4、安装

#Windows平台

    1、pip3 install wheel #安装后，便支持通过wheel文件安装软件，wheel文件官网：https://www.lfd.uci.edu/~gohlke/pythonlibs

    3、pip3 install lxml

    4、pip3 install pyopenssl

    5、下载并安装pywin32：https://sourceforge.net/projects/pywin32/files/pywin32/

    6、下载twisted的wheel文件：http://www.lfd.uci.edu/~gohlke/pythonlibs/#twisted

    7、执行pip3 install 下载目录\Twisted-17.9.0-cp36-cp36m-win_amd64.whl

    8、pip3 install scrapy

#Linux平台

    1、pip3 install scrapy

详细安装步骤：

windows平台安装scrapy

二、命令行工具

#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

#1、执行全局命令：请确保不在某个项目的目录下，排除受该项目配置的影响

scrapy startproject MyProject

cd MyProject

scrapy genspider baidu www.baidu.com

scrapy settings --get XXX #如果切换到项目目录下，看到的则是该项目的配置

scrapy runspider baidu.py

scrapy shell https://www.baidu.com

    response

    response.status

    response.body

    view(response)

scrapy view https://www.taobao.com #如果页面显示内容不全，不全的内容则是ajax请求实现的，以此快速定位问题

scrapy fetch --nolog --headers https://www.taobao.com

scrapy version #scrapy的版本

scrapy version -v #依赖库的版本

#2、执行项目命令：切到项目目录下

scrapy crawl baidu

scrapy check

scrapy list

scrapy parse http://quotes.toscrape.com/ --callback parse

scrapy bench

示范用法

三、项目结构以及爬虫应用简介

project_name/

   scrapy.cfg

   project_name/

       __init__.py

       items.py

       pipelines.py

       settings.py

       spiders/

           __init__.py

           爬虫1.py

           爬虫2.py

           爬虫3.py

文件说明：

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

注意：一般创建爬虫文件时，以网站域名命名

#在项目目录下新建：entrypoint.py

from scrapy.cmdline import execute

execute(['scrapy', 'crawl', 'xiaohua'])

默认只能在cmd中执行爬虫，在pycharm中执行需要

import sys,os

sys.stdout=io.TextIOWrapper(sys.stdout.buffer,encoding='gb18030')

关于windows编码

四、Spiders

1、介绍

#1、Spiders是由一系列类（定义了一个网址或一组网址将被爬取）组成，具体包括如何执行爬取任务并且如何从页面中提取结构化的数据。

#2、换句话说，Spiders是你为了一个特定的网址或一组网址自定义爬取和解析页面行为的地方

2、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）

3、Spiders总共提供了五种类：

#1、scrapy.spiders.Spider #scrapy.Spider等同于scrapy.spiders.Spider

#2、scrapy.spiders.CrawlSpider

#3、scrapy.spiders.XMLFeedSpider

#4、scrapy.spiders.CSVFeedSpider

#5、scrapy.spiders.SitemapSpider

4、导入使用

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

import scrapy

from scrapy.spiders import Spider,CrawlSpider,XMLFeedSpider,CSVFeedSpider,SitemapSpider

class AmazonSpider(scrapy.Spider): #自定义类，继承Spiders提供的基类

    name = 'amazon'

    allowed_domains = ['www.amazon.cn']

    start_urls = ['http://www.amazon.cn/']

    def parse(self, response):

        pass

5、class scrapy.spiders.Spider

这是最简单的spider类，任何其他的spider类都需要继承它（包含你自己定义的）。

该类不提供任何特殊的功能，它仅提供了一个默认的start_requests方法默认从start_urls中读取url地址发送requests请求，并且默认parse作为回调函数

class AmazonSpider(scrapy.Spider):

    name = 'amazon' 

    allowed_domains = ['www.amazon.cn'] 

    start_urls = ['http://www.amazon.cn/']

    custom_settings = {

        'BOT_NAME' : 'Egon_Spider_Amazon',

        'REQUEST_HEADERS' : {

          'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',

          'Accept-Language': 'en',

        }

    }

    def parse(self, response):

        pass

#1、name = 'amazon'

定义爬虫名，scrapy会根据该值定位爬虫程序

所以它必须要有且必须唯一（In Python 2 this must be ASCII only.）

#2、allowed_domains = ['www.amazon.cn']

定义允许爬取的域名，如果OffsiteMiddleware启动（默认就启动），

那么不属于该列表的域名及其子域名都不允许爬取

如果爬取的网址为：https://www.example.com/1.html，那就添加'example.com'到列表.

#3、start_urls = ['http://www.amazon.cn/']

如果没有指定url，就从该列表中读取url来生成第一个请求

#4、custom_settings

值为一个字典，定义一些配置信息，在运行爬虫程序时，这些配置会覆盖项目级别的配置

所以custom_settings必须被定义成一个类属性，由于settings会在类实例化前被加载

#5、settings

通过self.settings['配置项的名字']可以访问settings.py中的配置，如果自己定义了custom_settings还是以自己的为准

#6、logger

日志名默认为spider的名字

self.logger.debug('=============>%s' %self.settings['BOT_NAME'])

#5、crawler：了解

该属性必须被定义到类方法from_crawler中

#6、from_crawler(crawler, *args, **kwargs)：了解

You probably won’t need to override this directly  because the default implementation acts as a proxy to the __init__() method, calling it with the given arguments args and named arguments kwargs.

#7、start_requests()

该方法用来发起第一个Requests请求，且必须返回一个可迭代的对象。它在爬虫程序打开时就被Scrapy调用，Scrapy只调用它一次。

默认从start_urls里取出每个url来生成Request(url, dont_filter=True)

#针对参数dont_filter,请看自定义去重规则

如果你想要改变起始爬取的Requests，你就需要覆盖这个方法，例如你想要起始发送一个POST请求，如下

class MySpider(scrapy.Spider):

    name = 'myspider'

    def start_requests(self):

        return [scrapy.FormRequest("http://www.example.com/login",

                                   formdata={'user': 'john', 'pass': 'secret'},

                                   callback=self.logged_in)]

    def logged_in(self, response):

        # here you would extract links to follow and return Requests for

        # each of them, with another callback

        pass

#8、parse(response)

这是默认的回调函数，所有的回调函数必须返回an iterable of Request and/or dicts or Item objects.

#9、log(message[, level, component])：了解

Wrapper that sends a log message through the Spider’s logger, kept for backwards compatibility. For more information see Logging from Spiders.

#10、closed(reason)

爬虫程序结束时自动触发

定制scrapy.spider属性与方法详解

去重规则应该多个爬虫共享的，但凡一个爬虫爬取了，其他都不要爬了，实现方式如下

#方法一：

1、新增类属性

visited=set() #类属性

2、回调函数parse方法内：

def parse(self, response):

    if response.url in self.visited:

        return None

    .......

    self.visited.add(response.url) 

#方法一改进：针对url可能过长，所以我们存放url的hash值

def parse(self, response):

        url=md5(response.request.url)

    if url in self.visited:

        return None

    .......

    self.visited.add(url) 

#方法二：Scrapy自带去重功能

配置文件：

DUPEFILTER_CLASS = 'scrapy.dupefilter.RFPDupeFilter' #默认的去重规则帮我们去重，去重规则在内存中

DUPEFILTER_DEBUG = False

JOBDIR = "保存范文记录的日志路径，如：/root/"  # 最终路径为 /root/requests.seen，去重规则放文件中

scrapy自带去重规则默认为RFPDupeFilter，只需要我们指定

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

#方法三：

我们也可以仿照RFPDupeFilter自定义去重规则，

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

#步骤二：配置文件settings.py：

DUPEFILTER_CLASS = '项目名.dup.UrlFilter'

# 源码分析：

from scrapy.core.scheduler import Scheduler

见Scheduler下的enqueue_request方法：self.df.request_seen(request)

去重规则：去除重复的url

#例一：

import scrapy

class MySpider(scrapy.Spider):

    name = 'example.com'

    allowed_domains = ['example.com']

    start_urls = [

        'http://www.example.com/1.html',

        'http://www.example.com/2.html',

        'http://www.example.com/3.html',

    ]

    def parse(self, response):

        self.logger.info('A response from %s just arrived!', response.url)

#例二：一个回调函数返回多个Requests和Items

import scrapy

class MySpider(scrapy.Spider):

    name = 'example.com'

    allowed_domains = ['example.com']

    start_urls = [

        'http://www.example.com/1.html',

        'http://www.example.com/2.html',

        'http://www.example.com/3.html',

    ]

    def parse(self, response):

        for h3 in response.xpath('//h3').extract():

            yield {"title": h3}

        for url in response.xpath('//a/@href').extract():

            yield scrapy.Request(url, callback=self.parse)

#例三：在start_requests()内直接指定起始爬取的urls，start_urls就没有用了，

import scrapy

from myproject.items import MyItem

class MySpider(scrapy.Spider):

    name = 'example.com'

    allowed_domains = ['example.com']

    def start_requests(self):

        yield scrapy.Request('http://www.example.com/1.html', self.parse)

        yield scrapy.Request('http://www.example.com/2.html', self.parse)

        yield scrapy.Request('http://www.example.com/3.html', self.parse)

    def parse(self, response):

        for h3 in response.xpath('//h3').extract():

            yield MyItem(title=h3)

        for url in response.xpath('//a/@href').extract():

            yield scrapy.Request(url, callback=self.parse)

例子

我们可能需要在命令行为爬虫程序传递参数，比如传递初始的url，像这样

#命令行执行

scrapy crawl myspider -a category=electronics

#在__init__方法中可以接收外部传进来的参数

import scrapy

class MySpider(scrapy.Spider):

    name = 'myspider'

    def __init__(self, category=None, *args, **kwargs):

        super(MySpider, self).__init__(*args, **kwargs)

        self.start_urls = ['http://www.example.com/categories/%s' % category]

        #...

#注意接收的参数全都是字符串，如果想要结构化的数据，你需要用类似json.loads的方法

参数传递

6、其他通用Spiders：

https://docs.scrapy.org/en/latest/topics/spiders.html#generic-spiders

五、其它介绍

1、Selectors

#1 //与/

#2 text

#3、extract与extract_first:从selector对象中解出内容

#4、属性：xpath的属性加前缀@

#4、嵌套查找

#5、设置默认值

#4、按照属性查找

#5、按照属性模糊查找

#6、正则表达式

#7、xpath相对路径

#8、带变量的xpath

response.selector.css()

response.selector.xpath()

可简写为

response.css()

response.xpath()

#1 //与/

response.xpath('//body/a/')#

response.css('div a::text')

>>> response.xpath('//body/a') #开头的//代表从整篇文档中寻找,body之后的/代表body的儿子

[]

>>> response.xpath('//body//a') #开头的//代表从整篇文档中寻找,body之后的//代表body的子子孙孙

[<Selector xpath='//body//a' data='<a href="image1.html">Name: My image 1 <'>, <Selector xpath='//body//a' data='<a href="image2.html">Name: My image 2 <'>, <Selector xpath='//body//a' data='<a href="

image3.html">Name: My image 3 <'>, <Selector xpath='//body//a' data='<a href="image4.html">Name: My image 4 <'>, <Selector xpath='//body//a' data='<a href="image5.html">Name: My image 5 <'>]

#2 text

>>> response.xpath('//body//a/text()')

>>> response.css('body a::text')

#3、extract与extract_first:从selector对象中解出内容

>>> response.xpath('//div/a/text()').extract()

['Name: My image 1 ', 'Name: My image 2 ', 'Name: My image 3 ', 'Name: My image 4 ', 'Name: My image 5 ']

>>> response.css('div a::text').extract()

['Name: My image 1 ', 'Name: My image 2 ', 'Name: My image 3 ', 'Name: My image 4 ', 'Name: My image 5 ']

>>> response.xpath('//div/a/text()').extract_first()

'Name: My image 1 '

>>> response.css('div a::text').extract_first()

'Name: My image 1 '

#4、属性：xpath的属性加前缀@

>>> response.xpath('//div/a/@href').extract_first()

'image1.html'

>>> response.css('div a::attr(href)').extract_first()

'image1.html'

#4、嵌套查找

>>> response.xpath('//div').css('a').xpath('@href').extract_first()

'image1.html'

#5、设置默认值

>>> response.xpath('//div[@id="xxx"]').extract_first(default="not found")

'not found'

#4、按照属性查找

response.xpath('//div[@id="images"]/a[@href="image3.html"]/text()').extract()

response.css('#images a[@href="image3.html"]/text()').extract()

#5、按照属性模糊查找

response.xpath('//a[contains(@href,"image")]/@href').extract()

response.css('a[href*="image"]::attr(href)').extract()

response.xpath('//a[contains(@href,"image")]/img/@src').extract()

response.css('a[href*="imag"] img::attr(src)').extract()

response.xpath('//*[@href="image1.html"]')

response.css('*[href="image1.html"]')

#6、正则表达式

response.xpath('//a/text()').re(r'Name: (.*)')

response.xpath('//a/text()').re_first(r'Name: (.*)')

#7、xpath相对路径

>>> res=response.xpath('//a[contains(@href,"3")]')[0]

>>> res.xpath('img')

[<Selector xpath='img' data='<img src="data:image3_thumb.jpg">'>]

>>> res.xpath('./img')

[<Selector xpath='./img' data='<img src="data:image3_thumb.jpg">'>]

>>> res.xpath('.//img')

[<Selector xpath='.//img' data='<img src="data:image3_thumb.jpg">'>]

>>> res.xpath('//img') #这就是从头开始扫描

[<Selector xpath='//img' data='<img src="data:image1_thumb.jpg">'>, <Selector xpath='//img' data='<img src="data:image2_thumb.jpg">'>, <Selector xpath='//img' data='<img src="data:image3_thumb.jpg">'>, <Selector xpa

th='//img' data='<img src="data:image4_thumb.jpg">'>, <Selector xpath='//img' data='<img src="data:image5_thumb.jpg">'>]

#8、带变量的xpath

>>> response.xpath('//div[@id=$xxx]/a/text()',xxx='images').extract_first()

'Name: My image 1 '

>>> response.xpath('//div[count(a)=$yyy]/@id',yyy=5).extract_first() #求有5个a标签的div的id

'images'

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

2、Items

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

3、Item Pipeline

#一：可以写多个Pipeline类

#1、如果优先级高的Pipeline的process_item返回一个值或者None，会自动传给下一个pipline的process_item,

#2、如果只想让第一个Pipeline执行，那得让第一个pipline的process_item抛出异常raise DropItem()

#3、可以用spider.name == '爬虫名' 来控制哪些爬虫用哪些pipeline

二：示范

from scrapy.exceptions import DropItem

class CustomPipeline(object):

    def __init__(self,v):

        self.value = v

    @classmethod

    def from_crawler(cls, crawler):

        """

        Scrapy会先通过getattr判断我们是否自定义了from_crawler,有则调它来完

        成实例化

        """

        val = crawler.settings.getint('MMMM')

        return cls(val)

    def open_spider(self,spider):

        """

        爬虫刚启动时执行一次

        """

        print('')

    def close_spider(self,spider):

        """

        爬虫关闭时执行一次

        """

        print('')

    def process_item(self, item, spider):

        # 操作并进行持久化

        # return表示会被后续的pipeline继续处理

        return item

        # 表示将item丢弃，不会被后续pipeline处理

        # raise DropItem()

自定义pipeline

#1、settings.py

HOST="127.0.0.1"

PORT=27017

USER="root"

PWD=""

DB="amazon"

TABLE="goods"

ITEM_PIPELINES = {

   'Amazon.pipelines.CustomPipeline': 200,

}

#2、pipelines.py

class CustomPipeline(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,有则调它来完

        成实例化

        """

        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:%s@%s:%s' %(self.user,self.pwd,self.host,self.port))

    def close_spider(self,spider):

        """

        爬虫关闭时执行一次

        """

        self.client.close()

    def process_item(self, item, spider):

        # 操作并进行持久化

        self.client[self.db][self.table].save(dict(item))

示范

https://docs.scrapy.org/en/latest/topics/item-pipeline.html

4、Dowloader Middeware

下载中间件的用途

    1、在process——request内，自定义下载，不用scrapy的下载

    2、对请求进行二次加工，比如

        设置请求头

        设置cookie

        添加代理

            scrapy自带的代理组件：

                from scrapy.downloadermiddlewares.httpproxy import HttpProxyMiddleware

                from urllib.request import getproxies

class DownMiddleware1(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

下载器中间件

#1、与middlewares.py同级目录下新建proxy_handle.py

import requests

def get_proxy():

    return requests.get("http://127.0.0.1:5010/get/").text

def delete_proxy(proxy):

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

#2、middlewares.py

from Amazon.proxy_handle import get_proxy,delete_proxy

class DownMiddleware1(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

        """

        proxy="http://" + get_proxy()

        request.meta['download_timeout']=20

        request.meta["proxy"] = proxy

        print('为%s 添加代理%s ' % (request.url, proxy),end='')

        print('元数据为',request.meta)

    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('返回状态吗',response.status)

        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将会被重新调用下载

        """

        print('代理%s，访问%s出现异常:%s' %(request.meta['proxy'],request.url,exception))

        import time

        time.sleep(5)

        delete_proxy(request.meta['proxy'].split("//")[-1])

        request.meta['proxy']='http://'+get_proxy()

        return request

配置代理

5、Spider Middleware

class SpiderMiddleware(object):

    def process_spider_input(self,response, spider):

        """

        下载完成，执行，然后交给parse处理

        :param response:

        :param spider:

        :return:

        """

        pass

    def process_spider_output(self,response, result, spider):

        """

        spider处理完成，返回时调用

        :param response:

        :param result:

        :param spider:

        :return: 必须返回包含 Request 或 Item 对象的可迭代对象(iterable)

        """

        return result

    def process_spider_exception(self,response, exception, spider):

        """

        异常调用

        :param response:

        :param exception:

        :param spider:

        :return: None,继续交给后续中间件处理异常；含 Response 或 Item 的可迭代对象(iterable)，交给调度器或pipeline

        """

        return None

    def process_start_requests(self,start_requests, spider):

        """

        爬虫启动时调用

        :param start_requests:

        :param spider:

        :return: 包含 Request 对象的可迭代对象

        """

        return start_requests

爬虫中间件

6、自定义扩展

自定义扩展（与django的信号类似）

    1、django的信号是django是预留的扩展，信号一旦被触发，相应的功能就会执行

    2、scrapy自定义扩展的好处是可以在任意我们想要的位置添加功能，而其他组件中提供的功能只能在规定的位置执行

#1、在与settings同级目录下新建一个文件，文件名可以为extentions.py,内容如下

from scrapy import signals

class MyExtension(object):

    def __init__(self, value):

        self.value = value

    @classmethod

    def from_crawler(cls, crawler):

        val = crawler.settings.getint('MMMM')

        obj = cls(val)

        crawler.signals.connect(obj.spider_opened, signal=signals.spider_opened)

        crawler.signals.connect(obj.spider_closed, signal=signals.spider_closed)

        return obj

    def spider_opened(self, spider):

        print('=============>open')

    def spider_closed(self, spider):

        print('=============>close')

#2、配置生效

EXTENSIONS = {

    "Amazon.extentions.MyExtension":200

}

7、settings.py

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

# Scrapy settings for step8_king project

#

# For simplicity, this file contains only settings considered important or

# commonly used. You can find more settings consulting the documentation:

#

#     http://doc.scrapy.org/en/latest/topics/settings.html

#     http://scrapy.readthedocs.org/en/latest/topics/downloader-middleware.html

#     http://scrapy.readthedocs.org/en/latest/topics/spider-middleware.html

# 1. 爬虫名称

BOT_NAME = 'step8_king'

# 2. 爬虫应用路径

SPIDER_MODULES = ['step8_king.spiders']

NEWSPIDER_MODULE = 'step8_king.spiders'

# Crawl responsibly by identifying yourself (and your website) on the user-agent

# 3. 客户端 user-agent请求头

# USER_AGENT = 'step8_king (+http://www.yourdomain.com)'

# Obey robots.txt rules

# 4. 禁止爬虫配置

# ROBOTSTXT_OBEY = False

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

# 5. 并发请求数

# CONCURRENT_REQUESTS = 4

# Configure a delay for requests for the same website (default: 0)

# See http://scrapy.readthedocs.org/en/latest/topics/settings.html#download-delay

# See also autothrottle settings and docs

# 6. 延迟下载秒数

# DOWNLOAD_DELAY = 2

# The download delay setting will honor only one of:

# 7. 单域名访问并发数，并且延迟下次秒数也应用在每个域名

# CONCURRENT_REQUESTS_PER_DOMAIN = 2

# 单IP访问并发数，如果有值则忽略：CONCURRENT_REQUESTS_PER_DOMAIN，并且延迟下次秒数也应用在每个IP

# CONCURRENT_REQUESTS_PER_IP = 3

# Disable cookies (enabled by default)

# 8. 是否支持cookie，cookiejar进行操作cookie

# COOKIES_ENABLED = True

# COOKIES_DEBUG = True

# Disable Telnet Console (enabled by default)

# 9. Telnet用于查看当前爬虫的信息，操作爬虫等...

#    使用telnet ip port ，然后通过命令操作

# TELNETCONSOLE_ENABLED = True

# TELNETCONSOLE_HOST = '127.0.0.1'

# TELNETCONSOLE_PORT = [6023,]

# 10. 默认请求头

# 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',

# }

# Configure item pipelines

# See http://scrapy.readthedocs.org/en/latest/topics/item-pipeline.html

# 11. 定义pipeline处理请求

# ITEM_PIPELINES = {

#    'step8_king.pipelines.JsonPipeline': 700,

#    'step8_king.pipelines.FilePipeline': 500,

# }

# 12. 自定义扩展，基于信号进行调用

# Enable or disable extensions

# See http://scrapy.readthedocs.org/en/latest/topics/extensions.html

# EXTENSIONS = {

#     # 'step8_king.extensions.MyExtension': 500,

# }

# 13. 爬虫允许的最大深度，可以通过meta查看当前深度；0表示无深度

# DEPTH_LIMIT = 3

# 14. 爬取时，0表示深度优先Lifo(默认)；1表示广度优先FiFo

# 后进先出，深度优先

# DEPTH_PRIORITY = 0

# SCHEDULER_DISK_QUEUE = 'scrapy.squeue.PickleLifoDiskQueue'

# SCHEDULER_MEMORY_QUEUE = 'scrapy.squeue.LifoMemoryQueue'

# 先进先出，广度优先

# DEPTH_PRIORITY = 1

# SCHEDULER_DISK_QUEUE = 'scrapy.squeue.PickleFifoDiskQueue'

# SCHEDULER_MEMORY_QUEUE = 'scrapy.squeue.FifoMemoryQueue'

# 15. 调度器队列

# SCHEDULER = 'scrapy.core.scheduler.Scheduler'

# from scrapy.core.scheduler import Scheduler

# 16. 访问URL去重

# DUPEFILTER_CLASS = 'step8_king.duplication.RepeatUrl'

# Enable and configure the AutoThrottle extension (disabled by default)

# See http://doc.scrapy.org/en/latest/topics/autothrottle.html

"""

17. 自动限速算法

    from scrapy.contrib.throttle import AutoThrottle

    自动限速设置

    1. 获取最小延迟 DOWNLOAD_DELAY

    2. 获取最大延迟 AUTOTHROTTLE_MAX_DELAY

    3. 设置初始下载延迟 AUTOTHROTTLE_START_DELAY

    4. 当请求下载完成后，获取其"连接"时间 latency，即：请求连接到接受到响应头之间的时间

    5. 用于计算的... AUTOTHROTTLE_TARGET_CONCURRENCY

    target_delay = latency / self.target_concurrency

    new_delay = (slot.delay + target_delay) / 2.0 # 表示上一次的延迟时间

    new_delay = max(target_delay, new_delay)

    new_delay = min(max(self.mindelay, new_delay), self.maxdelay)

    slot.delay = new_delay

"""

# 开始自动限速

# 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 = 10

# 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 = True

# Enable and configure HTTP caching (disabled by default)

# See http://scrapy.readthedocs.org/en/latest/topics/downloader-middleware.html#httpcache-middleware-settings

"""

18. 启用缓存

    目的用于将已经发送的请求或相应缓存下来，以便以后使用

    from scrapy.downloadermiddlewares.httpcache import HttpCacheMiddleware

    from scrapy.extensions.httpcache import DummyPolicy

    from scrapy.extensions.httpcache import FilesystemCacheStorage

"""

# 是否启用缓存策略

# HTTPCACHE_ENABLED = True

# 缓存策略：所有请求均缓存，下次在请求直接访问原来的缓存即可

# HTTPCACHE_POLICY = "scrapy.extensions.httpcache.DummyPolicy"

# 缓存策略：根据Http响应头：Cache-Control、Last-Modified 等进行缓存的策略

# HTTPCACHE_POLICY = "scrapy.extensions.httpcache.RFC2616Policy"

# 缓存超时时间

# HTTPCACHE_EXPIRATION_SECS = 0

# 缓存保存路径

# HTTPCACHE_DIR = 'httpcache'

# 缓存忽略的Http状态码

# HTTPCACHE_IGNORE_HTTP_CODES = []

# 缓存存储的插件

# HTTPCACHE_STORAGE = 'scrapy.extensions.httpcache.FilesystemCacheStorage'

"""

19. 代理，需要在环境变量中设置

    from scrapy.contrib.downloadermiddleware.httpproxy import HttpProxyMiddleware

    方式一：使用默认

        os.environ

        {

            http_proxy:http://root:woshiniba@192.168.11.11:9999/

            https_proxy:http://192.168.11.11:9999/

        }

    方式二：使用自定义下载中间件

    def to_bytes(text, encoding=None, errors='strict'):

        if isinstance(text, bytes):

            return text

        if not isinstance(text, six.string_types):

            raise TypeError('to_bytes must receive a unicode, str or bytes '

                            'object, got %s' % type(text).__name__)

        if encoding is None:

            encoding = 'utf-8'

        return text.encode(encoding, errors)

    class ProxyMiddleware(object):

        def process_request(self, request, spider):

            PROXIES = [

                {'ip_port': '111.11.228.75:80', 'user_pass': ''},

                {'ip_port': '120.198.243.22:80', 'user_pass': ''},

                {'ip_port': '111.8.60.9:8123', 'user_pass': ''},

                {'ip_port': '101.71.27.120:80', 'user_pass': ''},

                {'ip_port': '122.96.59.104:80', 'user_pass': ''},

                {'ip_port': '122.224.249.122:8088', 'user_pass': ''},

            ]

            proxy = random.choice(PROXIES)

            if proxy['user_pass'] is not None:

                request.meta['proxy'] = to_bytes（"http://%s" % proxy['ip_port']）

                encoded_user_pass = base64.encodestring(to_bytes(proxy['user_pass']))

                request.headers['Proxy-Authorization'] = to_bytes('Basic ' + encoded_user_pass)

                print "**************ProxyMiddleware have pass************" + proxy['ip_port']

            else:

                print "**************ProxyMiddleware no pass************" + proxy['ip_port']

                request.meta['proxy'] = to_bytes("http://%s" % proxy['ip_port'])

    DOWNLOADER_MIDDLEWARES = {

       'step8_king.middlewares.ProxyMiddleware': 500,

    }

"""

"""

20. Https访问

    Https访问时有两种情况：

    1. 要爬取网站使用的可信任证书(默认支持)

        DOWNLOADER_HTTPCLIENTFACTORY = "scrapy.core.downloader.webclient.ScrapyHTTPClientFactory"

        DOWNLOADER_CLIENTCONTEXTFACTORY = "scrapy.core.downloader.contextfactory.ScrapyClientContextFactory"

    2. 要爬取网站使用的自定义证书

        DOWNLOADER_HTTPCLIENTFACTORY = "scrapy.core.downloader.webclient.ScrapyHTTPClientFactory"

        DOWNLOADER_CLIENTCONTEXTFACTORY = "step8_king.https.MySSLFactory"

        # https.py

        from scrapy.core.downloader.contextfactory import ScrapyClientContextFactory

        from twisted.internet.ssl import (optionsForClientTLS, CertificateOptions, PrivateCertificate)

        class MySSLFactory(ScrapyClientContextFactory):

            def getCertificateOptions(self):

                from OpenSSL import crypto

                v1 = crypto.load_privatekey(crypto.FILETYPE_PEM, open('/Users/wupeiqi/client.key.unsecure', mode='r').read())

                v2 = crypto.load_certificate(crypto.FILETYPE_PEM, open('/Users/wupeiqi/client.pem', mode='r').read())

                return CertificateOptions(

                    privateKey=v1,  # pKey对象

                    certificate=v2,  # X509对象

                    verify=False,

                    method=getattr(self, 'method', getattr(self, '_ssl_method', None))

                )

    其他：

        相关类

            scrapy.core.downloader.handlers.http.HttpDownloadHandler

            scrapy.core.downloader.webclient.ScrapyHTTPClientFactory

            scrapy.core.downloader.contextfactory.ScrapyClientContextFactory

        相关配置

            DOWNLOADER_HTTPCLIENTFACTORY

            DOWNLOADER_CLIENTCONTEXTFACTORY

"""

"""

21. 爬虫中间件

    class SpiderMiddleware(object):

        def process_spider_input(self,response, spider):

            '''

            下载完成，执行，然后交给parse处理

            :param response:

            :param spider:

            :return:

            '''

            pass

        def process_spider_output(self,response, result, spider):

            '''

            spider处理完成，返回时调用

            :param response:

            :param result:

            :param spider:

            :return: 必须返回包含 Request 或 Item 对象的可迭代对象(iterable)

            '''

            return result

        def process_spider_exception(self,response, exception, spider):

            '''

            异常调用

            :param response:

            :param exception:

            :param spider:

            :return: None,继续交给后续中间件处理异常；含 Response 或 Item 的可迭代对象(iterable)，交给调度器或pipeline

            '''

            return None

        def process_start_requests(self,start_requests, spider):

            '''

            爬虫启动时调用

            :param start_requests:

            :param spider:

            :return: 包含 Request 对象的可迭代对象

            '''

            return start_requests

    内置爬虫中间件：

        'scrapy.contrib.spidermiddleware.httperror.HttpErrorMiddleware': 50,

        'scrapy.contrib.spidermiddleware.offsite.OffsiteMiddleware': 500,

        'scrapy.contrib.spidermiddleware.referer.RefererMiddleware': 700,

        'scrapy.contrib.spidermiddleware.urllength.UrlLengthMiddleware': 800,

        'scrapy.contrib.spidermiddleware.depth.DepthMiddleware': 900,

"""

# from scrapy.contrib.spidermiddleware.referer import RefererMiddleware

# Enable or disable spider middlewares

# See http://scrapy.readthedocs.org/en/latest/topics/spider-middleware.html

SPIDER_MIDDLEWARES = {

   # 'step8_king.middlewares.SpiderMiddleware': 543,

}

"""

22. 下载中间件

    class DownMiddleware1(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

    默认下载中间件

    {

        'scrapy.contrib.downloadermiddleware.robotstxt.RobotsTxtMiddleware': 100,

        'scrapy.contrib.downloadermiddleware.httpauth.HttpAuthMiddleware': 300,

        'scrapy.contrib.downloadermiddleware.downloadtimeout.DownloadTimeoutMiddleware': 350,

        'scrapy.contrib.downloadermiddleware.useragent.UserAgentMiddleware': 400,

        'scrapy.contrib.downloadermiddleware.retry.RetryMiddleware': 500,

        'scrapy.contrib.downloadermiddleware.defaultheaders.DefaultHeadersMiddleware': 550,

        'scrapy.contrib.downloadermiddleware.redirect.MetaRefreshMiddleware': 580,

        'scrapy.contrib.downloadermiddleware.httpcompression.HttpCompressionMiddleware': 590,

        'scrapy.contrib.downloadermiddleware.redirect.RedirectMiddleware': 600,

        'scrapy.contrib.downloadermiddleware.cookies.CookiesMiddleware': 700,

        'scrapy.contrib.downloadermiddleware.httpproxy.HttpProxyMiddleware': 750,

        'scrapy.contrib.downloadermiddleware.chunked.ChunkedTransferMiddleware': 830,

        'scrapy.contrib.downloadermiddleware.stats.DownloaderStats': 850,

        'scrapy.contrib.downloadermiddleware.httpcache.HttpCacheMiddleware': 900,

    }

"""

# from scrapy.contrib.downloadermiddleware.httpauth import HttpAuthMiddleware

# Enable or disable downloader middlewares

# See http://scrapy.readthedocs.org/en/latest/topics/downloader-middleware.html

# DOWNLOADER_MIDDLEWARES = {

#    'step8_king.middlewares.DownMiddleware1': 100,

#    'step8_king.middlewares.DownMiddleware2': 500,

# }

settings.py

六、爬取亚马逊商品信息

链接：https://pan.baidu.com/s/1jJWdMD4

97、爬虫框架scrapy的更多相关文章

第三篇：爬虫框架 - Scrapy
前言 Python提供了一个比较实用的爬虫框架 - Scrapy.在这个框架下只要定制好指定的几个模块,就能实现一个爬虫. 本文将讲解Scrapy框架的基本体系结构,以及使用这个框架定制爬虫的具体步骤 ...
教你分分钟学会用python爬虫框架Scrapy爬取心目中的女神
本博文将带领你从入门到精通爬虫框架Scrapy,最终具备爬取任何网页的数据的能力.本文以校花网为例进行爬取,校花网:http://www.xiaohuar.com/,让你体验爬取校花的成就感. Scr ...
【转载】教你分分钟学会用python爬虫框架Scrapy爬取心目中的女神
原文:教你分分钟学会用python爬虫框架Scrapy爬取心目中的女神本博文将带领你从入门到精通爬虫框架Scrapy,最终具备爬取任何网页的数据的能力.本文以校花网为例进行爬取,校花网:http:/ ...
爬虫框架Scrapy
前面十章爬虫笔记陆陆续续记录了一些简单的Python爬虫知识, 用来解决简单的贴吧下载,绩点运算自然不在话下. 不过要想批量下载大量的内容,比如知乎的所有的问答,那便显得游刃不有余了点. 于是乎,爬虫 ...
网络爬虫框架Scrapy简介
作者: 黄进(QQ:7149101) 一. 网络爬虫网络爬虫(又被称为网页蜘蛛,网络机器人),是一种按照一定的规则,自动地抓取万维网信息的程序或者脚本:它是一个自动提取网页的程序,它为搜索引擎从万维 ...
Linux 安装python爬虫框架 scrapy
Linux 安装python爬虫框架 scrapy http://scrapy.org/ Scrapy是python最好用的一个爬虫框架.要求: python2.7.x. 1. Ubuntu14.04 ...
Python爬虫框架Scrapy实例（三）数据存储到MongoDB
Python爬虫框架Scrapy实例(三)数据存储到MongoDB任务目标:爬取豆瓣电影top250,将数据存储到MongoDB中. items.py文件复制代码# -*- coding: utf-8 ...
《Python3网络爬虫开发实战》PDF+源代码+《精通Python爬虫框架Scrapy》中英文PDF源代码
下载:https://pan.baidu.com/s/1oejHek3Vmu0ZYvp4w9ZLsw <Python 3网络爬虫开发实战>中文PDF+源代码下载:https://pan. ...
Python爬虫框架Scrapy教程(1)—入门
最近实验室的项目中有一个需求是这样的,需要爬取若干个(数目不小)网站发布的文章元数据(标题.时间.正文等).问题是这些网站都很老旧和小众,当然也不可能遵守 Microdata 这类标准.这时候所有网页 ...
怎么在32位windows系统上搭建爬虫框架scrapy？
禁止转载: 自学python,然后搭建爬虫框架scrapy.费了我一上午的心血.终于搭建成功,以防以后忘记搭建流程,特此撰写此贴,开写 ******************************** ...

随机推荐

IT服务(运维)管理实施的几个要点--第一章 IT服务质量的标准
子曰"干的最好就是个60分,稍有纰漏就是不及格" 谈一个事情,最先要谈的就是统一标准,又或者这个标准已经约定俗成,广泛认可,所以就可以略过.对于IT服务质量来说,确实有一个统一的标 ...
[知了堂学习笔记]_用JS制作《飞机大作战》游戏_第4讲（创建敌方飞机、敌方飞机发射子弹、玩家子弹击中敌方小飞机，小飞机死亡）
一.创建敌方飞机 1.思考创建思路: 创建敌方飞机思路与创建玩家飞机思路一样: (1)思考敌方飞机具备什么属性: 敌方飞机的图片.坐标.飞行速度.状态(是否被击中) 设置小飞机被击中时消失时间.飞机可 ...
type 命令详解
type 作用: 用来显示指定命令的类型,判断出命令是内部命令还是外部命令. 命令类型: alias: 别名 keyword:关键字, shell 保留字 function:函数, shell函数 ...
Linux发行版 CentOS6.5下的分区操作
本文地址http://comexchan.cnblogs.com/ ,尊重知识产权,转载请注明出处,谢谢! 查询磁盘信息并作分区规划执行下述命令查询磁盘信息: fdisk -l 可知.数据盘大小50 ...
uEditor富文本编辑器
在配合vue和webpack使用时,在严格模式下注意会报错,需要修改配置. 我采用的方式:----不建议全部取消严格模式,因为一些插件必须要再严格模式才能运行的对UEditor的严格模式报错文件,取 ...
ntopng 推送solr
1.修改代码在且不说 2.修改完之后先卸载原先的ntopng 使用 whereis ntopng 找到安装目录,然后删除 /usr/local/bin/ntopng /usr/local/share/ ...
吓尿了，mac下bash出了问题
由于个人的脑残行为,使用homebrew安装bash后,使用chsh命令将其改成brew安装的特定版本的bash,结果上次brew更新bash之后,就彻底用不了shell了... 无奈只能添加新的管理 ...
SQL基础学习_03_数据更新
数据的插入 1. 基本INSERT语句 INSERT的基本语法为: INSERT INTO <表名> (列1, 列2, 列3, -) VALUES (值1, 值2, 值 ...
前端学习_04_font-awesome字体图标
使用font-awesome字体图标库 font-awesome是一个比较大的矢量图标库,包含大部分IT类公司logo和常用的一些小图标,通过使用font-awesome提供的css样式集,可以在网页 ...
RAID常用级别的比较
[转]RAID常用级别的比较特点硬盘及容量性能及安全典型应用 raid 0 用于平行存储,即条带.其原理是把连续的数据分成几份,然后分散存储到阵列中的各个硬盘上.任何一个磁盘故障,都将导致数据 ...

97、爬虫框架scrapy

97、爬虫框架scrapy的更多相关文章

随机推荐

热门专题