大家好，我是四毛，下面是我的个人公众号，欢迎关注。有问题的可以私信我，看到就会回复。

更新 2018 年 08 月 03 日 14:39:32

其实可以利用 scrapy 的扩展展示更多的数据，立个 flag，后面更新上来

好，开始今天的文章。 今天主要是来说一下怎么可视化来监控你的爬虫的状态。 相信大家在跑爬虫的过程中，也会好奇自己养的爬虫一分钟可以爬多少页面，多大的数据量，当然查询的方式多种多样。今天我来讲一种可视化的方法。

关于爬虫数据在 mongodb 里的版本我写了一个可以热更新配置的版本，即添加了新的爬虫配置以后，不用重启程序，即可获取刚刚添加的爬虫的状态数据，大家可以通过关注我的公众号以后， 回复“可视化”即可获取脚本地址。

1.成品图

这个是监控服务器网速的最后成果，显示的是下载与上传的网速，单位为 M。爬虫的原理都是一样的，只不过将数据存到 InfluxDB 的方式不一样而已， 如下图。

可以实现对爬虫数量，增量，大小，大小增量的实时监控。

2. 环境

• InfluxDb，是目前比较流行的时间序列数据库；
• Grafana，一个可视化面板（Dashboard），有着非常漂亮的图表和布局展示，功能齐全的度量仪表盘和图形编辑器，支持 Graphite、zabbix、InfluxDB、Prometheus 和 OpenTSDB 作为数据源
• Ubuntu

• influxdb（pip install influxdb)

• Python 2.7

3. 原理

获取要展示的数据，包含当前的时间数据，存到 InfluxDb 里面，然后再到 Grafana 里面进行相应的配置即可展示；

4. 安装

4.1 Grafana 安装

官方安装指导 安装好以后，打开本地的 3000 端口，即可进入管理界面，用户名与密码都是admin。

4.2 InfulxDb 安装

这个安装就网上自己找吧，有很多的配置我都没有配置，就不在这里误人子弟了。

5. InfluxDb 简单操作

碰到了数据库，肯定要把增删改查学会了啊， 和 sql 几乎一样，只有一丝丝的区别，具体操作，大家可以参考官方的文档。

• influx 进入命令行
• CREATE DATABASE test 创建数据库
• show databases 查看数据库
• use test 使用数据库
• show series 看表
• select * from table_test 选择数据
• DROP MEASUREMENT table_test 删表

6. 存数据

InfluxDb 数据库的数据有一定的格式，因为我都是利用 python 库进行相关操作，所以下面将在 python 中的格式展示一下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

json_body = [
    {
        "measurement": "crawler",
        "time": current_time,
        "tags": {
            "spider_name": collection_name
        },
        "fields": {
            "count": current_count,
            "increase_count": increase_amount,
            "size": co_size,
            "increase_size": increase_co_size

        }
    }
]

其中:

• measurement, 表名
• time，时间
• tags，标签
• fields，字段

可以看到，就是个列表里面，嵌套了一个字典。其中，对于时间字段，有特殊要求，可以参考这里， 下面是 python 实现方法：

1
2

from datetime import datetime
current_time = datetime.utcnow().strftime('%Y-%m-%dT%H:%M:%SZ')

所以，到这里，如何将爬虫的相关属性存进去呢？以 MongoDB 为例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

mongodb_client = pymongo.MongoClient(uri)
    for db_name, collection_name in dbs_and_cos.iteritems():
        # 数据库操作
        db = mongodb_client[db_name]
        co = db[collection_name]
        # 集合大小
        co_size = round(float(db.command("collstats", collection_name).get('size')) / 1024 / 1024, 2)
        # 集合内数据条数
        current_count = co.count()

        # 初始化，当程序刚执行时，初始量就设置为第一次执行时获取的数据
        init_count = _count_dict.get(collection_name, current_count)
        # 初始化，当程序刚执行时，初始量就设置为第一次执行时获取的数据大小
        init_size = _size_dict.get(collection_name, co_size)

        # 条数增长量
        increase_amount = current_count - init_count
        # 集合大小增长量
        increase_co_size = co_size - init_size

        current_time = datetime.utcnow().strftime('%Y-%m-%dT%H:%M:%SZ')

        # 赋值
        _size_dict[collection_name] = co_size
        _count_dict[collection_name] = current_count

        json_body = [
            {
                "measurement": "crawler",
                "time": current_time,
                "tags": {
                    "spider_name": collection_name
                },
                "fields": {
                    "count": current_count,
                    "increase_count": increase_amount,
                    "size": co_size,
                    "increase_size": increase_co_size

                }
            }
        ]
        print json_body
        client.write_points(json_body)

完整代码，关注上面的公众号，发送“”可视化“”即可获取。 那么现在我们已经往数据里存了数据了，那么接下来要做的就是把存的数据展示出来。

7.展示数据

7.1 配置数据源

以 admin 登录到 Grafana 的后台后，我们首先需要配置一下数据源。点击左边栏的最下面的按钮，然后点击 DATA SOURCES，这样就可以进入下面的页面： 点击 ADD DATA SOURCE，进行配置即可，如下图： 其中，name 自行设定；Type 选择 InfluxDB；url 为默认的 http://localhost:8086， 其他的因为我前面没有进行配置，所以默认的即可。然后在 InfluxDB Details 里的填入 Database 名，最后点击测试，如果没有报错的话，则可以进入下一步的展示数据了；

7.2 展示数据

点击左边栏的+号，然后点击 GRAPH 接着点击下图中的 edit 进入编辑页面： 从上图中可以发现：

• 中间板块是最后的数据展示
• 下面是数据的设置项
• 右上角是展示时间的设置板块，在这里可以选择要展示多久的数据

7.2.1 配置数据

1. 在 Data Source 中选择刚刚在配置数据源的时候配置的 NAME 字段，而不是 database 名。
2. 接着在下面选择要展示的数据。看着就很熟悉是不是，完全是 sql 语句的可视化。同时，当我们的数据放到相关的字段上的时候，双击，就会把可以选择的项展示出来了，我们要做的就是直接选择即可；
3. 设置右上角的时间，则可以让数据实时进行更新与展示

因为下面的配置实质就是 sql 查询语句，所以大家按照自己的需求，进行选择配置即可，当配置完以后，就可以在中间的面板里面看到数据了。

8. 总结

到这里，本篇文章就结束了。其中，对于 Grafana 的操作我没有介绍的很详细，因为本篇主要讲的是怎么利用这几个工具完成我们的任务。 同时，里面的功能确实很多，还有可以安装的插件。我自己目前还是仅仅对于用到的部分比较了解，所以大家可以查询官方的或者别的教程资料来对 Grafana 进行更深入的了解，制作出更加好看的可视化作品来。 最后，关注公众号，回复“可视化” 即可获取本文代码哦

什么是 Elasticsearch

想查数据就免不了搜索，搜索就离不开搜索引擎，百度、谷歌都是一个非常庞大复杂的搜索引擎，他们几乎索引了互联网上开放的所有网页和数据。然而对于我们自己的业务数据来说，肯定就没必要用这么复杂的技术了，如果我们想实现自己的搜索引擎，方便存储和检索，Elasticsearch 就是不二选择，它是一个全文搜索引擎，可以快速地储存、搜索和分析海量数据。

为什么要用 Elasticsearch

Elasticsearch 是一个开源的搜索引擎，建立在一个全文搜索引擎库 Apache Lucene™ 基础之上。 那 Lucene 又是什么？Lucene 可能是目前存在的，不论开源还是私有的，拥有最先进，高性能和全功能搜索引擎功能的库，但也仅仅只是一个库。要用上 Lucene，我们需要编写 Java 并引用 Lucene 包才可以，而且我们需要对信息检索有一定程度的理解才能明白 Lucene 是怎么工作的，反正用起来没那么简单。 那么为了解决这个问题，Elasticsearch 就诞生了。Elasticsearch 也是使用 Java 编写的，它的内部使用 Lucene 做索引与搜索，但是它的目标是使全文检索变得简单，相当于 Lucene 的一层封装，它提供了一套简单一致的 RESTful API 来帮助我们实现存储和检索。 所以 Elasticsearch 仅仅就是一个简易版的 Lucene 封装吗？那就大错特错了，Elasticsearch 不仅仅是 Lucene，并且也不仅仅只是一个全文搜索引擎。 它可以被下面这样准确的形容：

• 一个分布式的实时文档存储，每个字段可以被索引与搜索
• 一个分布式实时分析搜索引擎
• 能胜任上百个服务节点的扩展，并支持 PB 级别的结构化或者非结构化数据

总之，是一个相当牛逼的搜索引擎，维基百科、Stack Overflow、GitHub 都纷纷采用它来做搜索。

Elasticsearch 的安装

我们可以到 Elasticsearch 的官方网站下载 Elasticsearch：https://www.elastic.co/downloads/elasticsearch，同时官网也附有安装说明。 首先把安装包下载下来并解压，然后运行 bin/elasticsearch（Mac 或 Linux）或者 bin\elasticsearch.bat (Windows) 即可启动 Elasticsearch 了。 我使用的是 Mac，Mac 下个人推荐使用 Homebrew 安装：

1

brew install elasticsearch

Elasticsearch 默认会在 9200 端口上运行，我们打开浏览器访问 http://localhost:9200/ 就可以看到类似内容：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

{
  "name" : "atntrTf",
  "cluster_name" : "elasticsearch",
  "cluster_uuid" : "e64hkjGtTp6_G2h1Xxdv5g",
  "version" : {
    "number": "6.2.4",
    "build_hash": "ccec39f",
    "build_date": "2018-04-12T20:37:28.497551Z",
    "build_snapshot": false,
    "lucene_version": "7.2.1",
    "minimum_wire_compatibility_version": "5.6.0",
    "minimum_index_compatibility_version": "5.0.0"
  },
  "tagline" : "You Know, for Search"
}

如果看到这个内容，就说明 Elasticsearch 安装并启动成功了，这里显示我的 Elasticsearch 版本是 6.2.4 版本，版本很重要，以后安装一些插件都要做到版本对应才可以。 接下来我们来了解一下 Elasticsearch 的基本概念以及和 Python 的对接。

Elasticsearch 相关概念

在 Elasticsearch 中有几个基本的概念，如节点、索引、文档等等，下面来分别说明一下，理解了这些概念对熟悉 Elasticsearch 是非常有帮助的。

Node 和 Cluster

Elasticsearch 本质上是一个分布式数据库，允许多台服务器协同工作，每台服务器可以运行多个 Elasticsearch 实例。 单个 Elasticsearch 实例称为一个节点（Node）。一组节点构成一个集群（Cluster）。

Index

Elasticsearch 会索引所有字段，经过处理后写入一个反向索引（Inverted Index）。查找数据的时候，直接查找该索引。 所以，Elasticsearch 数据管理的顶层单位就叫做 Index（索引），其实就相当于 MySQL、MongoDB 等里面的数据库的概念。另外值得注意的是，每个 Index （即数据库）的名字必须是小写。

Document

Index 里面单条的记录称为 Document（文档）。许多条 Document 构成了一个 Index。 Document 使用 JSON 格式表示，下面是一个例子。 同一个 Index 里面的 Document，不要求有相同的结构（scheme），但是最好保持相同，这样有利于提高搜索效率。

Type

Document 可以分组，比如 weather 这个 Index 里面，可以按城市分组（北京和上海），也可以按气候分组（晴天和雨天）。这种分组就叫做 Type，它是虚拟的逻辑分组，用来过滤 Document，类似 MySQL 中的数据表，MongoDB 中的 Collection。 不同的 Type 应该有相似的结构（Schema），举例来说，id 字段不能在这个组是字符串，在另一个组是数值。这是与关系型数据库的表的一个区别。性质完全不同的数据（比如 products 和 logs）应该存成两个 Index，而不是一个 Index 里面的两个 Type（虽然可以做到）。 根据规划，Elastic 6.x 版只允许每个 Index 包含一个 Type，7.x 版将会彻底移除 Type。

Fields

即字段，每个 Document 都类似一个 JSON 结构，它包含了许多字段，每个字段都有其对应的值，多个字段组成了一个 Document，其实就可以类比 MySQL 数据表中的字段。 在 Elasticsearch 中，文档归属于一种类型（Type），而这些类型存在于索引（Index）中，我们可以画一些简单的对比图来类比传统关系型数据库：

1
2

Relational DB -> Databases -> Tables -> Rows -> Columns
Elasticsearch -> Indices   -> Types  -> Documents -> Fields

以上就是 Elasticsearch 里面的一些基本概念，通过和关系性数据库的对比更加有助于理解。

Python 对接 Elasticsearch

Elasticsearch 实际上提供了一系列 Restful API 来进行存取和查询操作，我们可以使用 curl 等命令来进行操作，但毕竟命令行模式没那么方便，所以这里我们就直接介绍利用 Python 来对接 Elasticsearch 的相关方法。 Python 中对接 Elasticsearch 使用的就是一个同名的库，安装方式非常简单：

1

pip3 install elasticsearch

官方文档是：https://elasticsearch-py.readthedocs.io/，所有的用法都可以在里面查到，文章后面的内容也是基于官方文档来的。

创建 Index

我们先来看下怎样创建一个索引（Index），这里我们创建一个名为 news 的索引：

1
2
3
4
5

from elasticsearch import Elasticsearch

es = Elasticsearch()
result = es.indices.create(index='news', ignore=400)
print(result)

如果创建成功，会返回如下结果：

1

{'acknowledged': True, 'shards_acknowledged': True, 'index': 'news'}

返回结果是 JSON 格式，其中的 acknowledged 字段表示创建操作执行成功。 但这时如果我们再把代码执行一次的话，就会返回如下结果：

1

{'error': {'root_cause': [{'type': 'resource_already_exists_exception', 'reason': 'index [news/QM6yz2W8QE-bflKhc5oThw] already exists', 'index_uuid': 'QM6yz2W8QE-bflKhc5oThw', 'index': 'news'}], 'type': 'resource_already_exists_exception', 'reason': 'index [news/QM6yz2W8QE-bflKhc5oThw] already exists', 'index_uuid': 'QM6yz2W8QE-bflKhc5oThw', 'index': 'news'}, 'status': 400}

它提示创建失败，status 状态码是 400，错误原因是 Index 已经存在了。 注意这里我们的代码里面使用了 ignore 参数为 400，这说明如果返回结果是 400 的话，就忽略这个错误不会报错，程序不会执行抛出异常。 假如我们不加 ignore 这个参数的话：

1
2
3

es = Elasticsearch()
result = es.indices.create(index='news')
print(result)

再次执行就会报错了：

1
2

raise HTTP_EXCEPTIONS.get(status_code, TransportError)(status_code, error_message, additional_info)
elasticsearch.exceptions.RequestError: TransportError(400, 'resource_already_exists_exception', 'index [news/QM6yz2W8QE-bflKhc5oThw] already exists')

这样程序的执行就会出现问题，所以说，我们需要善用 ignore 参数，把一些意外情况排除，这样可以保证程序的正常执行而不会中断。

删除 Index

删除 Index 也是类似的，代码如下：

1
2
3
4
5

from elasticsearch import Elasticsearch

es = Elasticsearch()
result = es.indices.delete(index='news', ignore=[400, 404])
print(result)

这里也是使用了 ignore 参数，来忽略 Index 不存在而删除失败导致程序中断的问题。 如果删除成功，会输出如下结果：

1

{'acknowledged': True}

如果 Index 已经被删除，再执行删除则会输出如下结果：

1

{'error': {'root_cause': [{'type': 'index_not_found_exception', 'reason': 'no such index', 'resource.type': 'index_or_alias', 'resource.id': 'news', 'index_uuid': '_na_', 'index': 'news'}], 'type': 'index_not_found_exception', 'reason': 'no such index', 'resource.type': 'index_or_alias', 'resource.id': 'news', 'index_uuid': '_na_', 'index': 'news'}, 'status': 404}

这个结果表明当前 Index 不存在，删除失败，返回的结果同样是 JSON，状态码是 400，但是由于我们添加了 ignore 参数，忽略了 400 状态码，因此程序正常执行输出 JSON 结果，而不是抛出异常。

插入数据

Elasticsearch 就像 MongoDB 一样，在插入数据的时候可以直接插入结构化字典数据，插入数据可以调用 create() 方法，例如这里我们插入一条新闻数据：

1
2
3
4
5
6
7
8

from elasticsearch import Elasticsearch

es = Elasticsearch()
es.indices.create(index='news', ignore=400)

data = {'title': '美国留给伊拉克的是个烂摊子吗', 'url': 'http://view.news.qq.com/zt2011/usa_iraq/index.htm'}
result = es.create(index='news', doc_type='politics', id=1, body=data)
print(result)

这里我们首先声明了一条新闻数据，包括标题和链接，然后通过调用 create() 方法插入了这条数据，在调用 create() 方法时，我们传入了四个参数，index 参数代表了索引名称，doc_type 代表了文档类型，body 则代表了文档具体内容，id 则是数据的唯一标识 ID。 运行结果如下：

1

{'_index': 'news', '_type': 'politics', '_id': '1', '_version': 1, 'result': 'created', '_shards': {'total': 2, 'successful': 1, 'failed': 0}, '_seq_no': 0, '_primary_term': 1}

结果中 result 字段为 created，代表该数据插入成功。 另外其实我们也可以使用 index() 方法来插入数据，但与 create() 不同的是，create() 方法需要我们指定 id 字段来唯一标识该条数据，而 index() 方法则不需要，如果不指定 id，会自动生成一个 id，调用 index() 方法的写法如下：

1

es.index(index='news', doc_type='politics', body=data)

create() 方法内部其实也是调用了 index() 方法，是对 index() 方法的封装。

更新数据

更新数据也非常简单，我们同样需要指定数据的 id 和内容，调用 update() 方法即可，代码如下：

1
2
3
4
5
6
7
8
9
10

from elasticsearch import Elasticsearch

es = Elasticsearch()
data = {
    'title': '美国留给伊拉克的是个烂摊子吗',
    'url': 'http://view.news.qq.com/zt2011/usa_iraq/index.htm',
    'date': '2011-12-16'
}
result = es.update(index='news', doc_type='politics', body=data, id=1)
print(result)

这里我们为数据增加了一个日期字段，然后调用了 update() 方法，结果如下：

1

{'_index': 'news', '_type': 'politics', '_id': '1', '_version': 2, 'result': 'updated', '_shards': {'total': 2, 'successful': 1, 'failed': 0}, '_seq_no': 1, '_primary_term': 1}

可以看到返回结果中，result 字段为 updated，即表示更新成功，另外我们还注意到有一个字段 _version，这代表更新后的版本号数，2 代表这是第二个版本，因为之前已经插入过一次数据，所以第一次插入的数据是版本 1，可以参见上例的运行结果，这次更新之后版本号就变成了 2，以后每更新一次，版本号都会加 1。 另外更新操作其实利用 index() 方法同样可以做到，写法如下：

1

es.index(index='news', doc_type='politics', body=data, id=1)

可以看到，index() 方法可以代替我们完成两个操作，如果数据不存在，那就执行插入操作，如果已经存在，那就执行更新操作，非常方便。

删除数据

如果想删除一条数据可以调用 delete() 方法，指定需要删除的数据 id 即可，写法如下：

1
2
3
4
5

from elasticsearch import Elasticsearch

es = Elasticsearch()
result = es.delete(index='news', doc_type='politics', id=1)
print(result)

运行结果如下：

1

{'_index': 'news', '_type': 'politics', '_id': '1', '_version': 3, 'result': 'deleted', '_shards': {'total': 2, 'successful': 1, 'failed': 0}, '_seq_no': 2, '_primary_term': 1}

可以看到运行结果中 result 字段为 deleted，代表删除成功，_version 变成了 3，又增加了 1。

查询数据

上面的几个操作都是非常简单的操作，普通的数据库如 MongoDB 都是可以完成的，看起来并没有什么了不起的，Elasticsearch 更特殊的地方在于其异常强大的检索功能。 对于中文来说，我们需要安装一个分词插件，这里使用的是 elasticsearch-analysis-ik，GitHub 链接为：https://github.com/medcl/elasticsearch-analysis-ik，这里我们使用 Elasticsearch 的另一个命令行工具 elasticsearch-plugin 来安装，这里安装的版本是 6.2.4，请确保和 Elasticsearch 的版本对应起来，命令如下：

1

elasticsearch-plugin install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v6.2.4/elasticsearch-analysis-ik-6.2.4.zip

这里的版本号请替换成你的 Elasticsearch 的版本号。 安装之后重新启动 Elasticsearch 就可以了，它会自动加载安装好的插件。 首先我们新建一个索引并指定需要分词的字段，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

from elasticsearch import Elasticsearch

es = Elasticsearch()
mapping = {
    'properties': {
        'title': {
            'type': 'text',
            'analyzer': 'ik_max_word',
            'search_analyzer': 'ik_max_word'
        }
    }
}
es.indices.delete(index='news', ignore=[400, 404])
es.indices.create(index='news', ignore=400)
result = es.indices.put_mapping(index='news', doc_type='politics', body=mapping)
print(result)

这里我们先将之前的索引删除了，然后新建了一个索引，然后更新了它的 mapping 信息，mapping 信息中指定了分词的字段，指定了字段的类型 type 为 text，分词器 analyzer 和 搜索分词器 search_analyzer 为 ik_max_word，即使用我们刚才安装的中文分词插件。如果不指定的话则使用默认的英文分词器。 接下来我们插入几条新的数据：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

datas = [
    {
        'title': '美国留给伊拉克的是个烂摊子吗',
        'url': 'http://view.news.qq.com/zt2011/usa_iraq/index.htm',
        'date': '2011-12-16'
    },
    {
        'title': '公安部：各地校车将享最高路权',
        'url': 'http://www.chinanews.com/gn/2011/12-16/3536077.shtml',
        'date': '2011-12-16'
    },
    {
        'title': '中韩渔警冲突调查：韩警平均每天扣1艘中国渔船',
        'url': 'https://news.qq.com/a/20111216/001044.htm',
        'date': '2011-12-17'
    },
    {
        'title': '中国驻洛杉矶领事馆遭亚裔男子枪击 嫌犯已自首',
        'url': 'http://news.ifeng.com/world/detail_2011_12/16/11372558_0.shtml',
        'date': '2011-12-18'
    }
]

for data in datas:
    es.index(index='news', doc_type='politics', body=data)

这里我们指定了四条数据，都带有 title、url、date 字段，然后通过 index() 方法将其插入 Elasticsearch 中，索引名称为 news，类型为 politics。 接下来我们根据关键词查询一下相关内容：

1
2

result = es.search(index='news', doc_type='politics')
print(result)

可以看到查询出了所有插入的四条数据：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

{
  "took": 0,
  "timed_out": false,
  "_shards": {
    "total": 5,
    "successful": 5,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": 4,
    "max_score": 1.0,
    "hits": [
      {
        "_index": "news",
        "_type": "politics",
        "_id": "c05G9mQBD9BuE5fdHOUT",
        "_score": 1.0,
        "_source": {
          "title": "美国留给伊拉克的是个烂摊子吗",
          "url": "http://view.news.qq.com/zt2011/usa_iraq/index.htm",
          "date": "2011-12-16"
        }
      },
      {
        "_index": "news",
        "_type": "politics",
        "_id": "dk5G9mQBD9BuE5fdHOUm",
        "_score": 1.0,
        "_source": {
          "title": "中国驻洛杉矶领事馆遭亚裔男子枪击，嫌犯已自首",
          "url": "http://news.ifeng.com/world/detail_2011_12/16/11372558_0.shtml",
          "date": "2011-12-18"
        }
      },
      {
        "_index": "news",
        "_type": "politics",
        "_id": "dU5G9mQBD9BuE5fdHOUj",
        "_score": 1.0,
        "_source": {
          "title": "中韩渔警冲突调查：韩警平均每天扣1艘中国渔船",
          "url": "https://news.qq.com/a/20111216/001044.htm",
          "date": "2011-12-17"
        }
      },
      {
        "_index": "news",
        "_type": "politics",
        "_id": "dE5G9mQBD9BuE5fdHOUf",
        "_score": 1.0,
        "_source": {
          "title": "公安部：各地校车将享最高路权",
          "url": "http://www.chinanews.com/gn/2011/12-16/3536077.shtml",
          "date": "2011-12-16"
        }
      }
    ]
  }
}

可以看到返回结果会出现在 hits 字段里面，然后其中有 total 字段标明了查询的结果条目数，还有 max_score 代表了最大匹配分数。 另外我们还可以进行全文检索，这才是体现 Elasticsearch 搜索引擎特性的地方：

1
2
3
4
5
6
7
8
9
10
11

dsl = {
    'query': {
        'match': {
            'title': '中国 领事馆'
        }
    }
}

es = Elasticsearch()
result = es.search(index='news', doc_type='politics', body=dsl)
print(json.dumps(result, indent=2, ensure_ascii=False))

这里我们使用 Elasticsearch 支持的 DSL 语句来进行查询，使用 match 指定全文检索，检索的字段是 title，内容是“中国领事馆”，搜索结果如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

{
  "took": 1,
  "timed_out": false,
  "_shards": {
    "total": 5,
    "successful": 5,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": 2,
    "max_score": 2.546152,
    "hits": [
      {
        "_index": "news",
        "_type": "politics",
        "_id": "dk5G9mQBD9BuE5fdHOUm",
        "_score": 2.546152,
        "_source": {
          "title": "中国驻洛杉矶领事馆遭亚裔男子枪击，嫌犯已自首",
          "url": "http://news.ifeng.com/world/detail_2011_12/16/11372558_0.shtml",
          "date": "2011-12-18"
        }
      },
      {
        "_index": "news",
        "_type": "politics",
        "_id": "dU5G9mQBD9BuE5fdHOUj",
        "_score": 0.2876821,
        "_source": {
          "title": "中韩渔警冲突调查：韩警平均每天扣1艘中国渔船",
          "url": "https://news.qq.com/a/20111216/001044.htm",
          "date": "2011-12-17"
        }
      }
    ]
  }
}

这里我们看到匹配的结果有两条，第一条的分数为 2.54，第二条的分数为 0.28，这是因为第一条匹配的数据中含有“中国”和“领事馆”两个词，第二条匹配的数据中不包含“领事馆”，但是包含了“中国”这个词，所以也被检索出来了，但是分数比较低。 因此可以看出，检索时会对对应的字段全文检索，结果还会按照检索关键词的相关性进行排序，这就是一个基本的搜索引擎雏形。 另外 Elasticsearch 还支持非常多的查询方式，详情可以参考官方文档：https://www.elastic.co/guide/en/elasticsearch/reference/6.3/query-dsl.html 以上便是对 Elasticsearch 的基本介绍以及 Python 操作 Elasticsearch 的基本用法，但这仅仅是 Elasticsearch 的基本功能，它还有更多强大的功能等待着我们的探索，后面会继续更新，敬请期待。 本节代码：https://github.com/Germey/ElasticSearch。

资料推荐

另外推荐几个不错的学习站点：

• Elasticsearch 权威指南：https://es.xiaoleilu.com/index.html
• 全文搜索引擎 Elasticsearch 入门教程：http://www.ruanyifeng.com/blog/2017/08/elasticsearch.html
• Elastic 中文社区：https://www.elasticsearch.cn/

参考资料

• https://es.xiaoleilu.com/index.html
• https://blog.csdn.net/y472360651/article/details/76468327
• https://elasticsearch-py.readthedocs.io/en/master/
• https://es.xiaoleilu.com/010_Intro/10_Installing_ES.html
• https://github.com/medcl/elasticsearch-analysis-ik

大家好， 我不是崔老师，我是四毛，下面是我的个人公众号，欢迎大家关注。

好久没有写东西了，一直都记录在了自己的笔记上，这一篇是关于 glom 的一个介绍与初步使用，后期会将里面的各种 API 再给大家介绍下，同时，最近在搞爬虫的实时数据监控，也挺有意思，后面会和大家分享，敬请期待。

猛然发现，英语水平巅峰就在高考那一天。 因为是边看，边练习，然后翻译，所以个人理解可能有偏差，有错误的地方，请大家指正。 首先，这个库是用来处理一些嵌套的数据的，作者也在 PyCon 2018 上做了个分享，老美的 PyCon 还是有点质量的，不像国内的，搞的什么玩意。 视频地址：https://www.youtube.com/watch?v=bTAFl8P2DkE&t=18m07s

更新: 2018 年 7 月 28 日 10:32:08

经过咨询库的作者，在最后留的那个问题的准确解法如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

import glom

target = {
    'data': {
        'name': 'just_test',
        'likes': [{'ball': 'basketball'},
                  {'ball': 'football'},
                  {'water': 'swim'}]
    }
}

spec = {
    'name' : ('data.name'),
    'likes' : ('data', 'likes', [glom.Coalesce('ball', 'water')])
}

print glom.glom(target, spec)
####
{'name': 'just_test', 'likes': ['basketball', 'football', 'swim']}

非常棒，准确来说就是得灵活运用 Coalesce 方法啊，不能太死板。非常 Pythonic。 另附网址，作者有个很搞笑 little four hair ,哈哈哈哈 Issue 地址

1. 官方文档地址

文档地址

2. 安装方法

1

pip install glom

3. 正式开始

glom，官方的说法是用 PYTHONIC 的方式来处理内嵌的数据。对于现实世界中的数据处理更加给力，现实世界中的数据，我的理解就是 AJAX 越来越流行了，处理这类数据会越来越频繁。有如下特点：

• 对于嵌套数据结构的基于路径式的访问
• 可读，有意义的错误消息
• 声明性数据转换，使用轻量级，Pythonic 规范
• 内置数据探索和调试功能

3.1 原始处理嵌套数据

下面的脚本包导入

1

from glom import glom

下面的 data 就是个简单的嵌套数据，一般都可以用下面几种方法进行处理

1
2
3
4

data = {'a': {'b': {'c': 'd'}}}
data['a']['b']['c']
data.get('a').get('b').get('c')
data.get('a', {}).get('b',{}).get('c')

但是当我们的数据改变成下面的这样时：

1
2
3
4
5

data2 = {'a': {'b': None}}
data2['a']['b']['c']
Traceback (most recent call last):
...
TypeError: 'NoneType' object has no attribute '__getitem__'

会报错，而且由于是嵌套数据，从错误信息里我们只知道有个 None 值，但是到底谁是呢，是 a，是 b 呢，反正肯定不是我们的朋友小哪吒。

3.2 glom 出场

那么 glom 怎么处理上面的数据呢？ 如其所言，路径式：

1
2

data = {'a': {'b': {'c': 'd'}}}
print glom(data, 'a.b.c')  # d

看起来还是很优雅， 很 Pythonic。

1
2

data2 = {'a': {'b': None}}
glom(data2, 'a.b.c')

错误信息如下：

1

glom.core.PathAccessError: could not access 'c', part 2 of Path('a', 'b', 'c'), got error: AttributeError("'NoneType' object has no attribute 'c'",)

很明显，这个错误就很直观。 难道仅仅只有这个？当然不是

3.2.1 Going Beyond Access

上面的是原标题，我的理解是不仅仅获取数据，还有别的呢。 首先，介绍两个基本的术语

1
2

target 目标数据，可以是字典，列表，或其他任意的对象
spec  我们想要的输出格式 【specifications】， 定义你自己所需要的格式

现在让我们跟随宇航员的脚步，探索太阳系吧。

• 获取某个行星的名字：

1
2
3
4
5

target = {'galaxy': {'system': {'planet': 'jupiter'}}}
# 这个格式就是需要个字段值，所以输出的就是个字段值
spec = 'galaxy.system.planet'
glom(target, spec)
# 'jupyter'

• 现在，宇航员们想把行星的名字放进一个列表中，数据是这样：

1

target = {'system': {'planets': [{'name': 'earth'}, {'name': 'jupiter'}]}}

• 通常，处理这样的话，都要写个循环，或者搞个列表解析式，那么 glom 怎么处理呢？

1
2
3

glom(target, ('system.planets', ['name']))
print glom(target, spec)
# ['earth', 'jupiter']

是不是很简单。那么现在新需求又来了，宇航员想得到下面这个数据里面的行星的卫星的数:

1
2

target = {'system': {'planets': [{'name': 'earth', 'moons': 1},
                                  {'name': 'jupiter', 'moons': 69}]}}

• glom 解决方法：

1
2
3
4
5

# 自定义的格式
spec = {'names': ('system.planets', ['name']),
        'moons': ('system.planets', ['moons'])}
print glom(target, spec)
# {'moons': [1, 69], 'names': ['earth', 'jupiter']}

3.2.2 Changing Requirements

Coalesce 是 glom 定义的一种结构，允许我们对于 spec 中的子 spec 进行进一步的处理，你只要在子 spec 中将可能存在的值定义好就行了，听起来有点绕，现在来梳理一下。

• 首先，子 spec 是什么？

1
2
3

spec = {'names': ('system.planets', ['name']),
         'moons': ('system.planets', ['moons'])}
# 以这个为例，这里面的system.planets就是个子spec

• 然后，使用其解析数据：

1
2
3
4
5
6
7
8
9

target = {'system': {
    'planets': [{'name': 'earth', 'moons': 1}, {'name': 'jupiter', 'moons': 69}],
}
}
spec = {'names': (Coalesce('system.planets', 'system.dwarf_planets'), ['name']),
         'moons': (Coalesce('system.planets', 'system.dwarf_planets'), ['moons'])}

print glom(target, spec)
# {'moons': [1, 69], 'names': ['earth', 'jupiter']}

• 接着当我们的数据变成了这个以后

1
2
3
4
5
6

target = {'system': {'dwarf_planets': [{'name': 'pluto', 'moons': 5},
                                        {'name': 'ceres', 'moons': 0}]}}
spec = {'names': (Coalesce('system.planets', 'system.dwarf_planets'), ['name']),
         'moons': (Coalesce('system.planets', 'system.dwarf_planets'), ['moons'])}
print glom(target, spec)
# {'moons': [5, 0], 'names': ['pluto', 'ceres']}

可以看到，依然可以使用相同的 spec 来解析不同的目标数据。 有意思的是，你可以在 target 里面同时写入 plantes 和 dwarf_plants 数据试试看，会返回什么数据。 【这里应该是个惰性的匹配，只要匹配到一个，后面的就不再去匹配了】

3.2.3 True Python Native

真正的原生 python 在 glom 里面，你可以传值给 python 里面的任意的函数 举例：

• 求和

1
2
3
4
5
6

target = {'system': {'planets': [{'name': 'earth', 'moons': 1},
                                  {'name': 'jupiter', 'moons': 69}]}}

print glom(target, {'moon_count': ('system.planets', ['moons'], sum)})

# {'moon_count': 70}

原教程这里还有个案例，但是我还没有理解好，就不写出来了，大家可以点击链接自己看一下。

4. 结论

下一节，为大家带来其中一些重要的函数。 最后，在用的过程中，一直有个疑问，数据如下：

1
2
3
4
5
6
7
8

target = {
    'data': {
        'name': 'just_test',
        'likes': [{'ball': 'basketball'},
                  {'ball': 'football'},
                  {'water': 'swim'}]
    }
}

现在，我想返回的数据格式为：

1

{'name': 'just_for_test', 'likes': ['basketball', 'football', 'water']}

一开始我以为可以这么用：

1
2
3
4

spec = {
    'name': ('data.name'),
    'likes': ('data.likes', ['ball', 'water'] ),
}

但是不行，这样会报错。后来用了另外的方法：

1
2
3
4
5
6
7

spec = {
    'name': ('data.name'),
    'likes': ('data.likes', [lambda x: x.values()[0] if 'ball' or 'water' in x.keys() else ''] ),
}

print glom(target, spec)
# {'name': 'just_test', 'likes': ['basketball', 'football', 'swim']}

这样感觉很不爽啊，还望会的同学不吝赐教啊。

开门见山

话不多说了！第三波送书活动来了！这次送 20 本签名版《Python3 网络爬虫开发实战》。 本书目前上市三个月已经重印 6 次，上市三个月以来长期位居京东计算机类新书榜第一位（现已不算新书），目前在豆瓣的评分是 9.2 分。

书籍介绍

本书《Python3 网络爬虫开发实战》全面介绍了利用 Python3 开发网络爬虫的知识，书中首先详细介绍了各种类型的环境配置过程和爬虫基础知识，还讨论了 urllib、requests 等请求库和 Beautiful Soup、XPath、pyquery 等解析库以及文本和各类数据库的存储方法，另外本书通过多个真实新鲜案例介绍了分析 Ajax 进行数据爬取，Selenium 和 Splash 进行动态网站爬取的过程，接着又分享了一些切实可行的爬虫技巧，比如使用代理爬取和维护动态代理池的方法、ADSL 拨号代理的使用、各类验证码（图形、极验、点触、宫格等）的破解方法、模拟登录网站爬取的方法及 Cookies 池的维护等等。 此外，本书的内容还远远不止这些，作者还结合移动互联网的特点探讨了使用 Charles、mitmdump、Appium 等多种工具实现 App 抓包分析、加密参数接口爬取、微信朋友圈爬取的方法。此外本书还详细介绍了 pyspider 框架、Scrapy 框架的使用和分布式爬虫的知识，另外对于优化及部署工作，本书还包括 Bloom Filter 效率优化、Docker 和 Scrapyd 爬虫部署、分布式爬虫管理框架 Gerapy 的分享。 全书共 604 页，足足两斤重呢~ 定价为 99 元！

作者介绍

看书就先看看谁写的嘛，我们来了解一下~ 崔庆才，静觅博客博主（https://cuiqingcai.com），博客 Python 爬虫博文阅读量已过千万，北京航空航天大学硕士，天善智能、网易云课堂讲师，微软小冰大数据工程师，有多个大型分布式爬虫项目经验，乐于技术分享，文章通俗易懂 ^^ 附皂片一张 ~(@^^@)~

图文介绍

呕心沥血设计的宣传图也得放一下~

专家评论

书是好是坏，得让专家看评一评呀，那么下面就是几位专家的精彩评论，快来看看吧~ 在互联网软件开发工程师的分类中，爬虫工程师是非常重要的。爬虫工作往往是一个公司核心业务开展的基础，数据抓取下来，才有后续的加工处理和最终展现。此时数据的抓取规模、稳定性、实时性、准确性就显得非常重要。早期的互联网充分开放互联，数据获取的难度很小。随着各大公司对数据资产日益看重，反爬水平也在不断提高，各种新技术不断给爬虫软件提出新的课题。本书作者对爬虫的各个领域都有深刻研究，书中探讨了 Ajax 数据的抓取、动态渲染页面的抓取、验证码识别、模拟登录等高级话题，同时也结合移动互联网的特点探讨了 App 的抓取等。更重要的是，本书提供了大量源码，可以帮助读者更好地理解相关内容。强烈推荐给各位技术爱好者阅读！

——梁斌，八友科技总经理

数据既是当今大数据分析的前提，也是各种人工智能应用场景的基础。得数据者得天下，会爬虫者走遍天下也不怕！一册在手，让小白到老司机都能有所收获！

——李舟军，北京航空航天大学教授，博士生导师

本书从爬虫入门到分布式抓取，详细介绍了爬虫技术的各个要点，并针对不同的场景提出了对应的解决方案。另外，书中通过大量的实例来帮助读者更好地学习爬虫技术，通俗易懂，干货满满。强烈推荐给大家！

——宋睿华，微软小冰首席科学家

有人说中国互联网的带宽全给各种爬虫占据了，这说明网络爬虫的重要性以及中国互联网数据封闭垄断的现状。爬是一种能力，爬是为了不爬。

——施水才，北京拓尔思信息技术股份有限公司总裁

全书目录

书的目录也有~ 看这里！

• 1-开发环境配置
• 1.1-Python3 的安装
• 1.2-请求库的安装
• 1.3-解析库的安装
• 1.4-数据库的安装
• 1.5-存储库的安装
• 1.6-Web 库的安装
• 1.7-App 爬取相关库的安装
• 1.8-爬虫框架的安装
• 1.9-部署相关库的安装
• 2-爬虫基础
• 2.1-HTTP 基本原理
• 2.2-网页基础
• 2.3-爬虫的基本原理
• 2.4-会话和 Cookies
• 2.5-代理的基本原理
• 3-基本库的使用
• 3.1-使用 urllib
• 3.1.1-发送请求
• 3.1.2-处理异常
• 3.1.3-解析链接
• 3.1.4-分析 Robots 协议
• 3.2-使用 requests
• 3.2.1-基本用法
• 3.2.2-高级用法
• 3.3-正则表达式
• 3.4-抓取猫眼电影排行
• 4-解析库的使用
• 4.1-使用 XPath
• 4.2-使用 Beautiful Soup
• 4.3-使用 pyquery
• 5-数据存储
• 5.1-文件存储
• 5.1.1-TXT 文本存储
• 5.1.2-JSON 文件存储
• 5.1.3-CSV 文件存储
• 5.2-关系型数据库存储
• 5.2.1-MySQL 存储
• 5.3-非关系型数据库存储
• 5.3.1-MongoDB 存储
• 5.3.2-Redis 存储
• 6-Ajax 数据爬取
• 6.1-什么是 Ajax
• 6.2-Ajax 分析方法
• 6.3-Ajax 结果提取
• 6.4-分析 Ajax 爬取今日头条街拍美图
• 7-动态渲染页面爬取
• 7.1-Selenium 的使用
• 7.2-Splash 的使用
• 7.3-Splash 负载均衡配置
• 7.4-使用 Selenium 爬取淘宝商品
• 8-验证码的识别
• 8.1-图形验证码的识别
• 8.2-极验滑动验证码的识别
• 8.3-点触验证码的识别
• 8.4-微博宫格验证码的识别
• 9-代理的使用
• 9.1-代理的设置
• 9.2-代理池的维护
• 9.3-付费代理的使用
• 9.4-ADSL 拨号代理
• 9.5-使用代理爬取微信公众号文章
• 10-模拟登录
• 10.1-模拟登录并爬取 GitHub
• 10.2-Cookies 池的搭建
• 11-App 的爬取
• 11.1-Charles 的使用
• 11.2-mitmproxy 的使用
• 11.3-mitmdump 爬取“得到”App 电子书信息
• 11.4-Appium 的基本使用
• 11.5-Appium 爬取微信朋友圈
• 11.6-Appium+mitmdump 爬取京东商品
• 12-pyspider 框架的使用
• 12.1-pyspider 框架介绍
• 12.2-pyspider 的基本使用
• 12.3-pyspider 用法详解
• 13-Scrapy 框架的使用
• 13.1-Scrapy 框架介绍
• 13.2-Scrapy 入门
• 13.3-Selector 的用法
• 13.4-Spider 的用法
• 13.5-Downloader Middleware 的用法
• 13.6-Spider Middleware 的用法
• 13.7-Item Pipeline 的用法
• 13.8-Scrapy 对接 Selenium
• 13.9-Scrapy 对接 Splash
• 13.10-Scrapy 通用爬虫
• 13.11-Scrapyrt 的使用
• 13.12-Scrapy 对接 Docker
• 13.13-Scrapy 爬取新浪微博
• 14-分布式爬虫
• 14.1-分布式爬虫原理
• 14.2-Scrapy-Redis 源码解析
• 14.3-Scrapy 分布式实现
• 14.4-Bloom Filter 的对接
• 15-分布式爬虫的部署
• 15.1-Scrapyd 分布式部署
• 15.2-Scrapyd-Client 的使用
• 15.3-Scrapyd 对接 Docker
• 15.4-Scrapyd 批量部署
• 15.5-Gerapy 分布式管理

购买链接

想必很多小伙伴已经等了很久了，之前预售那么久也一直迟迟没有货，发售就有不少网店又售空了，不过现在起不用担心了！

书籍现已在京东、天猫、当当等网店上架并全面供应啦，复制链接到浏览器打开或扫描二维码打开即可购买了！

京东商城

https://item.jd.com/12333540.html

天猫商城

https://detail.tmall.com/item.htm?id=566699703917

当当网

http://product.dangdang.com/25249602.html

欢迎大家购买，谢谢支持！O(∩_∩)O

免费预览

不放心？想先看看有些啥，没问题！看这里： 免费章节试读： https://cuiqingcai.com/5052.html 将一直免费开放前 7 章节，欢迎大家试读！ 好了，接下来就是我们的福利环节啦~

福利一：签名书！！！

恭喜你看到这里了！那么接下来的福利时间就到了！后面还有两个福利不容错过~ 赠书活动第三波来袭，送 20 本作者亲笔签名书籍！！！ 活动流程（重要，请一定认真阅读）： 公众号进击的 Coder 回复 “赠书” 获取序列码参与活动，2018.7.24 22:00 截止，逾期参与无效，请记住您的序列码，这是您的唯一标识。 您可以转发活动页面邀请好友帮忙积攒人气值，最终取人气值前 20 位赠书，截止日期 2018.7.24 22:00，该时刻人气值前 20 位的朋友每人会获得签名书一本。 最终赠书名单会在微信公众号进击的 Coder 公布，届时请关注公众号消息！

福利二：独家优惠！！！

等等，你以为这就是全部福利吗？当然不是！除了抽奖送书，我们还拿到了拨号 VPS 知名品牌云立方的独家优惠，在公众号（进击的 Coder ）中回复：“优惠券”，即可免费领取云立方 50 元主机优惠券，数量有限，先到先得！优惠券可在云立方官网（www.yunlifang.cn）购买动态IP拨号VPS时抵扣现金，有了它，爬虫代理易如反掌！ 你问我动态拨号 VPS 能做什么？应该怎么用在爬虫里？来这里了解一下： 轻松获得海量稳定代理！ADSL 拨号代理的搭建

福利三：视频课程！！！

当然除了书籍，也有配套的视频课程，目前半价促销中，作者同样是崔庆才，二者结合学习效果更佳！限时优惠折扣中！扫描下图中二维码即可了解详情！ 最后也是最重要的就是参与活动的地址了！！！快来扫码回复领取属于你的福利吧！！！

特别致谢

最后特别感谢云立方、天善智能对本活动的大力支持！

1. 前言

在执行一些 IO 密集型任务的时候，程序常常会因为等待 IO 而阻塞。比如在网络爬虫中，如果我们使用 requests 库来进行请求的话，如果网站响应速度过慢，程序一直在等待网站响应，最后导致其爬取效率是非常非常低的。 为了解决这类问题，本文就来探讨一下 Python 中异步协程来加速的方法，此种方法对于 IO 密集型任务非常有效。如将其应用到网络爬虫中，爬取效率甚至可以成百倍地提升。 注：本文协程使用 async/await 来实现，需要 Python 3.5 及以上版本。

2. 基本了解

在了解异步协程之前，我们首先得了解一些基础概念，如阻塞和非阻塞、同步和异步、多进程和协程。

2.1 阻塞

阻塞状态指程序未得到所需计算资源时被挂起的状态。程序在等待某个操作完成期间，自身无法继续干别的事情，则称该程序在该操作上是阻塞的。 常见的阻塞形式有：网络 I/O 阻塞、磁盘 I/O 阻塞、用户输入阻塞等。阻塞是无处不在的，包括 CPU 切换上下文时，所有的进程都无法真正干事情，它们也会被阻塞。如果是多核 CPU 则正在执行上下文切换操作的核不可被利用。

2.2 非阻塞

程序在等待某操作过程中，自身不被阻塞，可以继续运行干别的事情，则称该程序在该操作上是非阻塞的。 非阻塞并不是在任何程序级别、任何情况下都可以存在的。 仅当程序封装的级别可以囊括独立的子程序单元时，它才可能存在非阻塞状态。 非阻塞的存在是因为阻塞存在，正因为某个操作阻塞导致的耗时与效率低下，我们才要把它变成非阻塞的。

2.3 同步

不同程序单元为了完成某个任务，在执行过程中需靠某种通信方式以协调一致，称这些程序单元是同步执行的。 例如购物系统中更新商品库存，需要用“行锁”作为通信信号，让不同的更新请求强制排队顺序执行，那更新库存的操作是同步的。 简言之，同步意味着有序。

2.4 异步

为完成某个任务，不同程序单元之间过程中无需通信协调，也能完成任务的方式，不相关的程序单元之间可以是异步的。 例如，爬虫下载网页。调度程序调用下载程序后，即可调度其他任务，而无需与该下载任务保持通信以协调行为。不同网页的下载、保存等操作都是无关的，也无需相互通知协调。这些异步操作的完成时刻并不确定。 简言之，异步意味着无序。

2.5 多进程

多进程就是利用 CPU 的多核优势，在同一时间并行地执行多个任务，可以大大提高执行效率。

2.6 协程

协程，英文叫做 Coroutine，又称微线程，纤程，协程是一种用户态的轻量级线程。 协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈。因此协程能保留上一次调用时的状态，即所有局部状态的一个特定组合，每次过程重入时，就相当于进入上一次调用的状态。 协程本质上是个单进程，协程相对于多进程来说，无需线程上下文切换的开销，无需原子操作锁定及同步的开销，编程模型也非常简单。 我们可以使用协程来实现异步操作，比如在网络爬虫场景下，我们发出一个请求之后，需要等待一定的时间才能得到响应，但其实在这个等待过程中，程序可以干许多其他的事情，等到响应得到之后才切换回来继续处理，这样可以充分利用 CPU 和其他资源，这就是异步协程的优势。

3. 异步协程用法

接下来让我们来了解下协程的实现，从 Python 3.4 开始，Python 中加入了协程的概念，但这个版本的协程还是以生成器对象为基础的，在 Python 3.5 则增加了 async/await，使得协程的实现更加方便。 Python 中使用协程最常用的库莫过于 asyncio，所以本文会以 asyncio 为基础来介绍协程的使用。 首先我们需要了解下面几个概念：

• event_loop：事件循环，相当于一个无限循环，我们可以把一些函数注册到这个事件循环上，当满足条件发生的时候，就会调用对应的处理方法。
• coroutine：中文翻译叫协程，在 Python 中常指代为协程对象类型，我们可以将协程对象注册到时间循环中，它会被事件循环调用。我们可以使用 async 关键字来定义一个方法，这个方法在调用时不会立即被执行，而是返回一个协程对象。
• task：任务，它是对协程对象的进一步封装，包含了任务的各个状态。
• future：代表将来执行或没有执行的任务的结果，实际上和 task 没有本质区别。

另外我们还需要了解 async/await 关键字，它是从 Python 3.5 才出现的，专门用于定义协程。其中，async 定义一个协程，await 用来挂起阻塞方法的执行。

3.1 定义协程

首先我们来定义一个协程，体验一下它和普通进程在实现上的不同之处，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12

import asyncio

async def execute(x):
    print('Number:', x)

coroutine = execute(1)
print('Coroutine:', coroutine)
print('After calling execute')

loop = asyncio.get_event_loop()
loop.run_until_complete(coroutine)
print('After calling loop')

运行结果：

1
2
3
4

Coroutine: <coroutine object execute at 0x1034cf830>
After calling execute
Number: 1
After calling loop

首先我们引入了 asyncio 这个包，这样我们才可以使用 async 和 await，然后我们使用 async 定义了一个 execute() 方法，方法接收一个数字参数，方法执行之后会打印这个数字。 随后我们直接调用了这个方法，然而这个方法并没有执行，而是返回了一个 coroutine 协程对象。随后我们使用 get_event_loop() 方法创建了一个事件循环 loop，并调用了 loop 对象的 run_until_complete() 方法将协程注册到事件循环 loop 中，然后启动。最后我们才看到了 execute() 方法打印了输出结果。 可见，async 定义的方法就会变成一个无法直接执行的 coroutine 对象，必须将其注册到事件循环中才可以执行。 上文我们还提到了 task，它是对 coroutine 对象的进一步封装，它里面相比 coroutine 对象多了运行状态，比如 running、finished 等，我们可以用这些状态来获取协程对象的执行情况。 在上面的例子中，当我们将 coroutine 对象传递给 run_until_complete() 方法的时候，实际上它进行了一个操作就是将 coroutine 封装成了 task 对象，我们也可以显式地进行声明，如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

import asyncio

async def execute(x):
    print('Number:', x)
    return x

coroutine = execute(1)
print('Coroutine:', coroutine)
print('After calling execute')

loop = asyncio.get_event_loop()
task = loop.create_task(coroutine)
print('Task:', task)
loop.run_until_complete(task)
print('Task:', task)
print('After calling loop')

运行结果：

1
2
3
4
5
6

Coroutine: <coroutine object execute at 0x10e0f7830>
After calling execute
Task: <Task pending coro=<execute() running at demo.py:4>>
Number: 1
Task: <Task finished coro=<execute() done, defined at demo.py:4> result=1>
After calling loop

这里我们定义了 loop 对象之后，接着调用了它的 create_task() 方法将 coroutine 对象转化为了 task 对象，随后我们打印输出一下，发现它是 pending 状态。接着我们将 task 对象添加到事件循环中得到执行，随后我们再打印输出一下 task 对象，发现它的状态就变成了 finished，同时还可以看到其 result 变成了 1，也就是我们定义的 execute() 方法的返回结果。 另外定义 task 对象还有一种方式，就是直接通过 asyncio 的 ensure_future() 方法，返回结果也是 task 对象，这样的话我们就可以不借助于 loop 来定义，即使我们还没有声明 loop 也可以提前定义好 task 对象，写法如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

import asyncio

async def execute(x):
    print('Number:', x)
    return x

coroutine = execute(1)
print('Coroutine:', coroutine)
print('After calling execute')

task = asyncio.ensure_future(coroutine)
print('Task:', task)
loop = asyncio.get_event_loop()
loop.run_until_complete(task)
print('Task:', task)
print('After calling loop')

运行结果：

1
2
3
4
5
6

Coroutine: <coroutine object execute at 0x10aa33830>
After calling execute
Task: <Task pending coro=<execute() running at demo.py:4>>
Number: 1
Task: <Task finished coro=<execute() done, defined at demo.py:4> result=1>
After calling loop

发现其效果都是一样的。

3.2 绑定回调

另外我们也可以为某个 task 绑定一个回调方法，来看下面的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

import asyncio
import requests

async def request():
    url = 'https://www.baidu.com'
    status = requests.get(url)
    return status

def callback(task):
    print('Status:', task.result())

coroutine = request()
task = asyncio.ensure_future(coroutine)
task.add_done_callback(callback)
print('Task:', task)

loop = asyncio.get_event_loop()
loop.run_until_complete(task)
print('Task:', task)

在这里我们定义了一个 request() 方法，请求了百度，返回状态码，但是这个方法里面我们没有任何 print() 语句。随后我们定义了一个 callback() 方法，这个方法接收一个参数，是 task 对象，然后调用 print() 方法打印了 task 对象的结果。这样我们就定义好了一个 coroutine 对象和一个回调方法，我们现在希望的效果是，当 coroutine 对象执行完毕之后，就去执行声明的 callback() 方法。 那么它们二者怎样关联起来呢？很简单，只需要调用 add_done_callback() 方法即可，我们将 callback() 方法传递给了封装好的 task 对象，这样当 task 执行完毕之后就可以调用 callback() 方法了，同时 task 对象还会作为参数传递给 callback() 方法，调用 task 对象的 result() 方法就可以获取返回结果了。 运行结果：

1
2
3

Task: <Task pending coro=<request() running at demo.py:5> cb=[callback() at demo.py:11]>
Status: <Response [200]>
Task: <Task finished coro=<request() done, defined at demo.py:5> result=<Response [200]>>

实际上不用回调方法，直接在 task 运行完毕之后也可以直接调用 result() 方法获取结果，如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

import asyncio
import requests

async def request():
    url = 'https://www.baidu.com'
    status = requests.get(url)
    return status

coroutine = request()
task = asyncio.ensure_future(coroutine)
print('Task:', task)

loop = asyncio.get_event_loop()
loop.run_until_complete(task)
print('Task:', task)
print('Task Result:', task.result())

运行结果是一样的：

1
2
3

Task: <Task pending coro=<request() running at demo.py:4>>
Task: <Task finished coro=<request() done, defined at demo.py:4> result=<Response [200]>>
Task Result: <Response [200]>

3.3 多任务协程

上面的例子我们只执行了一次请求，如果我们想执行多次请求应该怎么办呢？我们可以定义一个 task 列表，然后使用 asyncio 的 wait() 方法即可执行，看下面的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

import asyncio
import requests

async def request():
    url = 'https://www.baidu.com'
    status = requests.get(url)
    return status

tasks = [asyncio.ensure_future(request()) for _ in range(5)]
print('Tasks:', tasks)

loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))

for task in tasks:
    print('Task Result:', task.result())

这里我们使用一个 for 循环创建了五个 task，组成了一个列表，然后把这个列表首先传递给了 asyncio 的 wait() 方法，然后再将其注册到时间循环中，就可以发起五个任务了。最后我们再将任务的运行结果输出出来，运行结果如下：

1
2
3
4
5
6

Tasks: [<Task pending coro=<request() running at demo.py:5>>, <Task pending coro=<request() running at demo.py:5>>, <Task pending coro=<request() running at demo.py:5>>, <Task pending coro=<request() running at demo.py:5>>, <Task pending coro=<request() running at demo.py:5>>]
Task Result: <Response [200]>
Task Result: <Response [200]>
Task Result: <Response [200]>
Task Result: <Response [200]>
Task Result: <Response [200]>

可以看到五个任务被顺次执行了，并得到了运行结果。

3.4 协程实现

前面说了这么一通，又是 async，又是 coroutine，又是 task，又是 callback，但似乎并没有看出协程的优势啊？反而写法上更加奇怪和麻烦了，别急，上面的案例只是为后面的使用作铺垫，接下来我们正式来看下协程在解决 IO 密集型任务上有怎样的优势吧！ 上面的代码中，我们用一个网络请求作为示例，这就是一个耗时等待的操作，因为我们请求网页之后需要等待页面响应并返回结果。耗时等待的操作一般都是 IO 操作，比如文件读取、网络请求等等。协程对于处理这种操作是有很大优势的，当遇到需要等待的情况的时候，程序可以暂时挂起，转而去执行其他的操作，从而避免一直等待一个程序而耗费过多的时间，充分利用资源。 为了表现出协程的优势，我们需要先创建一个合适的实验环境，最好的方法就是模拟一个需要等待一定时间才可以获取返回结果的网页，上面的代码中使用了百度，但百度的响应太快了，而且响应速度也会受本机网速影响，所以最好的方式是自己在本地模拟一个慢速服务器，这里我们选用 Flask。 如果没有安装 Flask 的话可以执行如下命令安装：

1

pip3 install flask

然后编写服务器代码如下：

1
2
3
4
5
6
7
8
9
10
11
12

from flask import Flask
import time

app = Flask(__name__)

@app.route('/')
def index():
    time.sleep(3)
    return 'Hello!'

if __name__ == '__main__':
    app.run(threaded=True)

这里我们定义了一个 Flask 服务，主入口是 index() 方法，方法里面先调用了 sleep() 方法休眠 3 秒，然后接着再返回结果，也就是说，每次请求这个接口至少要耗时 3 秒，这样我们就模拟了一个慢速的服务接口。 注意这里服务启动的时候，run() 方法加了一个参数 threaded，这表明 Flask 启动了多线程模式，不然默认是只有一个线程的。如果不开启多线程模式，同一时刻遇到多个请求的时候，只能顺次处理，这样即使我们使用协程异步请求了这个服务，也只能一个一个排队等待，瓶颈就会出现在服务端。所以，多线程模式是有必要打开的。 启动之后，Flask 应该默认会在 127.0.0.1:5000 上运行，运行之后控制台输出结果如下：

1

 * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

接下来我们再重新使用上面的方法请求一遍：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

import asyncio
import requests
import time

start = time.time()

async def request():
    url = 'http://127.0.0.1:5000'
    print('Waiting for', url)
    response = requests.get(url)
    print('Get response from', url, 'Result:', response.text)

tasks = [asyncio.ensure_future(request()) for _ in range(5)]
loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))

end = time.time()
print('Cost time:', end - start)

在这里我们还是创建了五个 task，然后将 task 列表传给 wait() 方法并注册到时间循环中执行。 运行结果如下：

1
2
3
4
5
6
7
8
9
10
11

Waiting for http://127.0.0.1:5000
Get response from http://127.0.0.1:5000 Result: Hello!
Waiting for http://127.0.0.1:5000
Get response from http://127.0.0.1:5000 Result: Hello!
Waiting for http://127.0.0.1:5000
Get response from http://127.0.0.1:5000 Result: Hello!
Waiting for http://127.0.0.1:5000
Get response from http://127.0.0.1:5000 Result: Hello!
Waiting for http://127.0.0.1:5000
Get response from http://127.0.0.1:5000 Result: Hello!
Cost time: 15.049368143081665

可以发现和正常的请求并没有什么两样，依然还是顺次执行的，耗时 15 秒，平均一个请求耗时 3 秒，说好的异步处理呢？ 其实，要实现异步处理，我们得先要有挂起的操作，当一个任务需要等待 IO 结果的时候，可以挂起当前任务，转而去执行其他任务，这样我们才能充分利用好资源，上面方法都是一本正经的串行走下来，连个挂起都没有，怎么可能实现异步？想太多了。 要实现异步，接下来我们再了解一下 await 的用法，使用 await 可以将耗时等待的操作挂起，让出控制权。当协程执行的时候遇到 await，时间循环就会将本协程挂起，转而去执行别的协程，直到其他的协程挂起或执行完毕。 所以，我们可能会将代码中的 request() 方法改成如下的样子：

1
2
3
4
5

async def request():
    url = 'http://127.0.0.1:5000'
    print('Waiting for', url)
    response = await requests.get(url)
    print('Get response from', url, 'Result:', response.text)

仅仅是在 requests 前面加了一个 await，然而执行以下代码，会得到如下报错：

1
2
3
4
5
6
7
8
9
10
11
12

Waiting for http://127.0.0.1:5000
Waiting for http://127.0.0.1:5000
Waiting for http://127.0.0.1:5000
Waiting for http://127.0.0.1:5000
Waiting for http://127.0.0.1:5000
Cost time: 15.048935890197754
Task exception was never retrieved
future: <Task finished coro=<request() done, defined at demo.py:7> exception=TypeError("object Response can't be used in 'await' expression",)>
Traceback (most recent call last):
  File "demo.py", line 10, in request
    status = await requests.get(url)
TypeError: object Response can't be used in 'await' expression

这次它遇到 await 方法确实挂起了，也等待了，但是最后却报了这么个错，这个错误的意思是 requests 返回的 Response 对象不能和 await 一起使用，为什么呢？因为根据官方文档说明，await 后面的对象必须是如下格式之一：

• A native coroutine object returned from a native coroutine function，一个原生 coroutine 对象。
• A generator-based coroutine object returned from a function decorated with types.coroutine()，一个由 types.coroutine() 修饰的生成器，这个生成器可以返回 coroutine 对象。
• An object with an await method returning an iterator，一个包含 await 方法的对象返回的一个迭代器。

可以参见：https://www.python.org/dev/peps/pep-0492/#await-expression。 reqeusts 返回的 Response 不符合上面任一条件，因此就会报上面的错误了。 那么有的小伙伴就发现了，既然 await 后面可以跟一个 coroutine 对象，那么我用 async 把请求的方法改成 coroutine 对象不就可以了吗？所以就改写成如下的样子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

import asyncio
import requests
import time

start = time.time()

async def get(url):
    return requests.get(url)

async def request():
    url = 'http://127.0.0.1:5000'
    print('Waiting for', url)
    response = await get(url)
    print('Get response from', url, 'Result:', response.text)

tasks = [asyncio.ensure_future(request()) for _ in range(5)]
loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))

end = time.time()
print('Cost time:', end - start)

这里我们将请求页面的方法独立出来，并用 async 修饰，这样就得到了一个 coroutine 对象，我们运行一下看看：

1
2
3
4
5
6
7
8
9
10
11

Waiting for http://127.0.0.1:5000
Get response from http://127.0.0.1:5000 Result: Hello!
Waiting for http://127.0.0.1:5000
Get response from http://127.0.0.1:5000 Result: Hello!
Waiting for http://127.0.0.1:5000
Get response from http://127.0.0.1:5000 Result: Hello!
Waiting for http://127.0.0.1:5000
Get response from http://127.0.0.1:5000 Result: Hello!
Waiting for http://127.0.0.1:5000
Get response from http://127.0.0.1:5000 Result: Hello!
Cost time: 15.134317874908447

还是不行，它还不是异步执行，也就是说我们仅仅将涉及 IO 操作的代码封装到 async 修饰的方法里面是不可行的！我们必须要使用支持异步操作的请求方式才可以实现真正的异步，所以这里就需要 aiohttp 派上用场了。

3.5 使用 aiohttp

aiohttp 是一个支持异步请求的库，利用它和 asyncio 配合我们可以非常方便地实现异步请求操作。 安装方式如下：

1

pip3 install aiohttp

官方文档链接为：https://aiohttp.readthedocs.io/，它分为两部分，一部分是 Client，一部分是 Server，详细的内容可以参考官方文档。 下面我们将 aiohttp 用上来，将代码改成如下样子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

import asyncio
import aiohttp
import time

start = time.time()

async def get(url):
    session = aiohttp.ClientSession()
    response = await session.get(url)
    result = await response.text()
    session.close()
    return result

async def request():
    url = 'http://127.0.0.1:5000'
    print('Waiting for', url)
    result = await get(url)
    print('Get response from', url, 'Result:', result)

tasks = [asyncio.ensure_future(request()) for _ in range(5)]
loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))

end = time.time()
print('Cost time:', end - start)

在这里我们将请求库由 requests 改成了 aiohttp，通过 aiohttp 的 ClientSession 类的 get() 方法进行请求，结果如下：

1
2
3
4
5
6
7
8
9
10
11

Waiting for http://127.0.0.1:5000
Waiting for http://127.0.0.1:5000
Waiting for http://127.0.0.1:5000
Waiting for http://127.0.0.1:5000
Waiting for http://127.0.0.1:5000
Get response from http://127.0.0.1:5000 Result: Hello!
Get response from http://127.0.0.1:5000 Result: Hello!
Get response from http://127.0.0.1:5000 Result: Hello!
Get response from http://127.0.0.1:5000 Result: Hello!
Get response from http://127.0.0.1:5000 Result: Hello!
Cost time: 3.0199508666992188

成功了！我们发现这次请求的耗时由 15 秒变成了 3 秒，耗时直接变成了原来的 1/5。 代码里面我们使用了 await，后面跟了 get() 方法，在执行这五个协程的时候，如果遇到了 await，那么就会将当前协程挂起，转而去执行其他的协程，直到其他的协程也挂起或执行完毕，再进行下一个协程的执行。 开始运行时，时间循环会运行第一个 task，针对第一个 task 来说，当执行到第一个 await 跟着的 get() 方法时，它被挂起，但这个 get() 方法第一步的执行是非阻塞的，挂起之后立马被唤醒，所以立即又进入执行，创建了 ClientSession 对象，接着遇到了第二个 await，调用了 session.get() 请求方法，然后就被挂起了，由于请求需要耗时很久，所以一直没有被唤醒，好第一个 task 被挂起了，那接下来该怎么办呢？事件循环会寻找当前未被挂起的协程继续执行，于是就转而执行第二个 task 了，也是一样的流程操作，直到执行了第五个 task 的 session.get() 方法之后，全部的 task 都被挂起了。所有 task 都已经处于挂起状态，那咋办？只好等待了。3 秒之后，几个请求几乎同时都有了响应，然后几个 task 也被唤醒接着执行，输出请求结果，最后耗时，3 秒！ 怎么样？这就是异步操作的便捷之处，当遇到阻塞式操作时，任务被挂起，程序接着去执行其他的任务，而不是傻傻地等着，这样可以充分利用 CPU 时间，而不必把时间浪费在等待 IO 上。 有人就会说了，既然这样的话，在上面的例子中，在发出网络请求后，既然接下来的 3 秒都是在等待的，在 3 秒之内，CPU 可以处理的 task 数量远不止这些，那么岂不是我们放 10 个、20 个、50 个、100 个、1000 个 task 一起执行，最后得到所有结果的耗时不都是 3 秒左右吗？因为这几个任务被挂起后都是一起等待的。 理论来说确实是这样的，不过有个前提，那就是服务器在同一时刻接受无限次请求都能保证正常返回结果，也就是服务器无限抗压，另外还要忽略 IO 传输时延，确实可以做到无限 task 一起执行且在预想时间内得到结果。 我们这里将 task 数量设置成 100，再试一下：

1

tasks = [asyncio.ensure_future(request()) for _ in range(100)]

耗时结果如下：

1

Cost time: 3.106252670288086

最后运行时间也是在 3 秒左右，当然多出来的时间就是 IO 时延了。 可见，使用了异步协程之后，我们几乎可以在相同的时间内实现成百上千倍次的网络请求，把这个运用在爬虫中，速度提升可谓是非常可观了。

3.6 与单进程、多进程对比

可能有的小伙伴非常想知道上面的例子中，如果 100 次请求，不是用异步协程的话，使用单进程和多进程会耗费多少时间，我们来测试一下： 首先来测试一下单进程的时间：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

import requests
import time

start = time.time()

def request():
    url = 'http://127.0.0.1:5000'
    print('Waiting for', url)
    result = requests.get(url).text
    print('Get response from', url, 'Result:', result)

for _ in range(100):
    request()

end = time.time()
print('Cost time:', end - start)

最后耗时：

1

Cost time: 305.16639709472656

接下来我们使用多进程来测试下，使用 multiprocessing 库：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

import requests
import time
import multiprocessing

start = time.time()

def request(_):
    url = 'http://127.0.0.1:5000'
    print('Waiting for', url)
    result = requests.get(url).text
    print('Get response from', url, 'Result:', result)

cpu_count = multiprocessing.cpu_count()
print('Cpu count:', cpu_count)
pool = multiprocessing.Pool(cpu_count)
pool.map(request, range(100))

end = time.time()
print('Cost time:', end - start)

这里我使用了multiprocessing 里面的 Pool 类，即进程池。我的电脑的 CPU 个数是 8 个，这里的进程池的大小就是 8。 运行时间：

1

Cost time: 48.17306900024414

可见 multiprocessing 相比单线程来说，还是可以大大提高效率的。

3.7 与多进程的结合

既然异步协程和多进程对网络请求都有提升，那么为什么不把二者结合起来呢？在最新的 PyCon 2018 上，来自 Facebook 的 John Reese 介绍了 asyncio 和 multiprocessing 各自的特点，并开发了一个新的库，叫做 aiomultiprocess，感兴趣的可以了解下：https://www.youtube.com/watch?v=0kXaLh8Fz3k。 这个库的安装方式是：

1

pip3 install aiomultiprocess

需要 Python 3.6 及更高版本才可使用。 使用这个库，我们可以将上面的例子改写如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

import asyncio
import aiohttp
import time
from aiomultiprocess import Pool

start = time.time()

async def get(url):
    session = aiohttp.ClientSession()
    response = await session.get(url)
    result = await response.text()
    session.close()
    return result

async def request():
    url = 'http://127.0.0.1:5000'
    urls = [url for _ in range(100)]
    async with Pool() as pool:
        result = await pool.map(get, urls)
        return result

coroutine = request()
task = asyncio.ensure_future(coroutine)
loop = asyncio.get_event_loop()
loop.run_until_complete(task)

end = time.time()
print('Cost time:', end - start)

这样就会同时使用多进程和异步协程进行请求，当然最后的结果其实和异步是差不多的：

1

Cost time: 3.1156570434570312

因为我的测试接口的原因，最快的响应也是 3 秒，所以这部分多余的时间基本都是 IO 传输时延。但在真实情况下，我们在做爬取的时候遇到的情况千变万化，一方面我们使用异步协程来防止阻塞，另一方面我们使用 multiprocessing 来利用多核成倍加速，节省时间其实还是非常可观的。 以上便是 Python 中协程的基本用法，希望对大家有帮助。

4. 参考来源

• http://python.jobbole.com/87310/
• https://www.cnblogs.com/xybaby/p/6406191.html
• http://python.jobbole.com/88291/
• http://lotabout.me/2017/understand-python-asyncio/
• https://segmentfault.com/a/1190000008814676
• https://www.cnblogs.com/animalize/p/4738941.html

最近有一个朋友刚入手了 Mac，准备专门搞开发用，让我给他推荐几款软件，然后我就把我的 Launchpad 截图发给了他，他看到这密密麻麻的软件完全不知所措。 于是乎，我就大略整理了一些我比较推荐的几款软件，同时分享给大家，希望对大家有所帮助！ 下面的一些软件都是我个人比较喜欢的，其实还有很多其他的恕不能一一列举了，如果大家有其他推荐的欢迎留言给我，谢谢！

日常工具

一些日常工具在这里我就不一一列举了，大部分使用 Mac 的小伙伴都会安装，比如 QQ、微信、Chrome 浏览器、网易云音乐、迅雷等等，这些在 Windows 上也几乎都是必备软件，这里就不再展开说明了。

效率工具

效率工具顾名思义，可以方便和简化 Mac 的操作，提高生产工作效率的工具，下面推荐几款我比较常用的。

Alfred

首推 Alfred，可以说是 Mac 必备软件，利用它我们可以快速地进行各种操作，大幅提高工作效率，如快速打开某个软件、快速打开某个链接、快速搜索某个文档，快速定位某个文件，快速查看本机 IP，快速定义某个色值，几乎你能想到的都能对接实现。 这些快速功能是怎么实现的呢？实际上是 Alfred 对接了很多 Workflow，我们可以使用 Workflow 方便地进行功能扩展，一些比较优秀的 Workflow 已经有人专门做过整理了，可以参见：https://github.com/zenorocha/alfred-workflows。 推荐指数：★★★★★

Todoist

大家肯定也在使用各种 Todo List 的软件，这种软件其实也是五花八门，经过我本人试用，我觉得 Todoist 这款软件是最方便的。 它支持各种类型的任务定制，还可以设置分组、优先级、Deadline、执行人员、提醒、协作、效率统计等功能。另外它的各个平台支持真是异常地全啊，网页、PC、移动端就不用说了，都必须有的，另外它还有浏览器插件版、电邮版、可穿戴设备（如 Apple Watch、Google Wear）版，另外他还可以和 Mac 的日历事件进行同步，日历添加的事件也会自动添加到 Todoist 里面，非常方便，是目前我体验过的最好用的一款。 这款软件个人推荐购买专业版解锁全部功能，一个月 3 刀，但个人觉得确实非常值。 推荐指数：★★★★☆

Paste

Mac 上默认只有一个粘贴板，当我们新复制了一段文字之后，如果我们想再找寻之前复制的历史记录就找不到了，这其实是很反人类的。 好在 Paste 这款软件帮我们解决了这个问题，它可以保存我们粘贴板的历史记录，等需要粘贴某个内容的时候只需要呼出 Paste 历史粘贴板，然后选择某个特定的内容粘贴就好了，另外它还支持文本格式调整粘贴板分类和搜索，还可以支持快速便捷粘贴。有了它，妈妈再也不用担心我的粘贴板丢失了！ 推荐指数：★★★★★

Synergy

工作时我会使用公司的台式机，是 Windows 系统，另外自己的个人笔记本 Mac 也会放在旁边，两台 PC 有时候会交替使用，但是我总不能配两套键盘和鼠标吧，这样就显得累赘了，而且也没那么多地方放啊。 有了 Synergy，我们可以将两台 PC 关联，实现键盘鼠标共享。我们可以使用一套键盘和鼠标来操作两台 PC，注意这是两个完全独立的 PC，各自有各自的屏幕和系统，使用 Synergy 我们可以做到一套键鼠同时控制两台电脑，鼠标可以直接从一台电脑的屏幕滑动到另一台电脑屏幕上，同时键盘、粘贴板也都是共享的。 设想这么个情景，我在我的台式机 Windows 上打开了一个页面，需要让我输入一个很长的序列号，而这个序列号又恰巧存在 Mac 上，这时如果有了 Synergy 将二者关联，我们只需要把鼠标从 Windows 的屏幕上直接滑动到 Mac 的屏幕上，选中序列号，然后键盘按下复制的快捷键，然后再把鼠标移回 Windows，粘贴即可，一气呵成。而不必再想办法发消息传输了，大大提高效率。 推荐指数：★★★★

Feedly、Reeder

博客现在已经越来越多了，越来越多的人开始在博客上发表文章，而当我们遇到优质的博客时，我们还想随时知道博客的发表动态，一旦有新文章发表我们想立马得到相关动态，这样可以实现吗？ 肯定是可行的，现在绝大多数博客都有 RSS 订阅功能，有了它我们可以订阅自己喜欢的博客，这里我使用的 RSS 订阅工具就是 Feedly，利用它我可以很轻松地添加自己喜欢的博客或论坛到自己的 Feed 流里面，一旦有文章更新，我就会收到相应提示。 但是 Feedly 有个小问题，就是在国内速度太慢了，所以我又使用 Reeder 将 Feedly 里面的 Feed 流做了转接，它可以添加 Feedly 源，并带有灵活的分类、标记等管理功能，还支持各种预览方式，还支持存储到 Pocket，还有各种分享方式，功能十分齐全。 总之，推荐 Feedly 来添加自己喜欢的博客，用 Reeder 来阅读订阅的内容，双剑合璧，另外 Reeder 对移动版的支持也很不错，可以体验一下。 推荐指数：★★★★

Mindnode

有时候在思考问题的时候我们想要把一些思路记录下来，另外在做一些概要设计的时候需要把概要图大体描述出来，这时候画一个思维导图再合适不过了，比如你现在读的这篇文章就很适合用一个思维导图画一下。 画思维导图我个人比较喜欢的一款软件是 Mindnode，觉得比较简洁好用，当然也有不少人使用 XMind，也很不错。可能是先入为主，也可能是界面设计风格，我个人更加偏向于使用 Mindnode。 推荐指数：★★★★

1Password

随着年龄的增长，我们可能变得越来越忘事了。另外还有些反人类的网站密码必须要至少大写、小写、数字、特殊符号，有的还要求不少于多少位，有的还要求我么能定时更换密码，还不能与之前用过的相同！这会使得我们之前预想设计的很多密码都没法用了。另外网站又这么多，谁又能把网站的密码都记下来啊？ 这时候我们就需要一款专门管理密码的软件，我个人推荐一款叫做 1Password，有了它我们可以将各个平台的密码保存起来，同时它还可以根据我们的要求帮我们随机生成一些密码并保存，这对注册一些新网站非常有用，同时使用随机的密码还降低了撞库的风险，不然一个平台的密码被盗了，其他平台用的同样的密码的话，就很不安全了。 1Password 还支持各种平台，如网页、PC、移动版都通通完美支持，实现密码云同步，妈妈再也不用担心我忘记密码了！ 推荐指数：★★★★

系统工具

下面介绍的两款系统工具软件几乎是装机必备的。

Tuxera NTFS For Mac

用了 Mac，我们在使用移动硬盘的时候可能会遇到一个无法传输数据（如拷贝文件）的问题，这是因为部分移动硬盘是 NTFS 格式的，而 Mac 的磁盘不是这个格式，因此就会导致二者之间无法拷贝文件。有一个解决方法就是使用 Tuxera NTFS For Mac，有了它，我们就可以比较顺利地拷贝文件了。 另外还有其他品牌的 NTFS For Mac 软件，也可以尝试使用一下。 推荐指数：★★★★☆

VMware、Parallels Desktop

用了 Mac 之后，难免会有些情况下也还会不得不使用 Windows，毕竟很多软件可能只有 Windows 版本，但用 Mac 我就不推荐装双系统了，直接装虚拟机就好了，Mac 上虚拟机软件有两款比较好用，一个就是著名的 VMware，另一个就是 Parallels Desktop，这两款我都使用过，觉得都非常不错，现在用的是 VMware。 推荐指数：★★★★☆

CleanMyMac

很多时候用着用着磁盘就不够用了，如果你的 Mac 硬盘是 512GB 的倒还好，256GB 的你就得多注意一下了，另外 1T 定制版土豪请绕道，这款软件不适合你。 CleanMyMac 可以非常方便地帮助我们扫描缓存、大文件、废纸篓、残留项等内容，清理这些内容之后我们可以节省很多硬盘空间，另外它还支持软件卸载和残留清扫功能，可以帮我们非常干净地移除 Mac 中的软件，目前应该是出到第三版了，非常推荐。 推荐指数：★★★★☆

编辑器

既然做程序开发嘛，不配置好自己的开发环境怎么行，下面推荐一下我平常使用的开发软件。

JetBrains

我目前使用的 IDE 是 JetBrains 全家桶，目前我编写 Python 比较多，所以主要使用 PyCharm，另外写前端的时候也会使用 WebStorm，写 Java 就用 IntelliJ IDEA，C、C++ 用 CLion，PHP 的话就用 PhpStorm，Ruby 的话就用 RubyMine，其他的语言用的就少了，就没有装了。 当然有的小伙伴会说 JetBrains 系列的 IDE 需要购买啊？我只想说，国人的力量是无穷的，在网上其实可以搜到各种破解方法，如 License Server 验证，你能搜到各种五花八门的 License Server。另外 JetBrains 还有专门的 Educational Programs，可以来这里申请：https://www.jetbrains.com/education/programs/?fromMenu，学生、老师或教育工作者可以使用学校的 edu 邮箱申请免费的 License，如果你还是学生的话，那么申请是十分方便的，因为我还是个学生，我目前就在使用学生套餐，当然如果你已经工作的话也可以向正在上学的弟弟妹妹们借一下嘛。 总之我个人比较喜欢 JetBrains 全家桶，不论是页面风格还是开发习惯我都比较喜欢，推荐使用。 推荐指数：★★★★☆

Sublime

有时候我们可能下载了或接收了一些单个的文本文件，我们只想看看文本文件内容是什么，或者对其再做一些简单的修改操作，这时候就没必要单独用 JetBrains 的 IDE 打开了，显得有点重了。或者有时候需要修改某个配置文件，这时候也需要一个比较好用的编辑器。我使用的就是 Sublime，对于一些日常的文本编辑是足够了，另外 Sublime 还可以扩展好多插件，配置好了功能上基本不输 JetBrains IDE，非常推荐。 推荐指数：★★★★

MarkEditor

现在越来越多的写作平台开始支持 MarkDown，不得不说这确实是一门提高文字生产效率的语言，写 MarkDown 我强烈推荐 MarkEditor，我之前尝试过各种 MarkDown 写作软件，觉得都不如这款好用，如 Typora、MWeb、GitBook 等等。 MarkEditor 支持写作及预览模式，更重要的是支持文件管理，很多软件如 Typora 只能打开单个的 Makrdown 文件，不能打开整个文件夹，这就很鸡肋了。另外 MarkEditor 支持直接插入图片，如我们截了一张图或者刚从网上复制了一张图，在 MarkEditor 里面直接粘贴就可以了，它会自动把这张图保存到当前目录下，同时生成 Makrdown 格式的的图片链接，不能更方便了！另外还支持主题自定义、样式自定义，还可以快速插入某些 Makrdown 元素，还支持 Latex 公式，还可以快速导出电子书，快速生成文稿网页，快速局域网共享，功能应有尽有，强烈推荐！ 这个软件我购买了 Pro 版，解锁了全部功能，订购地址：https://www.markeditor.com/，个人觉得物超所值！ 推荐指数：★★★★★

SnippetLab

在写代码的时候，我们经常会有一些常用代码或者精华代码，或者一些常用的配置，想要单独保存下来复用，这时我们可能会把它保存到某个文本文件里面，更高级点可以使用云笔记，如有道云笔记或者印象笔记，用过 GitHub Gists 的小伙伴可能会选择 GitHub Gists，但我觉得这些都不是最佳的。 首先文本文件、云笔记里面其实并不是专门为了保存代码使用的，另外 GitHub Gists 保存操作并没有那么便捷，而且打开速度也很慢，影响体验。在这里推荐一款专门用来保存代码的软件叫做 SnippetLab，涉设计初衷就是为了保存短代码片的，它支持几乎所有编程语言，另外支持分类、分级、加标签、加描述等，另外它还可以和 Alfred 对接实现快速搜索查找，另外还支持备份、导出、云同步等各种功能，非常适合做代码片的管理。 推荐指数：★★★★

Beyond Compare

有时候我们需要比较两个文件的不同之处，以便于快速得知两个版本的修改内容，我使用的软件是 Beyond Compare，个人觉得比较简洁好用，同时删除和添加的内容有对应的红绿颜色标识，推荐给大家使用。 推荐指数：★★★☆

管理工具

有时候我们需要管理很多文件，或者还需要远程管理很多终端设备，在这里推荐几款比较好用的工具。

Filezlla

有时候我们需要管理一些远程的服务器，比如 Linux 服务器。那么如何和这些服务器之间传递数据和文件呢？这里推荐一个轻便简洁的软件 Filezlla，它支持 FTP、SFTP 等协议类型，使用它我们可以方便地进行文件传输和远程文件管理。 推荐指数：★★★

ForkLift

Mac 上的 Finder 你是不是已经受够了？在一些方面做得相当不友好，例如在当前打开的目录下新建一个空白文件，在当前的目录下打开命令行工具等等，有了 ForkLift 这些都是小意思了。另外 ForkLift 还集成了 Filezlla 的功能，利用它我们还可以像普通文件管理器一样管理远程的主机内容，它还支持 FTP、SFTP、SMB、WebDAV、NFS 等等各种协议。同时界面也非常美观，有了它，几乎可以抛弃 Finder 和 Filezlla 了，强烈推荐！ 推荐指数：★★★★☆

SSH Shell

我们经常会和各种服务器打交道，例如我们经常使用 SSH 来远程连接某台 Linux 服务器，原生 Terminal 是支持 SSH 的，但你会发现原生带的这个太难用了。可能很多小伙伴使用 iTerm，不得不说这确实是个神器，大大方便了远程管理流程。但我在这里还要推荐一个我经常使用的 SSH Shell，没错，它的名字就是 SSH Shell，它的页面操作简洁，同时管理和记录远程主机十分方便，另外还支持秘钥管理、自动重连、自定义主题等等功能，个人用起来十分顺手，强烈推荐！ 推荐指数：★★★★☆

HomeBrew、CakeBrew

对于开发者来说，这个软件几乎是 Mac 上必备的一个软件，它的官方简介就是 “The missing package manager for macOS”，算是 Mac 上的一个软件包平台，它里面包含着非常多的 Mac 开发软件包，比如 Python、PHP、Redis、MySQL、RabbitMQ、HBase 等等，几乎你能想到的开发软件都集成在里面了，堪称神器！ 它的安装也非常简单，参见这里：https://brew.sh/，另外 HomeBrew 也有对应的图形界面，叫做 CakeBrew，如果不喜欢命令行操作的话可以使用 CakeBrew 来代替。 推荐指数：★★★★★

影音图像

IINA

这个必须要赞一下，非常强大简洁好用的视频播放器，是 GitHub 上的一个开源软件，链接是：https://lhc70000.github.io/iina/，播放控制、视频设置、音频设置、字幕设置、文件操作，几乎你能想到的应有尽有，而且无广告，简洁清爽，支持的视频格式也十分广泛，推荐使用！ 推荐指数：★★★★

ScreenFlow

之前我曾录制过一些 Python 的视频课程，本来尝试过 QuickTime 录制，可是实在是太难用了，另外视频剪辑、音频剪辑等又是个麻烦事。后来我就使用了 ScreenFlow，它集录制、剪辑、配音、字幕、特效等功能于一体，另外录制质量，渲染质量也是一流，大大提高了我的效率，堪称神器！ 推荐指数：★★★★☆

iPic

有时候我们在写 MarkDown 的时候，可能突然需要一张插入一张图片，比如我们想插入一张屏幕截图，我们就需要把这张图片先存下来，然后加上图片的路径，如果转发给别人还需要连着图片一并发给对方，这其实是不怎么方便的，倘若这张图片是一张来自网络的图片，我们直接用 HTTP 访问的话，那岂不是方便太多了？ 要将图片传到网上分几步？三步。第一步，把上传页面打开，第二步，把图片传到网上并把传后链接拷贝下来，第三步，把上传页面关闭。简直是太麻烦了对不对？另外找个合适的图床也是个麻烦事啊，七牛？又拍？你不得又得申请和注册。那么有了 iPic，一切就不是难事了，它可以监听 Mac 的粘贴板，一旦我们复制了一张图或者新截了一张图，它就能显示到待上传队列里面，我们点一下它就会把图片上传到网络上，然后生成上传后的链接，默认使用的是新浪的图床，网速也非常快。有了它，传图什么的都不是事了！另外付费版还支持各种自定义图床，如七牛云、又拍云、阿里云、腾讯云等等。 推荐指数：★★★★☆

PixelMator

在 Windows 上我们常用 PS 来修改和处理图片，Mac 上我是没有使用 PS，使用了 PixelMator，个人觉得使用这款软件能完全胜任 PS 的工作，一般的图片设计、排版、抠图、特效、蒙版等操作都支持，我个人比较喜欢使用这款软件做设计。 推荐指数：★★★★

Polarr Photo Editor

这个软件又名“泼辣修图”，类似 Mac 上的美图秀秀，它自带了各种后期滤镜，还带有 Lightroom 的很多调光调色的工具，能够帮我们快速对照片进行后期处理，效果也还不错，当然比不上 Photoshop 和 Lightroom 那么专业，但对于快速进行后处理的小伙伴来说不失为一个好的选择。 推荐指数：★★★★

Boom2

我有边工作边听歌的习惯，所以音乐几乎离不开我的生活，入了个好耳机，那当然就得配上好音乐。大家肯定也听说过音效均衡器，我们可以调整不同的音效参数来达到不同的声音效果，如电子音、人声、环绕、重低音等等，在 Mac 上我觉得最好用的就是 Boom2 了，它内置了各种音效均衡器，还有一些高保真效果的渲染，效果非常给力。我一般听歌的时候就会把 Boom2 开起来，享受不一样的音效感觉，美哉。 推荐指数：★★★★

趣味扩展

另外还有几个比较有意思的工具推荐下。

Tickeys

使用过机械键盘吗？按键感觉和声音很爽吧，但是用了 Mac，你如果不使用外接键盘的话，想必手感就差上不少，但这款软件或许可以拯救一下，它可以模拟机械键盘的按键声，每次按键都有有机械键盘清脆的声音，我平时戴耳机撸代码的时候就会开着这个软件，感觉体验还是不错的，建议尝试一下。 推荐指数：★★★☆

Duet

Duet 这款软件可以将 iPad 或 iPhone 变成电脑的扩展屏幕，如果你有一个大屏的比如 12.9 寸的 iPad 的话，非常建议你尝试一下这款软件，这样如果正你在用 Mac 不用 iPad 的话，完全可以用 Duet 把 iPad 和电脑屏幕连接起来来扩展显示，充分利用资源。 推荐指数：★★★☆ 好了，暂时推荐这么多，其实还有很多很多，尤其是专门针对于开发者的一些工具，这些就太偏极客化了，后面再为大家整理一些好用的开发者工具，敬请期待。 还不尽兴的小伙伴可以关注 GitHub 上的一个仓库叫 awesome-mac，里面列出来了 Mac 上推荐的非常多的软件，总结得非常非常详细，链接是：https://github.com/jaywcjlove/awesome-mac，大家可以去看下。

Tips

可能有的小伙伴好奇我的 Launchpad 为啥能放那么多图标，是怎么做到的？其实很简单，几行代码就搞定了。 调整每列显示图标数量，这里以 7 为例：

1

defaults write com.apple.dock springboard-rows -int 7

调整每行显示图标的数量，这里以 8 为例：

1

defaults write com.apple.dock springboard-columns -int 8

上面两行代码最后的数字可以自行修改。 修改完了之后还需要重置一下 Launchpad，代码如下：

1

defaults write com.apple.dock ResetLaunchPad -bool TRUE;killall Dock

好了，这样我们就可以自由定制我们的 Launchpad 图标数量啦！ 另外，还有的小伙伴会说，很多软件都需要花钱购买啊，咋办？告诉你个网址：http://xclient.info/，几乎你想找的破解版都有，别说别的了，雷锋也别叫了，省下的钱打赏给我一点就行哈哈。 以上就是我的一些 Mac 常用软件分享及 Tips，希望对大家有帮助！ 另外大家如有还有推荐的软件，欢迎留言给我，非常感谢！

嗨~ 给大家重磅推荐一本书！上市两月就已经重印 4 次的 Python 爬虫书！它就是由静觅博客博主崔庆才所作的《Python3 网络爬虫开发实战》！！！同时文末还有抽奖赠书活动，不容错过！！！

书籍介绍

本书《Python3 网络爬虫开发实战》全面介绍了利用 Python3 开发网络爬虫的知识，书中首先详细介绍了各种类型的环境配置过程和爬虫基础知识，还讨论了 urllib、requests 等请求库和 Beautiful Soup、XPath、pyquery 等解析库以及文本和各类数据库的存储方法，另外本书通过多个真实新鲜案例介绍了分析 Ajax 进行数据爬取，Selenium 和 Splash 进行动态网站爬取的过程，接着又分享了一些切实可行的爬虫技巧，比如使用代理爬取和维护动态代理池的方法、ADSL 拨号代理的使用、各类验证码（图形、极验、点触、宫格等）的破解方法、模拟登录网站爬取的方法及 Cookies 池的维护等等。 此外，本书的内容还远远不止这些，作者还结合移动互联网的特点探讨了使用 Charles、mitmdump、Appium 等多种工具实现 App 抓包分析、加密参数接口爬取、微信朋友圈爬取的方法。此外本书还详细介绍了 pyspider 框架、Scrapy 框架的使用和分布式爬虫的知识，另外对于优化及部署工作，本书还包括 Bloom Filter 效率优化、Docker 和 Scrapyd 爬虫部署、分布式爬虫管理框架 Gerapy 的分享。 全书共 604 页，足足两斤重呢~ 定价为 99 元！

作者介绍

看书就先看看谁写的嘛，我们来了解一下~ 崔庆才，静觅博客博主（https://cuiqingcai.com），博客 Python 爬虫博文阅读量已过千万，北京航空航天大学硕士，天善智能、网易云课堂讲师，微软小冰大数据工程师，有多个大型分布式爬虫项目经验，乐于技术分享，文章通俗易懂 ^^ 附皂片一张 ~(@^^@)~

图文介绍

呕心沥血设计的宣传图也得放一下~

专家评论

书是好是坏，得让专家看评一评呀，那么下面就是几位专家的精彩评论，快来看看吧~ 在互联网软件开发工程师的分类中，爬虫工程师是非常重要的。爬虫工作往往是一个公司核心业务开展的基础，数据抓取下来，才有后续的加工处理和最终展现。此时数据的抓取规模、稳定性、实时性、准确性就显得非常重要。早期的互联网充分开放互联，数据获取的难度很小。随着各大公司对数据资产日益看重，反爬水平也在不断提高，各种新技术不断给爬虫软件提出新的课题。本书作者对爬虫的各个领域都有深刻研究，书中探讨了 Ajax 数据的抓取、动态渲染页面的抓取、验证码识别、模拟登录等高级话题，同时也结合移动互联网的特点探讨了 App 的抓取等。更重要的是，本书提供了大量源码，可以帮助读者更好地理解相关内容。强烈推荐给各位技术爱好者阅读！

——梁斌，八友科技总经理

数据既是当今大数据分析的前提，也是各种人工智能应用场景的基础。得数据者得天下，会爬虫者走遍天下也不怕！一册在手，让小白到老司机都能有所收获！

——李舟军，北京航空航天大学教授，博士生导师

本书从爬虫入门到分布式抓取，详细介绍了爬虫技术的各个要点，并针对不同的场景提出了对应的解决方案。另外，书中通过大量的实例来帮助读者更好地学习爬虫技术，通俗易懂，干货满满。强烈推荐给大家！

——宋睿华，微软小冰首席科学家

有人说中国互联网的带宽全给各种爬虫占据了，这说明网络爬虫的重要性以及中国互联网数据封闭垄断的现状。爬是一种能力，爬是为了不爬。

——施水才，北京拓尔思信息技术股份有限公司总裁

全书目录

书的目录也有~ 看这里！

• 1-开发环境配置
• 1.1-Python3 的安装
• 1.2-请求库的安装
• 1.3-解析库的安装
• 1.4-数据库的安装
• 1.5-存储库的安装
• 1.6-Web 库的安装
• 1.7-App 爬取相关库的安装
• 1.8-爬虫框架的安装
• 1.9-部署相关库的安装
• 2-爬虫基础
• 2.1-HTTP 基本原理
• 2.2-网页基础
• 2.3-爬虫的基本原理
• 2.4-会话和 Cookies
• 2.5-代理的基本原理
• 3-基本库的使用
• 3.1-使用 urllib
• 3.1.1-发送请求
• 3.1.2-处理异常
• 3.1.3-解析链接
• 3.1.4-分析 Robots 协议
• 3.2-使用 requests
• 3.2.1-基本用法
• 3.2.2-高级用法
• 3.3-正则表达式
• 3.4-抓取猫眼电影排行
• 4-解析库的使用
• 4.1-使用 XPath
• 4.2-使用 Beautiful Soup
• 4.3-使用 pyquery
• 5-数据存储
• 5.1-文件存储
• 5.1.1-TXT 文本存储
• 5.1.2-JSON 文件存储
• 5.1.3-CSV 文件存储
• 5.2-关系型数据库存储
• 5.2.1-MySQL 存储
• 5.3-非关系型数据库存储
• 5.3.1-MongoDB 存储
• 5.3.2-Redis 存储
• 6-Ajax 数据爬取
• 6.1-什么是 Ajax
• 6.2-Ajax 分析方法
• 6.3-Ajax 结果提取
• 6.4-分析 Ajax 爬取今日头条街拍美图
• 7-动态渲染页面爬取
• 7.1-Selenium 的使用
• 7.2-Splash 的使用
• 7.3-Splash 负载均衡配置
• 7.4-使用 Selenium 爬取淘宝商品
• 8-验证码的识别
• 8.1-图形验证码的识别
• 8.2-极验滑动验证码的识别
• 8.3-点触验证码的识别
• 8.4-微博宫格验证码的识别
• 9-代理的使用
• 9.1-代理的设置
• 9.2-代理池的维护
• 9.3-付费代理的使用
• 9.4-ADSL 拨号代理
• 9.5-使用代理爬取微信公众号文章
• 10-模拟登录
• 10.1-模拟登录并爬取 GitHub
• 10.2-Cookies 池的搭建
• 11-App 的爬取
• 11.1-Charles 的使用
• 11.2-mitmproxy 的使用
• 11.3-mitmdump 爬取“得到”App 电子书信息
• 11.4-Appium 的基本使用
• 11.5-Appium 爬取微信朋友圈
• 11.6-Appium+mitmdump 爬取京东商品
• 12-pyspider 框架的使用
• 12.1-pyspider 框架介绍
• 12.2-pyspider 的基本使用
• 12.3-pyspider 用法详解
• 13-Scrapy 框架的使用
• 13.1-Scrapy 框架介绍
• 13.2-Scrapy 入门
• 13.3-Selector 的用法
• 13.4-Spider 的用法
• 13.5-Downloader Middleware 的用法
• 13.6-Spider Middleware 的用法
• 13.7-Item Pipeline 的用法
• 13.8-Scrapy 对接 Selenium
• 13.9-Scrapy 对接 Splash
• 13.10-Scrapy 通用爬虫
• 13.11-Scrapyrt 的使用
• 13.12-Scrapy 对接 Docker
• 13.13-Scrapy 爬取新浪微博
• 14-分布式爬虫
• 14.1-分布式爬虫原理
• 14.2-Scrapy-Redis 源码解析
• 14.3-Scrapy 分布式实现
• 14.4-Bloom Filter 的对接
• 15-分布式爬虫的部署
• 15.1-Scrapyd 分布式部署
• 15.2-Scrapyd-Client 的使用
• 15.3-Scrapyd 对接 Docker
• 15.4-Scrapyd 批量部署
• 15.5-Gerapy 分布式管理

购买链接

想必很多小伙伴已经等了很久了，之前预售那么久也一直迟迟没有货，发售就有不少网店又售空了，不过现在起不用担心了！

书籍现已在京东、天猫、当当等网店上架并全面供应啦，复制链接到浏览器打开或扫描二维码打开即可购买了！

京东商城

https://item.jd.com/12333540.html

天猫商城

https://detail.tmall.com/item.htm?id=566699703917

当当网

http://product.dangdang.com/25249602.html

欢迎大家购买，谢谢支持！O(∩_∩)O

免费预览

不放心？想先看看有些啥，没问题！看这里： 免费章节试读（复制粘贴至浏览器打开）： https://cuiqingcai.com/5052.html 将一直免费开放前 7 章节，欢迎大家试读！ 好了，接下来就是我们的福利环节啦~

福利一：抽奖送书！！！

恭喜你看到这里了！那么接下来的福利时间就到了！后面还有两个福利不容错过哦~ 抽奖送书活动第二波来袭（后面还有很多波哦），公众号抽奖送 30 本作者亲笔签名书籍！！！ 活动流程（重要，请一定认真阅读）： 公众号进击的 Coder 回复 “抽奖” 获取抽奖码，2018.6.24 22:00 截止，逾期参与无效，请记住您的抽奖码，活动结束后会从参与活动的小伙伴中根据幸运值按照权重比例抽取 30 位并在微信公众号公布，届时请关注公众号抽奖结果的公布！获奖的小伙伴会获得作者亲笔签名的《Python3 网络爬虫开发实战》一本。

福利二：独家优惠！！！

等等，你以为这就是全部福利吗？当然不是！除了抽奖送书，我们还拿到了拨号 VPS 知名品牌云立方的独家优惠，在公众号（进击的 Coder ）中回复：“优惠券”，即可免费领取云立方 50 元主机优惠券，数量有限，先到先得！优惠券可在云立方官网（www.yunlifang.cn）购买动态IP拨号VPS时抵扣现金，有了它，爬虫代理易如反掌！ 你问我动态拨号 VPS 能做什么？应该怎么用在爬虫里？来这里了解一下： 轻松获得海量稳定代理！ADSL 拨号代理的搭建

福利三：视频课程！！！

当然除了书籍，也有配套的视频课程，作者同样是崔庆才，二者结合学习效果更佳！限时优惠折扣中！扫描下图中二维码即可了解详情！ 最后也是最重要的就是参与活动的地址了！！！快来扫码回复领取属于你的福利吧！！！

特别致谢

最后特别感谢云立方、天善智能对本活动的大力支持！

在做自然语言处理的过程中，我们经常会遇到需要找出相似语句的场景，或者找出句子的近似表达，这时候我们就需要把类似的句子归到一起，这里面就涉及到句子相似度计算的问题，那么本节就来了解一下怎么样来用 Python 实现句子相似度的计算。

基本方法

句子相似度计算我们一共归类了以下几种方法：

• 编辑距离计算
• 杰卡德系数计算
• TF 计算
• TFIDF 计算
• Word2Vec 计算

下面我们来一一了解一下这几种算法的原理和 Python 实现。

编辑距离计算

编辑距离，英文叫做 Edit Distance，又称 Levenshtein 距离，是指两个字串之间，由一个转成另一个所需的最少编辑操作次数，如果它们的距离越大，说明它们越是不同。许可的编辑操作包括将一个字符替换成另一个字符，插入一个字符，删除一个字符。 例如我们有两个字符串：string 和 setting，如果我们想要把 string 转化为 setting，需要这么两步：

• 第一步，在 s 和 t 之间加入字符 e。
• 第二步，把 r 替换成 t。

所以它们的编辑距离差就是 2，这就对应着二者要进行转化所要改变（添加、替换、删除）的最小步数。 那么用 Python 怎样来实现呢，我们可以直接使用 distance 库：

1
2
3
4
5
6
7
8

import distance

def edit_distance(s1, s2):
    return distance.levenshtein(s1, s2)

s1 = 'string'
s2 = 'setting'
print(edit_distance(s1, s2))

这里我们直接使用 distance 库的 levenshtein() 方法，传入两个字符串，即可获取两个字符串的编辑距离了。 运行结果如下：

1

2

这里的 distance 库我们可以直接使用 pip3 来安装：

1

pip3 install distance

这样如果我们想要获取相似的文本的话可以直接设定一个编辑距离的阈值来实现，如设置编辑距离为 2，下面是一个样例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

import distance

def edit_distance(s1, s2):
    return distance.levenshtein(s1, s2)

strings = [
    '你在干什么',
    '你在干啥子',
    '你在做什么',
    '你好啊',
    '我喜欢吃香蕉'
]

target = '你在干啥'
results = list(filter(lambda x: edit_distance(x, target) <= 2, strings))
print(results)

这里我们定义了一些字符串，然后定义了一个目标字符串，然后用编辑距离 2 的阈值进行设定，最后得到的结果就是编辑距离在 2 及以内的结果，运行结果如下：

1

['你在干什么', '你在干啥子']

通过这种方式我们可以大致筛选出类似的句子，但是发现一些句子例如“你在做什么” 就没有被识别出来，但他们的意义确实是相差不大的，因此，编辑距离并不是一个好的方式，但是简单易用。

杰卡德系数计算

杰卡德系数，英文叫做 Jaccard index, 又称为 Jaccard 相似系数，用于比较有限样本集之间的相似性与差异性。Jaccard 系数值越大，样本相似度越高。 实际上它的计算方式非常简单，就是两个样本的交集除以并集得到的数值，当两个样本完全一致时，结果为 1，当两个样本完全不同时，结果为 0。 算法非常简单，就是交集除以并集，下面我们用 Python 代码来实现一下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

from sklearn.feature_extraction.text import CountVectorizer
import numpy as np


def jaccard_similarity(s1, s2):
    def add_space(s):
        return ' '.join(list(s))
    
    # 将字中间加入空格
    s1, s2 = add_space(s1), add_space(s2)
    # 转化为TF矩阵
    cv = CountVectorizer(tokenizer=lambda s: s.split())
    corpus = [s1, s2]
    vectors = cv.fit_transform(corpus).toarray()
    # 求交集
    numerator = np.sum(np.min(vectors, axis=0))
    # 求并集
    denominator = np.sum(np.max(vectors, axis=0))
    # 计算杰卡德系数
    return 1.0 * numerator / denominator


s1 = '你在干嘛呢'
s2 = '你在干什么呢'
print(jaccard_similarity(s1, s2))

这里我们使用了 Sklearn 库中的 CountVectorizer 来计算句子的 TF 矩阵，然后利用 Numpy 来计算二者的交集和并集，随后计算杰卡德系数。 这里值得学习的有 CountVectorizer 的用法，通过它的 fit_transform() 方法我们可以将字符串转化为词频矩阵，例如这里有两句话“你在干嘛呢”和“你在干什么呢”，首先 CountVectorizer 会计算出不重复的有哪些字，会得到一个字的列表，结果为：

1

['么', '什', '你', '呢', '嘛', '在', '干']

这个其实可以通过如下代码来获取，就是获取词表内容：

1

cv.get_feature_names()

接下来通过转化之后，vectors 变量就变成了：

1
2

[[0 0 1 1 1 1 1]
 [1 1 1 1 0 1 1]]

它对应的是两个句子对应词表的词频统计，这里是两个句子，所以结果是一个长度为 2 的二维数组，比如第一句话“你在干嘛呢”中不包含“么”字，那么第一个“么”字对应的结果就是0，即数量为 0，依次类推。 后面我们使用了 np.min() 方法并传入了 axis 为 0，实际上就是获取了每一列的最小值，这样实际上就是取了交集，np.max() 方法是获取了每一列的最大值，实际上就是取了并集。 二者分别取和即是交集大小和并集大小，然后作商即可，结果如下：

1

0.5714285714285714

这个数值越大，代表两个字符串越接近，否则反之，因此我们也可以使用这个方法，并通过设置一个相似度阈值来进行筛选。

TF 计算

第三种方案就是直接计算 TF 矩阵中两个向量的相似度了，实际上就是求解两个向量夹角的余弦值，就是点乘积除以二者的模长，公式如下：

1

cosθ=a·b/|a|*|b|

上面我们已经获得了 TF 矩阵，下面我们只需要求解两个向量夹角的余弦值就好了，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

from sklearn.feature_extraction.text import CountVectorizer
import numpy as np
from scipy.linalg import norm

def tf_similarity(s1, s2):
    def add_space(s):
        return ' '.join(list(s))
    
    # 将字中间加入空格
    s1, s2 = add_space(s1), add_space(s2)
    # 转化为TF矩阵
    cv = CountVectorizer(tokenizer=lambda s: s.split())
    corpus = [s1, s2]
    vectors = cv.fit_transform(corpus).toarray()
    # 计算TF系数
    return np.dot(vectors[0], vectors[1]) / (norm(vectors[0]) * norm(vectors[1]))


s1 = '你在干嘛呢'
s2 = '你在干什么呢'
print(tf_similarity(s1, s2))

在在这里我们使用了 np.dot() 方法获取了向量的点乘积，然后通过 norm() 方法获取了向量的模长，经过计算得到二者的 TF 系数，结果如下：

1

0.7302967433402214

TFIDF 计算

另外除了计算 TF 系数我们还可以计算 TFIDF 系数，TFIDF 实际上就是在词频 TF 的基础上再加入 IDF 的信息，IDF 称为逆文档频率，不了解的可以看下阮一峰老师的讲解：http://www.ruanyifeng.com/blog/2013/03/tf-idf.html，里面对 TFIDF 的讲解也是十分透彻的。 下面我们还是借助于 Sklearn 中的模块 TfidfVectorizer 来实现，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

from sklearn.feature_extraction.text import TfidfVectorizer
import numpy as np
from scipy.linalg import norm


def tfidf_similarity(s1, s2):
    def add_space(s):
        return ' '.join(list(s))
    
    # 将字中间加入空格
    s1, s2 = add_space(s1), add_space(s2)
    # 转化为TF矩阵
    cv = TfidfVectorizer(tokenizer=lambda s: s.split())
    corpus = [s1, s2]
    vectors = cv.fit_transform(corpus).toarray()
    # 计算TF系数
    return np.dot(vectors[0], vectors[1]) / (norm(vectors[0]) * norm(vectors[1]))


s1 = '你在干嘛呢'
s2 = '你在干什么呢'
print(tfidf_similarity(s1, s2))

这里的 vectors 变量实际上就对应着 TFIDF 值，内容如下：

1
2

[[0.         0.         0.4090901  0.4090901  0.57496187 0.4090901 0.4090901 ]
 [0.49844628 0.49844628 0.35464863 0.35464863 0.  0.35464863 0.35464863]]

运行结果如下：

1

0.5803329846765686

所以通过 TFIDF 系数我们也可以进行相似度的计算。

Word2Vec 计算

Word2Vec，顾名思义，其实就是将每一个词转换为向量的过程。如果不了解的话可以参考：https://blog.csdn.net/itplus/article/details/37969519。 这里我们可以直接下载训练好的 Word2Vec 模型，模型的链接地址为：https://pan.baidu.com/s/1TZ8GII0CEX32ydjsfMc0zw，是使用新闻、百度百科、小说数据来训练的 64 维的 Word2Vec 模型，数据量很大，整体效果还不错，我们可以直接下载下来使用，这里我们使用的是 news_12g_baidubaike_20g_novel_90g_embedding_64.bin 数据，然后实现 Sentence2Vec，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

import gensim
import jieba
import numpy as np
from scipy.linalg import norm

model_file = './word2vec/news_12g_baidubaike_20g_novel_90g_embedding_64.bin'
model = gensim.models.KeyedVectors.load_word2vec_format(model_file, binary=True)

def vector_similarity(s1, s2):
    def sentence_vector(s):
        words = jieba.lcut(s)
        v = np.zeros(64)
        for word in words:
            v += model[word]
        v /= len(words)
        return v
    
    v1, v2 = sentence_vector(s1), sentence_vector(s2)
    return np.dot(v1, v2) / (norm(v1) * norm(v2))

在获取 Sentence Vector 的时候，我们首先对句子进行分词，然后对分好的每一个词获取其对应的 Vector，然后将所有 Vector 相加并求平均，这样就可得到 Sentence Vector 了，然后再计算其夹角余弦值即可。 调用示例如下：

1
2
3

s1 = '你在干嘛'
s2 = '你正做什么'
vector_similarity(s1, s2)

结果如下：

1

0.6701133967824016

这时如果我们再回到最初的例子看下效果：

1
2
3
4
5
6
7
8
9
10
11
12

strings = [
    '你在干什么',
    '你在干啥子',
    '你在做什么',
    '你好啊',
    '我喜欢吃香蕉'
]

target = '你在干啥'

for string in strings:
    print(string, vector_similarity(string, target))

依然是前面的例子，我们看下它们的匹配度结果是多少，运行结果如下：

1
2
3
4
5

你在干什么 0.8785495016487204
你在干啥子 0.9789649689827049
你在做什么 0.8781992402695274
你好啊 0.5174225914249863
我喜欢吃香蕉 0.582990841450621

可以看到相近的语句相似度都能到 0.8 以上，而不同的句子相似度都不足 0.6，这个区分度就非常大了，可以说有了 Word2Vec 我们可以结合一些语义信息来进行一些判断，效果明显也好很多。 所以总体来说，Word2Vec 计算的方式是非常好的。 另外学术界还有一些可能更好的研究成果，这个可以参考知乎上的一些回答：https://www.zhihu.com/question/29978268/answer/54399062。 以上便是进行句子相似度计算的基本方法和 Python 实现，本节代码地址：https://github.com/AIDeepLearning/SentenceDistance。

Scrapy-Redis 详解

通常我们在一个站站点进行采集的时候，如果是小站的话 我们使用scrapy本身就可以满足。 但是如果在面对一些比较大型的站点的时候，单个scrapy就显得力不从心了。 要是我们能够多个Scrapy一起采集该多好啊 人多力量大。 很遗憾Scrapy官方并不支持多个同时采集一个站点，虽然官方给出一个方法： 将一个站点的分割成几部分 交给不同的scrapy去采集 似乎是个解决办法，但是很麻烦诶！毕竟分割很麻烦的哇 下面就改轮到我们的额主角Scrapy-Redis登场了！

什么？？你这么就登场了？还没说为什么呢？

好吧 为了简单起见 就用官方图来简单说明一下： 这张图大家相信大家都很熟悉了。重点看一下SCHEDULER 1. 先来看看官方对于SCHEDULER的定义： SCHEDULER接受来自Engine的Requests,并将它们放入队列（可以按顺序优先级），以便在之后将其提供给Engine 点我看文档 2. 现在我们来看看SCHEDULER都提供了些什么功能： 根据官方文档说明 在我们没有没有指定 SCHEDULER 参数时，默认使用：’scrapy.core.scheduler.Scheduler’ 作为SCHEDULER(调度器) scrapy.core.scheduler.py:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

class Scheduler(object):

    def __init__(self, dupefilter, jobdir=None, dqclass=None, mqclass=None,
                 logunser=False, stats=None, pqclass=None):
        self.df = dupefilter
        self.dqdir = self._dqdir(jobdir)
        self.pqclass = pqclass
        self.dqclass = dqclass
        self.mqclass = mqclass
        self.logunser = logunser
        self.stats = stats
        # 注意在scrpy中优先注意这个方法，此方法是一个钩子 用于访问当前爬虫的配置
    @classmethod
    def from_crawler(cls, crawler):
        settings = crawler.settings
        # 获取去重用的类 默认：scrapy.dupefilters.RFPDupeFilter
        dupefilter_cls = load_object(settings['DUPEFILTER_CLASS'])
        # 对去重类进行配置from_settings 在 scrapy.dupefilters.RFPDupeFilter 43行
        # 这种调用方式对于IDE跳转不是很好  所以需要自己去找
        # @classmethod
        # def from_settings(cls, settings):
        #     debug = settings.getbool('DUPEFILTER_DEBUG')
        #     return cls(job_dir(settings), debug)
        # 上面就是from_settings方法 其实就是设置工作目录 和是否开启debug
        dupefilter = dupefilter_cls.from_settings(settings)
        # 获取优先级队列 类对象 默认：queuelib.pqueue.PriorityQueue
        pqclass = load_object(settings['SCHEDULER_PRIORITY_QUEUE'])
        # 获取磁盘队列 类对象（SCHEDULER使用磁盘存储 重启不会丢失）
        dqclass = load_object(settings['SCHEDULER_DISK_QUEUE'])
        # 获取内存队列 类对象（SCHEDULER使用内存存储 重启会丢失）
        mqclass = load_object(settings['SCHEDULER_MEMORY_QUEUE'])
        # 是否开启debug
        logunser = settings.getbool('LOG_UNSERIALIZABLE_REQUESTS', settings.getbool('SCHEDULER_DEBUG'))
        # 将这些参数传递给 __init__方法
        return cls(dupefilter, jobdir=job_dir(settings), logunser=logunser,
                   stats=crawler.stats, pqclass=pqclass, dqclass=dqclass, mqclass=mqclass)


    def has_pending_requests(self):
      """检查是否有没处理的请求"""
        return len(self) > 0

    def open(self, spider):
      """Engine创建完毕之后会调用这个方法"""
        self.spider = spider
        # 创建一个有优先级的内存队列 实例化对象
        # self.pqclass 默认是：queuelib.pqueue.PriorityQueue
        # self._newmq 会返回一个内存队列的 实例化对象 在110  111 行
        self.mqs = self.pqclass(self._newmq)
        # 如果self.dqdir 有设置 就创建一个磁盘队列 否则self.dqs 为空
        self.dqs = self._dq() if self.dqdir else None
        # 获得一个去重实例对象 open 方法是从BaseDupeFilter继承的
        # 现在我们可以用self.df来去重啦
        return self.df.open()

    def close(self, reason):
      """当然Engine关闭时"""
          # 如果有磁盘队列 则对其进行dump后保存到active.json文件中
        if self.dqs:
            prios = self.dqs.close()
            with open(join(self.dqdir, 'active.json'), 'w') as f:
                json.dump(prios, f)
        # 然后关闭去重
        return self.df.close(reason)

    def enqueue_request(self, request):
      """添加一个Requests进调度队列"""
          # self.df.request_seen是检查这个Request是否已经请求过了 如果有会返回True
        if not request.dont_filter and self.df.request_seen(request):
              # 如果Request的dont_filter属性没有设置（默认为False）和 已经存在则去重
            # 不push进队列
            self.df.log(request, self.spider)
            return False
        # 先尝试将Request push进磁盘队列
        dqok = self._dqpush(request)
        if dqok:
              # 如果成功 则在记录一次状态
            self.stats.inc_value('scheduler/enqueued/disk', spider=self.spider)
        else:
              # 不能添加进磁盘队列则会添加进内存队列
            self._mqpush(request)
            self.stats.inc_value('scheduler/enqueued/memory', spider=self.spider)
        self.stats.inc_value('scheduler/enqueued', spider=self.spider)
        return True

    def next_request(self):
      """从队列中获取一个Request"""
          # 优先从内存队列中获取
        request = self.mqs.pop()
        if request:
            self.stats.inc_value('scheduler/dequeued/memory', spider=self.spider)
        else:
              # 不能获取的时候从磁盘队列队里获取
            request = self._dqpop()
            if request:
                self.stats.inc_value('scheduler/dequeued/disk', spider=self.spider)
        if request:
            self.stats.inc_value('scheduler/dequeued', spider=self.spider)
        # 将获取的到Request返回给Engine
        return request

    def __len__(self):
        return len(self.dqs) + len(self.mqs) if self.dqs else len(self.mqs)

    def _dqpush(self, request):
        if self.dqs is None:
            return
        try:
            reqd = request_to_dict(request, self.spider)
            self.dqs.push(reqd, -request.priority)
        except ValueError as e:  # non serializable request
            if self.logunser:
                msg = ("Unable to serialize request: %(request)s - reason:"
                       " %(reason)s - no more unserializable requests will be"
                       " logged (stats being collected)")
                logger.warning(msg, {'request': request, 'reason': e},
                               exc_info=True, extra={'spider': self.spider})
                self.logunser = False
            self.stats.inc_value('scheduler/unserializable',
                                 spider=self.spider)
            return
        else:
            return True

    def _mqpush(self, request):
        self.mqs.push(request, -request.priority)

    def _dqpop(self):
        if self.dqs:
            d = self.dqs.pop()
            if d:
                return request_from_dict(d, self.spider)

    def _newmq(self, priority):
        return self.mqclass()

    def _newdq(self, priority):
        return self.dqclass(join(self.dqdir, 'p%s' % priority))

    def _dq(self):
        activef = join(self.dqdir, 'active.json')
        if exists(activef):
            with open(activef) as f:
                prios = json.load(f)
        else:
            prios = ()
        q = self.pqclass(self._newdq, startprios=prios)
        if q:
            logger.info("Resuming crawl (%(queuesize)d requests scheduled)",
                        {'queuesize': len(q)}, extra={'spider': self.spider})
        return q

    def _dqdir(self, jobdir):
        if jobdir:
            dqdir = join(jobdir, 'requests.queue')
            if not exists(dqdir):
                os.makedirs(dqdir)
            return dqdir

只挑了一些重点的写了一些注释剩下大家自己领会(才不是我懒哦 ) 从上面的代码 我们可以很清楚的知道 SCHEDULER的主要是完成了 push Request pop Request 和 去重的操作。 而且queue 操作是在内存队列中完成的。 大家看queuelib.queue就会发现基于内存的（deque） 那么去重呢？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31