这博文写得我懒癌犯了，最后的那个章节内容排序，我没有实验是否是正确的，不过这只是个教大家用 Scrapy 的教程，正确与否并不重要··· 如果不正确，记得留言；等我懒癌过了，我再改改······ 还有其它的问题也是一样··· ，把问题留言下； 等我懒癌过了·· 我改回来！嗯！是等我懒癌结束了，再改。 前面几篇博文，给大家从头到尾做了一个比较高效的爬虫，从这篇起来说说 Python 的爬虫框架 Scrapy； 至于为什么要说框架呢？因为啊，框架可以帮我们处理一部分事情，比如下载模块不用我们自己写了，我们只需专注于提取数据就好了； 最重要的一点啊！框架使用了异步的模式;可以加快我们的下载速度，而不用自己去实现异步框架；毕竟实现异步爬虫是一件比较麻烦的事情。 不过啊！反爬虫这个坎还是要我们自己迈过去啊！这是后话，以后再说。我们先来让 Scrapy 能跑起来，并提取出我们需要的数据，再解决其它问题。 官方文档在这儿：点我 环境搭建： 关于这一点，对在 Windows 环境下使用的小伙伴来说，请务必使用我之前提到的 Anaconda 这个 Python 的发行版本，不然光环境的各种报错就能消磨掉你所有的学习兴趣！ 下载地址在这儿：http://pan.baidu.com/s/1pLgySav 安装完成之后，在 cmd 中执行：conda install Scrapy (如果需要使用特定版本，请在 Scrapy 后面加上 ==XXXX XXXX 代表你需要的版本号) 下面是安装示意图： So Easy@@！环境搭建完成！是不是超简单？全程无痛啊！ 下面开始踏上新的征程！Go Go Go！！ 使用 Scrapy 第一步：创建项目；CMD 进入你需要放置项目的目录 输入：

1

scrapy startproject XXXXX             XXXXX代表你项目的名字

OK 项目创建完成。现在可以开始我们的爬取之旅了！ 下面是目录中各个文件的作用 好了，目录我们认识完了，在开始之前给大家一个小技巧，Scrapy 默认是不能在 IDE 中调试的，我们在根目录中新建一个 py 文件叫：entrypoint.py；在里面写入以下内容：

1
2

from scrapy.cmdline import execute
execute(['scrapy', 'crawl', 'dingdian'])

注意！第二行中代码中的前两个参数是不变的，第三个参数请使用自己的 spider 的名字。稍后我会讲到！！ 现在整个目录看起来是这样： 基础工作准备完毕！我们来说说基本思路。 上面的准备工作完成之后，我们先不要着急开始工作，毕竟作为一个框架，还是很复杂的；贸然上手 开整，很容易陷入懵逼状态啊！一团浆糊，理不清思路，后面的事情做起来很很麻烦啦！ 我们来看看下面这张图： 这就是整个 Scrapy 的架构图了； Scrapy Engine: 这是引擎，负责 Spiders、ItemPipeline、Downloader、Scheduler 中间的通讯，信号、数据传递等等！（像不像人的身体？） Scheduler(调度器): 它负责接受引擎发送过来的 requests 请求，并按照一定的方式进行整理排列，入队、并等待 Scrapy Engine(引擎)来请求时，交给引擎。 Downloader（下载器）：负责下载 Scrapy Engine(引擎)发送的所有 Requests 请求，并将其获取到的 Responses 交还给 Scrapy Engine(引擎)，由引擎交给 Spiders 来处理， Spiders：它负责处理所有 Responses,从中分析提取数据，获取 Item 字段需要的数据，并将需要跟进的 URL 提交给引擎，再次进入 Scheduler(调度器)， Item Pipeline：它负责处理 Spiders 中获取到的 Item，并进行处理，比如去重，持久化存储（存数据库，写入文件，总之就是保存数据用的） Downloader Middlewares（下载中间件）：你可以当作是一个可以自定义扩展下载功能的组件 Spider Middlewares（Spider 中间件）：你可以理解为是一个可以自定扩展和操作引擎和 Spiders 中间‘通信‘的功能组件（比如进入 Spiders 的 Responses;和从 Spiders 出去的 Requests） 数据在整个 Scrapy 的流向： 程序运行的时候， 引擎：Hi！Spider, 你要处理哪一个网站？ Spiders：我要处理 23wx.com 引擎：你把第一个需要的处理的 URL 给我吧。 Spiders：给你第一个 URL 是 XXXXXXX.com 引擎：Hi！调度器，我这有 request 你帮我排序入队一下。 调度器：好的，正在处理你等一下。 引擎：Hi！调度器，把你处理好的 request 给我， 调度器：给你，这是我处理好的 request 引擎：Hi！下载器，你按照下载中间件的设置帮我下载一下这个 request 下载器：好的！给你，这是下载好的东西。（如果失败：不好意思，这个 request 下载失败，然后引擎告诉调度器，这个 request 下载失败了，你记录一下，我们待会儿再下载。） 引擎：Hi！Spiders，这是下载好的东西，并且已经按照 Spider 中间件处理过了，你处理一下（注意！这儿 responses 默认是交给 def parse 这个函数处理的） Spiders：（处理完毕数据之后对于需要跟进的 URL），Hi！引擎，这是我需要跟进的 URL，将它的 responses 交给函数 def xxxx(self, responses)处理。还有这是我获取到的 Item。 引擎：Hi ！Item Pipeline 我这儿有个 item 你帮我处理一下！调度器！这是我需要的 URL 你帮我处理下。然后从第四步开始循环，直到获取到你需要的信息， 注意！只有当调度器中不存在任何 request 了，整个程序才会停止，（也就是说，对于下载失败的ＵＲＬ，Scrapy 会重新下载。） 以上就是 Scrapy 整个流程了。 大家将就着看看。 建立一个项目之后： 第一件事情是在 items.py 文件中定义一些字段，这些字段用来临时存储你需要保存的数据。方便后面保存数据到其他地方，比如数据库 或者 本地文本之类的。 第二件事情在 spiders 文件夹中编写自己的爬虫 第三件事情在 pipelines.py 中存储自己的数据 还有一件事情，不是非做不可的，就 settings.py 文件 并不是一定要编辑的，只有有需要的时候才会编辑。 建议一点：在大家调试的时候建议大家在 settings.py 中取消下面几行的注释： 这几行注释的作用是，Scrapy 会缓存你有的 Requests!当你再次请求时，如果存在缓存文档则返回缓存文档，而不是去网站请求，这样既加快了本地调试速度，也减轻了 网站的压力。一举多得 第一步定义字段： 好了，我们来做 第一步 定义一些字段；那具体我们要定义那些字段呢？ 这个根据自己需要的提取的内容来定义。 比如：我们爬取小说站点都需要提取些什么数据啊？ 小说名字、作者、小说地址、连载状态、连载字数、文章类别 就像下面这样： 这样我们第一步就完成啦！是不是 So Easy？ヾ(´▽‘)ﾉ ； 下面开始重点了哦！编写 spider（就是我们用来提取数据的爬虫了） 第二步编写 Spider： 在 spiders 文件中新建一个 dingdian.py 文件 并导入我们需用的模块 PS：Scrapy 中 Response 可以直接使用 Xpath 来解析数据；不过大家也可以使用自己习惯的包，比如我导入的 BS4 、re ；当然也可以使其他比如 pyquery 之类的。这个并没有什么限制 另外或许个别小伙伴会遇到 from dingdian.items import DingdianItem 这个导入失败的情况；可以试试把项目文件移动到根目录。 Request 这个模块可以用来重写单独请求一个 URL，用于我们后面跟进 URL。 好了开整；首先我们需要什么？ 我们需要从一个地址入手开始爬取，我在顶点小说上没有发现有全站小说地址，但是我找到每个分类地址全部小说： 玄幻魔幻：http://www.23wx.com/class/1_1.html 武侠修真：http://www.23wx.com/class/2_1.html 都市言情：http://www.23wx.com/class/3_1.html 历史军事：http://www.23wx.com/class/4_1.html 侦探推理：http://www.23wx.com/class/5_1.html 网游动漫：http://www.23wx.com/class/6_1.html 科幻小说：http://www.23wx.com/class/7_1.html 恐怖灵异：http://www.23wx.com/class/8_1.html 散文诗词：http://www.23wx.com/class/9_1.html 其他：http://www.23wx.com/class/10_1.html 全本：http://www.23wx.com/quanben/1 好啦！入口地址我们找到了，现在开始写第一部分代码： 当然对于上面的地址，我们是可以直接全使用 Start_urls 这种列表全部请求，不过并不太美观，我需要把其中，有规律的部分，单独其他方式实现，比如字典之类的： 第十行：首先我们创建一个类 Myspider；这个类继承自 scrapy.Spider（当然还有一些其他父类，继承各个父类后能实现的功能不一样）； 第十二行：我们定义 name：dingdian （请注意，这 name 就是我们在 entrypoint.py 文件中的第三个参数！）！！！！请务必注意：此 Name 的！名字！在整个项目中有且只能有一个、名字不可重复！！！！ 第十一行：我们定义了一个 allowed_domains；这个不是必须的；但是在某写情况下需要用得到，比如使用爬取规则的时候就需要了；它的作用是只会跟进存在于 allowed_domains 中的 URL。不存在的 URL 会被忽略。 第十七行到第十九行：我们使用字符串拼接的方式实现了我们上面发现的全部 URL。 第二十行和二十一行：我们使用了导入的 Request 包，来跟进我们的 URL（并将返回的 response 作为参数传递给 self.parse, 嗯！这个叫回调函数！） 第二十三行：使用 parse 函数接受上面 request 获取到的 response。（请务必注意：不要轻易改写 parse 函数（意思就是不要把 parse 函数用作它用）；因为这样 request 的回调函数被你用了，就没谁接受 request 返回的 response 啦！如果你非要用作它用，则需要自己给 request 一个回调函数哦！）

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

import re
import scrapy #导入scrapy包
from bs4 import BeautifulSoup
from scrapy.http import Request ##一个单独的request的模块，需要跟进URL的时候，需要用它
from dingdian.items import DingdianItem ##这是我定义的需要保存的字段，（导入dingdian项目中，items文件中的DingdianItem类）

class Myspider(scrapy.Spider):

    name = 'dingdian'
    allowed_domains = ['23wx.com']
    bash_url = 'http://www.23wx.com/class/'
    bashurl = '.html'

    def start_requests(self):
        for i in range(1, 11):
            url = self.bash_url + str(i) + '_1' + self.bashurl
            yield Request(url, self.parse)
        yield Request('http://www.23wx.com/quanben/1', self.parse)

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

我们测试一下是否正常工作：在 IDE 中运行我们之前创建的 entrypoint.py 文件（如果没有这个文件是不能在 IDE 中运行的哦！ヽ(=^･ω･^=)丿） 然后会像这样： 你会发现在红色状态报告之后，所有页面几乎是一瞬间出现的；那是因为 Scrapy 使用了异步啦！ヽ(°◇° )ノ 另外因为 Scrapy 遵循了 robots 规则，如果你想要获取的页面在 robots 中被禁止了，Scrapy 是会忽略掉的哦！！ヾ(。￣ □ ￣)ﾂ゜゜゜ 请求就这么轻而易举的实现了啊！简直 So Easy！ 继续 继续！ 我们需要历遍所有页面才能取得所有的小说页面连接： 每个页面的这个位置都是最后一个页面，我们提取出它，历遍就可以拼接出一个完整的 URL 了ヾ§ ￣ ▽)ゞ 2333333 Go Go 第二十三行：def parse(self, response)这个函数接受来在二十一行返回的 response，并处理。 第二十四行：我们使用 BS4 从 response 中获取到了最大页码。 第二十五行至二十七行：我们照例拼接了一个完整的 URL（response.url:就是这个 response 的 URL 地址） 第二十八行：功能和第二十行一样，callback= 是指定回调函数，不过不写 callback=也没有什么影响！ 注意我只是说的 callback=这个几个；不是后面的 self.get_name. 看清楚了 response 是怎么用的没？ヾ§ ￣ ▽)ゞ 2333333 是不是 So Easy？ 如果不清楚那个拼接 URL 的小伙伴可以打印出来，看看哦··· 再去观察一下网页，就很明白啦 上面两个函数就彻底的把整个网站的所有小说的页面 URL 的提取出来了，并将每个页面的 response 交给了 get_name 函数处理哦！ 现在我们的爬虫就开始处理具体的小说了哦： 瞅见没 我们需要的东西，快用 F12 工具看一下吧，在什么位置有什么标签，可以方便我们提取数据。还不知道怎么看的小伙伴，去看看妹子图那个教程，有教哦；实在不行百度一下也行！ 过程忽略了，直接上代码（主要是懒癌来了）： 前面三行不说了， 第三十七和三十八行：是我们的小说名字和 URL 第三十九行和第四十行；大伙儿可能会发现，多了个一个 meta 这么一个字典，这是 Scrapy 中传递额外数据的方法。因我们还有一些其他内容需要在下一个页面中才能获取到。 下面我的爬虫进入了这个页面： 这个页面就有很多我们需要的信息了：废话不说了代码上来： 第四十行：将我们导入的 item 文件进行实例化，用来存储我们的数据。 后面全部：将需要的数据，复制给 item[key] (注意这儿的 Key 就是我们前面在 item 文件中定义的那些字段。) 注意！response.meta[key]：这个是提取从上一个函数传递下来的值。 return item 就是返回我们的字典了，然后 Pipelines 就可以开始对这些数据进行处理了。比如 存储之类的。 好啦，Spiders 我们先编写到这个地方。（是不是有小伙伴发现我还有几个字段没有取值？当然留着你们自己试试了，哈哈哈ヽ(=^･ω･^=)丿）后面再继续。 我现在教教大家怎么处理这些数据：对头就是说说 Pipeline 了： 对于基本的 Pipeline 存储方式，网上有很多教程了，今天我们做一个自定义的 MySQL 的 Pipeline： 首先为了能好区分框架自带的 Pipeline，我们把 MySQL 的 Pipeline 单独放到一个目录里面。 我们在项目中新建了一个 mysqlpipelines 的文件夹，我们所有的 MySQL 文件都放在这个目录。 init.py 这个文件不需要我说了吧，不知道做啥的小哥儿自己百度。 pipelines.py 这个是我们写存放数据的文件 sql.py 看名字就知道，需要的 sql 语句。 首先是需要的 MySQL 表，（MySQL 都没有的小哥儿 自己百度装一个啊，我就不教了）

1
2
3
4
5
6
7
8
9

DROP TABLE IF EXISTS `dd_name`;
CREATE TABLE `dd_name` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `xs_name` varchar(255) DEFAULT NULL,
  `xs_author` varchar(255) DEFAULT NULL,
  `category` varchar(255) DEFAULT NULL,
  `name_id` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=38 DEFAULT CHARSET=utf8mb4;

首先我们再 settings.py 文件中定义好 MySQL 的配置文件（当然你也可以直接定义在 sql.py 文件中）： PS :注意 MySQL 的默认端口是 3306；我自己的 MySQL 改成了 3389。这儿各位酌情自己更改。 在开始写 sql.py 之前，我们需要安装一个 Python 操作 MySQL 的包，来自 MySQL 官方的一个包：点我下载 下载完成后解压出来，从 CMD 进入该目录的绝对路径，然后 Python setup.py install ；即可完成安装 下面是我们的 sql.py 文件： 第一行至第二行分别导入了：我的 MySQL 操作包，settings 配置文件 第四行至第八行 ： 从 settings 配置文件中获取到了，我们的 MySQL 配置文件 第十行至第十一行： 初始化了一个 MySQL 的操作游标 第十三行： 定义了一个 Sql 的类 第十六行至第二十五行：定义了一个函数，将函数中的四个变量写入数据库（这四个变量就是我们后面传进来的需要存储的数据。） 关于@classmethod 这个是一个修饰符；作用是我们不需要初始化类就可以直接调用类中的函数使用（具体说起来麻烦，知道作用就好啦） 好了第一部分写完了，我们还需要一个能够去重的： 这一段代码会查找 name_id 这个字段，如果存在则会返回 1 不存在则会返回 0 Nice！sqi.py 这一部分我们完成，来开始写 pipeline 吧： 第一行至第二行：我们导入了之前编写的 sql.py 中的 Sql 类，和我们建立的 item 第六行：建立了一个 DingdianPipeline 的类（别忘了一定要继承 object 这个类啊，这是做啥的不用多了解，说多了你们头晕，我也懒） 第八行：我们定义了一个 process_item 函数并有，item 和 spider 这两个参数（请注意啊！这两玩意儿 务必！！！要加上！！千万不能少！！！！务必！！！务必！！！） 第十行：你这样理解如果在 item 中存在 DingdianItem；就执行下面的。 第十一行：从 item 中取出 name_id 的值。 第十二行：调用 Sql 中的 select_name 函数获得返回值 第十三行：判断 ret 是否等于 1 ，是的话证明已经存了 第二十行：调用 Sql 中的 insert_dd_name 函数，存储上面几个值。 搞完！下面我们启用这个 Pipeline 在 settings 中作如下设置： PS: dingdian（项目目录）.mysqlpipelines（自己建立的 MySQL 目录）.pipelines（自己建立的 pipelines 文件）.DingdianPipeline（其中定义的类） 后面的 1 是优先级程度（1-1000 随意设置，数值越低，组件的优先级越高） 好！我们来运行一下试试！！Go Go Go！ Nice!!完美！！我之前运行过了 所以提示已经存在。 下面我们开始还剩下的一些内容获取：小说章节 和章节内容 首先我们在 item 中新定义一些需要获取内容的字段： 代码不解释了哦！（懒癌来了，写不下去了） 继续编写 Spider 文件： 请注意我图中画红框的的地方，这个地方返回 item 是不能用 return 的哦！用了就结束了，程序就不会继续下去了，得用 yield（你知道就行，这玩意儿说起来麻烦。） 第五十八行： num 这个变量的作用是 因为 Scrapy 是异步的方式运作，你采集到的章节顺序都是混乱的，需要给它有序的序列，我们按照这个排序就能得到正确的章节顺序啦 请注意在顶部导入定义的第二个 item 类！ 下面我们来写存储这部分 spider 的 Pipeline： 数据表：

1
2
3
4
5
6
7
8
9
10
11

DROP TABLE IF EXISTS `dd_chaptername`;
CREATE TABLE `dd_chaptername` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `xs_chaptername` varchar(255) DEFAULT NULL,
  `xs_content` text,
  `id_name` int(11) DEFAULT NULL,
  `num_id` int(11) DEFAULT NULL,
  `url` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2726 DEFAULT CHARSET=gb18030;
SET FOREIGN_KEY_CHECKS=1;

Sql.py: 不解释了哦！ 下面是 Pipeline： 有小伙伴注意，这儿比上面一个 Pipeline 少一个判断，因为我把判断移动到 Spider 中去了，这样就可以减少一次 Request，减轻服务器压力。 改变后的 Spider 长这样： 别忘了在 spider 中导入 Sql 哦！ヾ(。￣ □ ￣)ﾂ゜゜゜ 到此收工！！！！ 至于小说图片，因为 Scrapy 的图片下载管道，是自动以 md5 命名，而且感觉不爽··· 后面单独写一个异步下载的脚本··· https://github.com/thsheep/dingdian

这篇文章主要介绍一些常用的包管理命令以及包的版本如何进行约束。

常用命令

require命令

在《Composer快速入门》中已经简单介绍过使用install命令安装依赖的方式。除了install命令，我们还可以使用require命令快速的安装一个依赖而不需要手动在composer.json里添加依赖信息：

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

$ composer require monolog/monolog
Using version ^1.19 for monolog/monolog
./composer.json has been updated
Loading composer repositories with package information
Updating dependencies (including require-dev)
  - Installing psr/log (1.0.0)
    Downloading: 100%         

  - Installing monolog/monolog (1.19.0)
    Downloading: 100%         

monolog/monolog suggests installing graylog2/gelf-php (Allow sending log messages to a GrayLog2 server)
......
monolog/monolog suggests installing php-console/php-console (Allow sending log messages to Google Chrome)
Writing lock file
Generating autoload files

Composer会先找到合适的版本，然后更新composer.json文件，在require那添加monolog/monolog包的相关信息，再把相关的依赖下载下来进行安装，最后更新composer.lock文件并生成php的自动加载文件。

update命令

通过update命令，可以更新项目里所有的包，或者指定的某些包。

1
2
3
4
5
6
7
8
9
10
11

# 更新所有依赖
$ composer update

# 更新指定的包
$ composer update monolog/monolog

# 更新指定的多个包
$ composer update monolog/monolog symfony/dependency-injection

# 还可以通过通配符匹配包
$ composer update monolog/monolog symfony/*

需要注意的时，包能升级的版本会受到版本约束的约束，包不会升级到超出约束的版本的范围。例如如果composer.json里包的版本约束为^1.10，而最新版本为2.0。那么update命令是不能把包升级到2.0版本的，只能最高升级到1.x版本。关于版本约束请看后面的介绍。

remove命令

使用remove命令可以移除一个包及其依赖（在依赖没有被其他包使用的情况下）：

1
2
3
4
5
6
7

$ composer remove monolog/monolog
Loading composer repositories with package information
Updating dependencies (including require-dev)
  - Removing monolog/monolog (1.19.0)
  - Removing psr/log (1.0.0)
Writing lock file
Generating autoload files

search命令

使用search命令可以进行包的搜索：

1
2
3
4
5

$ composer search monolog
monolog/monolog Sends your logs to files, sockets, inboxes, databases and various web services

# 如果只是想匹配名称可以使用--only-name选项
$ composer search --only-name monolog

show命令

使用show命令可以列出项目目前所安装的包的信息：

1
2
3
4
5
6
7
8

# 列出所有已经安装的包
$ composer show

# 可以通过通配符进行筛选
$ composer show monolog/*

# 显示具体某个包的信息
$ composer show monolog/monolog

以上是常用命令的介绍。

版本约束

前面说到，我们可以指定要下载的包的版本。例如我们想要下载版本1.19的monolog。我们可以通过composer.json文件：

1
2
3
4
5

{
    "require": {
        "monolog/monolog": "1.19"
    }
}

然后运行install命令，或者通过require命令达到目的：

1
2
3
4
5
6
7

$ composer require monolog/monolog:1.19

# 或者
$ composer require monolog/monolog=1.19

# 或者
$composer require monolog/monolog 1.19

除了像上面那样指定具体的版本，我们还可以通过不同的约束方式去指定版本。

基本约束

精确版本

可以指定具体的版本，告诉Composer只能安装这个版本。但是如果其他的依赖需要用到其他的版本，则包的安装或者更新最后会失败并终止。 例子：1.0.2

范围

使用比较操作符你可以指定包的范围。这些操作符包括：\>，\>=，<，<=，!=。 你可以定义多个范围，使用空格 或者逗号,表示逻辑上的与，使用双竖线||表示逻辑上的或。其中与的优先级会大于或。

需要注意的是，使用没有边界的范围有可能会导致安装不可预知的版本，并破坏向下的兼容性。建议使用折音号操作符。

例子：

• \>=1.0
• \>=1.0 <2.0
• \>=1.0 <1.1 || >=1.2

范围（使用连字符）

带连字符的范围表明了包含的版本范围，意味着肯定是有边界的。其中连字符的左边表明了\>=的版本，而连字符的右边情况则稍微有点复杂。如果右边的版本不是完整的版本号，则会被使用通配符进行补全。例如1.0 - 2.0等同于\>=1.0.0 <2.1（2.0相当于2.0.*），而1.0.0 - 2.1.0则等同于\>=1.0.0 <=2.1.0。 例子：1.0 - 2.0

通配符

可以使用通配符去定义版本。1.0.*相当于\>=1.0 <1.1。 例子：1.0.*

下一个重要版本操作符

波浪号~

我们先通过后面这个例子去解释~操作符的用法：~1.2相当于\>=1.2 <2.0.0，而~1.2.3相当于\>=1.2.3 <1.3.0。对于使用Semantic Versioning作为版本号标准的项目来说，这种版本约束方式很实用。例如~1.2定义了最小的小版本号，然后你可以升级2.0以下的任何版本而不会出问题，因为按照Semantic Versioning的版本定义，小版本的升级不应该有兼容性的问题。简单来说，~定义了最小的版本，并且允许版本的最后一位版本号进行升级（没懂得话，请再看一边前面的例子）。 例子：~1.2

需要注意的是，如果~作用在主版本号上，例如~1，按照上面的说法，Composer可以安装版本1以后的主版本，但是事实上是~1会被当作~1.0对待，只能增加小版本，不能增加主版本。

折音号^

^操作符的行为跟Semantic Versioning有比较大的关联，它允许升级版本到安全的版本。例如，^1.2.3相当于\>=1.2.3 <2.0.0，因为在2.0版本前的版本应该都没有兼容性的问题。而对于1.0之前的版本，这种约束方式也考虑到了安全问题，例如^0.3会被当作\>=0.3.0 <0.4.0对待。 例子：^1.2.3

版本稳定性

如果你没有显式的指定版本的稳定性，Composer会根据使用的操作符，默认在内部指定为\-dev或者\-stable。例如：

约束

内部约束

1.2.3

\=1.2.3.0-stable

>1.2

>1.2.0.0-stable

>=1.2

>=1.2.0.0-dev

>=1.2-stable

>=1.2.0.0-stable

<1.3

<1.3.0.0-dev

<=1.3

<=1.3.0.0-stable

1 - 2

>=1.0.0.0-dev <3.0.0.0-dev

~1.3

>=1.3.0.0-dev <2.0.0.0-dev

1.4.*

>=1.4.0.0-dev <1.5.0.0-dev

如果你想指定版本只要稳定版本，你可以在版本后面添加后缀\-stable。 minimum-stability 配置项定义了包在选择版本时对稳定性的选择的默认行为。默认是stable。它的值如下（按照稳定性排序）：dev，alpha，beta，RC和stable。除了修改这个配置去修改这个默认行为，我们还可以通过稳定性标识（例如@stable和@dev）来安装一个相比于默认配置不同稳定性的版本。例如：

1
2
3
4
5
6

{
    "require": {
        "monolog/monolog": "1.0.*@beta",
        "acme/foo": "@dev"
    }
}

以上是版本约束的介绍

参考

• https://segmentfault.com/a/1190000005898222
• https://getcomposer.org/doc/03-cli.md[2]
• https://getcomposer.org/doc/articles/versions.md[3]
• http://semver.org/[1]

2022 年最新 Python3 网络爬虫教程

大家好，我是崔庆才，由于爬虫技术不断迭代升级，一些旧的教程已经过时、案例已经过期，最前沿的爬虫技术比如异步、JavaScript 逆向、安卓逆向、智能解析、WebAssembly、大规模分布式、Kubernetes 等技术层出不穷，我最近新出了一套最新最全面的 Python3 网络爬虫系列教程。

博主自荐：截止 2022 年，可以将最前沿最全面的爬虫技术都涵盖的教程，如异步、JavaScript 逆向、安卓逆向、智能解析、WebAssembly、大规模分布式、Kubernetes 等，市面上目前就这一套了。

最新教程对旧的爬虫技术内容进行了全面更新，搭建了全新的案例平台进行全面讲解，保证案例稳定有效不过期。

教程请移步：

【2022 版】Python3 网络爬虫学习教程

如下为原文。

提示

本教程方法已不是最优，最新解决方案请移步 http://cuiqingcai.com/4596.html

那夜

那是一个寂静的深夜，科比还没起床练球，虽然他真的可能不练了。 我废了好大劲，爬虫终于写好了！BUG 也全部调通了！心想，终于可以坐享其成了！ 泡杯茶，安静地坐在椅子上看着屏幕上一行行文字在控制台跳出，一条条数据嗖嗖进入我的数据库，一张张图片悄悄存入我的硬盘。人生没有几个比这更惬意的事情了。 我端起茶杯，抿了一口，静静地回味着茶香。 这时，什么情况！屏幕爆红了！爆红了！一口茶的功夫啊喂！ 怎么回事！咋爬不动了，不动了！我用浏览器点开那一个个报错的链接，浏览器显示

您的请求过于频繁，IP 已经被暂时封禁，请稍后再试！

沃日，我 IP 被封了？此时此刻，空气凝固了，茶也不再香了，请给我一个爱的抱抱啊。 时候不早了，还是洗洗睡吧。

次日

那一晚，辗转反侧难以入睡。 怎么办？怎么办？如果是你你该怎么办？ 手动换个 IP？得了吧，一会又要封了，还能不能安心睡觉啊？ 找免费代理？可行，不过我之前测过不少免费代理 IP，一大半都不好用，而且慢。不过可以一直维护一个代理池，定时更新。 买代理？可以可以，不过优质的代理服务商价格可是不菲的，我买过一些廉价的，比如几块钱套餐一次提取几百 IP 的，算了还是不说了都是泪。 然而最行之有效的方法是什么？那当然是 ADSL 拨号！ 这是个啥？且听我慢慢道来。

什么是 ADSL

ADSL （Asymmetric Digital Subscriber Line ，非对称数字用户环路）是一种新的数据传输方式。它因为上行和下行带宽不对称，因此称为非对称数字用户线环路。它采用频分复用技术把普通的电话线分成了电话、上行和下行三个相对独立的信道，从而避免了相互之间的干扰。 他有个独有的特点，每拨一次号，就获取一个新的 IP。也就是它的 IP 是不固定的，不过既然是拨号上网嘛，速度也是有保障的，用它搭建一个代理，那既能保证可用，又能自由控制拨号切换。 如果你是用的 ADSL 上网方式，那就不用过多设置了，直接自己电脑调用一个拨号命令就好了，自动换 IP，分分钟解决封 IP 的事。 然而，你可能说？我家宽带啊，我连得公司无线啊，我蹭的网上的啊！那咋办？ 这时，你就需要一台 VPS 拨号主机。

购买服务器

某度广告做的那么好是吧？一搜一片，这点谷歌可是远远比不上啊。 于是乎，我就搜了搜，键入：拨号服务器，有什么骑士互联啊、无极网络啊、挂机宝啊等等的。我选了个价钱还凑合的，选了个无极网络（这里不是在打广告），80 一个月的配置，一天两块钱多点。 2 核、512M 内存，10M 带宽。 云立方 大家觉得有更便宜的更好用请告诉我呀！ 接下来开始装操作系统，进入后台，有一个自助装系统的页面。 我装的 CentOS 的，在后面设置代理啊，定时任务啊，远程 SSH 管理啊之类的比较方便。如果你想用 Windows，能配置好代理那也没问题。 有的小伙伴可能会问了，既然它的 IP 是拨号变化的，你咋用 SSH 连？其实服务商提供了一个域名，做了动态解析和端口映射，映射到这台主机的 22 端口就好了，所以不用担心 IP 变化导致 SSH 断开的问题。 好了装好了服务器之后，服务商提供了一个 ADSL 的拨号操作过程，用 pppoe 命令都可以完成，如果你的是 Linux 的主机一般都是用这个。然后服务商还会给给你一个拨号账号和密码。 那么接下来就是试下拨号了。 服务商会提供详细的拨号流程说明。 比如无极的是这样的： 拨号流程 设置好了之后，就有几个关键命令：

1
2
3

pppoe-start 拨号
pppoe-stop  断开拨号
pppoe-status 拨号连接状态

如果想重新拨号，那就执行 stop、start 就可以了。 反复执行，然后查看下 ip 地址，你会发现拨号一次换一个 IP，是不是爽翻了！ 好，那接下来就设置代理吧。

设置代理服务器

之前总是用别人的代理，没自己设置过吧？那么接下来我们就来亲自搭建 HTTP 代理。 Linux 下搭建 HTTP 代理，推荐 Squid 和 TinyProxy。都非常好配置，你想用哪个都行，且听我慢慢道来。 我的系统是 CentOS，以它为例进行说明。

Squid

首先利用 yum 安装 squid

1

yum -y install squid

设置开机启动

1

chkconfig --level 35 squid on

修改配置文件

1

vi /etc/squid/squid.conf

修改如下几个部分：

1
2
3

http_access allow !Safe_ports    #deny改成allow
http_access allow CONNECT !SSL_ports  #deny改成allow
http_access allow all  #deny改成allow

其他的不需要过多配置。 启动 squid

1

sudo service squid start

如此一来配置就完成了。 代理使用的端口是 3128

TinyProxy

首先添加一下镜像源，然后安装

1
2
3

rpm -Uvh http://dl.fedoraproject.org/pub/epel/5/i386/epel-release-5-4.noarch.rpm
yum update
yum install tinyproxy

修改配置

1

vi /etc/tinyproxy/tinyproxy.conf

可以修改端口和允许的 IP，如果想任意主机都连接那就把 Allow 这一行注释掉。

1
2
3
4

Port 8888 #预设是8888 Port,你可以更改
Allow 127.0.0.1 #将127.0.0.1改成你自己的IP
#例如你的IP 是1.2.3.4,你改成Allow 1.2.3.4,那只有你才可以连上这个Proxy
#若你想任何IP都可以脸到Proxy在Allow前面打#注释

启动 TinyProxy

1

service tinyproxy start

好了，两个代理都配置好了。 你想用那个都可以！ 不过你以为这样就完了吗？太天真了，我被困扰了好几天，怎么都连不上，我还在怀疑是不是我哪里设置得不对？各种搜，一直以为是哪里配置有遗漏，后来发现是 iptables 的锅，万恶的防火墙。踩过的的坑，那就不要让大家踩了，用下面的命令设置下 iptables，放行 3128 和 8888 端口就好了。

1
2
3
4
5
6

service iptables save
systemctl stop firewalld
systemctl disable  firewalld
systemctl start iptables
systemctl status iptables
systemctl enable iptables

修改 iptables 配置

1

vi /etc/sysconfig/iptables

在

1

-A IN_public_allow -p tcp -m tcp --dport 22 -m conntrack --ctstate NEW -j ACCEPT

的下面添加两条规则

1
2

-A IN_public_allow -p tcp -m tcp --dport 3128 -m conntrack --ctstate NEW -j ACCEPT
-A IN_public_allow -p tcp -m tcp --dport 8888 -m conntrack --ctstate NEW -j ACCEPT

如图所示 保存，然后重启 iptables

1

sudo service iptabels restart

输入 ifconfig 得到 IP 地址，在其他的主机上输入

1

curl -x IP:8888 www.baidu.com

测试一下，如果能出现结果，那就说明没问题。 如果怎么配都连不上，那干脆关了你的防火墙吧。虽然不推荐。

连接代理

接下来才是重头戏，你咋知道你的服务器 IP 现在到底是多少啊？拨一次号 IP 就换一次，那这还了得？ 如果服务商提供了端口映射！那一切都解决了！直接用端口映射过去就好了。然而，我的并没有。 自力更生，艰苦创业！ 首先我研究了一下 DDNS 服务，也就是动态域名解析。即使你的 IP 在变化，那也可以通过一个域名来映射过来。 原理简单而统一：当前拨号主机定时向一个固定的服务器发请求，服务器获取 remote_addr 就好了，可以做到定时更新和解析。 那么我找了一下，国内做的比较好的就是花生壳了，然后又找到了 DNSPOD 的接口解析。 下面简单说下我的折腾过程，大家可以先不用试，后面有更有效的方法。

花生壳

现在花生壳出到 3.0 版本了，有免费版和付费版之分，我就试用了一下免费版的。这里是花生壳的一些配置和下载： 花生壳配置 下载花生壳客户端之后，会生成 SN 码，用这个在花生壳的官网登录后，会分配给你一个免费的域名。 接下来这个域名就能解析到你的主机了。

DNSPOD

DNSPOD 原理也是一样，不过好处是你可以配置自己的域名。 在 GitHub 上有脚本可以使用。 脚本链接 具体的细节我就不说了，实际上就是定时请求，利用 remote_addr 更新 DNSPOD 记录，做到动态解析。 解析接口 不过！这两个有个通病！慢！ 什么慢？解析慢！但这不是他们的锅，因为 DNS 修改后完全生效就是需要一定的时间，这一秒你拨号了，然后更新了 IP，但是域名可能还是解析着原来的 IP，需要过几分钟才能变过来。这能忍吗？ 我可是在跑爬虫啊，这还能忍？

自力更生

嗯，V2EX 果然是个好地方，逛了一下，收获不小。 链接在此 参考了 abelyao 的思路，自己写了脚本来获取 IP，保证秒级更新！ 此时，你还需要另一台固定 IP 的主机或者某个云服务器，只要是地址固定的就好。在这里我用了另一台有固定 IP 的阿里云主机，当然你如果有什么新浪云啊之类的也可以。 那么现在的思路就是，拨号 VPS 定时拨号换 IP，然后请求阿里云主机，阿里云主机获取 VPS 的 IP 地址即可。 拨号 VPS 做的事情： 定时拨号，定时请求服务器。使用 bash 脚本，然后 crontab 定时执行。 远程服务器： 接收请求，获取 remote_addr，保存起来。使用 Flask 搭建服务器，接收请求。 废话少说，上代码 AutoProxy

功能

由于 DDNS 生效时间过长，对于爬虫等一些时间要求比较紧迫的项目就不太适用，为此本项目根据 DDNS 基本原理来实现实时获取 ADSL 拨号主机 IP。

基本原理

client 文件夹由 ADSL 拨号客户机运行。它会定时执行拨号操作，然后请求某个固定地址的服务器，以便让服务器获取 ADSL 拨号客户机的 IP，主要是定时 bash 脚本运行。 server 文件夹是服务器端运行，利用 Python 的 Flask 搭建服务器，然后接收 ADSL 拨号客户机的请求，得到 remote_addr，获取客户机拨号后的 IP。

项目结构

server

• config.py 配置文件。
• ip 客户端请求后获取的客户端 IP，文本保存。
• main.py Flask 主程序，提供两个接口，一个是接收客户端请求，然后将 IP 保存，另外一个是获取当前保存的 IP。

client

• crontab 定时任务命令示例。
• pppoe.sh 拨号脚本，主要是实现重新拨号的几个命令。
• request.sh 请求服务器的脚本，主要是实现拨号后请求服务器的操作。
• request.conf 配置文件。

使用

服务器

服务器提供两个功能，record 方法是客户机定时请求，然后获取客户机 IP 并保存。proxy 方法是供我们自己用，返回保存的客户机 IP，提取代理。

克隆项目

1

git clone https://github.com/Germey/AutoProxy.git

修改配置

修改 config.py 文件

• KEY 是客户端请求服务器时的凭证，在 client 的 request.conf 也有相同的配置，二者保持一致即可。
• NEED_AUTH 在获取当前保存的 IP（即代理的 IP）的时候，为防止自己的主机代理被滥用，在获取 IP 的时候，需要加权限验证。
• AUTH_USER 和 AUTH_PASSWORD 分别是认证用户名密码。
• PORT 默认端口，返回保存的结果中会自动添加这个端口，组成一个 IP:PORT 的代理形式。

运行

1
2

cd server
nohup python main.py

ADSL 客户机

克隆项目

1

git clone https://github.com/Germey/AutoProxy.git

修改配置

修改 reqeust.conf 文件

• KEY 是客户端请求服务器时的凭证，在 server 的 config.py 也有相同的配置，二者保持一致即可。
• SERVER 是服务器项目运行后的地址，一般为 http://<服务器 IP>:<服务器端口>/record。如http://120.27.14.24:5000/record。

修改 pppoe.sh 文件 这里面写上重新拨号的几条命令，记得在前两行配置一下环境变量，配置上拨号命令所在的目录，以防出现脚本无法运行的问题。

运行

设置定时任务

1

crontab -e

输入 crontab 的实例命令

1

*/5 * * * * /var/py/AutoProxy/client/request.sh /var/py/AutoProxy/client/request.conf >> /var/py/AutoProxy/client/request.log

注意修改路径，你的项目在哪里，都统一修改成自己项目的路径。 最前面的*/5 是 5 分钟执行一次。 好了，保存之后，定时任务就会开启。

验证结果

这样一来，访问服务器地址，就可以得到 ADSL 拨号客户机的 IP 了。

1
2
3
4
5

import requests

url = 'http://120.27.14.24:5000'
proxy = requests.get(url, auth=('admin', '123')).text
print(proxy)

实例结果：

1

116.208.97.22:8888

扩展

如果你有域名，可以自己解析一个域名，这样就可以直接请求自己的域名，拿到实时好用的代理了，而且定时更新。

代理设置

urllib2

1
2
3
4
5
6

import urllib2
proxy_handler = urllib2.ProxyHandler({"http": 'http://' + proxy})
opener = urllib2.build_opener(proxy_handler)
urllib2.install_opener(opener)
response = urllib2.urlopen('http://httpbin.org/get')
print response.read()

requests

1
2
3
4
5
6

import requests
proxies = {
'http': 'http://' + proxy,
}
r = requests.get('http://httpbin.org/get', proxies=proxies)
print(r.text)

以上便秒级解决了动态 IP 解析，自己实现了一遍 DDNS，爽！ 那这样以来，以后就可以直接请求你的主机获取一个最新可用的代理 IP 了，稳定可用，定时变化！ 以上便是 ADSL 拨号服务器配置的全过程，希望对大家有帮助！

ＰＳ：使用多线程时好像在目录切换的问题上存在问题，可以给线程加个锁试试 Hello 大家好！我又来了。 你是不是发现下载图片速度特别慢、难以忍受啊！对于这种问题 一般解决办法就是多进程了！一个进程速度慢！我就用十个进程，相当于十个人一起干。速度就会快很多啦！（为什么不说多线程？懂点 Python 的小伙伴都知道、GIL 的存在 导致 Python 的多线程有点坑啊！）今天就教大家来做一个多进程的爬虫（其实吧、可以用来做一个超简化版的分布式爬虫） 其实吧！还有一种加速的方法叫做“异步”！不过这玩意儿我没怎么整明白就不出来误人子弟了！（因为爬虫大部分时间都是在等待 response 中！‘异步’则能让程序在等待 response 的时间去做的其他事情。） 学过 Python 基础的同学都知道、在多进程中，进程之间是不能相互通信的，这就有一个很坑爹的问题的出现了！多个进程怎么知道那那些需要爬取、哪些已经被爬取了！ 这就涉及到一个东西！这玩意儿叫做队列！！队列！！队列！！其实吧正常来说应该给大家用队列来完成这个教程的， 比如 Tornado 的 queue 模块。（如果需要更为稳定健壮的队列，则请考虑使用 Celery 这一类的专用消息传递工具） 不过为了简化技术种类啊！（才不会告诉你们是我懒，嫌麻烦呢！）这次我们继续使用 MongoDB。 好了！先来理一下思路： 每个进程需要知道那些 URL 爬取过了、哪些 URL 需要爬取！我们来给每个 URL 设置两种状态： outstanding:等待爬取的 URL complete:爬取完成的 URL 诶！等等我们好像忘了啥？ 失败的 URL 的怎么办啊？我们在增加一种状态： processing:正在进行的 URL。 嗯！当一个所有初始的 URL 状态都为 outstanding；当开始爬取的时候状态改为：processing；爬取完成状态改为：complete；失败的 URL 重置状态为：outstanding。为了能够处理 URL 进程被终止的情况、我们设置一个计时参数，当超过这个值时；我们则将状态重置为 outstanding。 下面开整 Go Go Go！ 首先我们需要一个模块：datetime(这个模块比内置 time 模块要好使一点)不会装？？不是吧！ pip install datetime 还有上一篇博文我们已经使用过的 pymongo 下面是队列的代码：

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

from datetime import datetime, timedelta
from pymongo import MongoClient, errors

class MogoQueue():

    OUTSTANDING = 1 ##初始状态
    PROCESSING = 2 ##正在下载状态
    COMPLETE = 3 ##下载完成状态

    def __init__(self, db, collection, timeout=300):##初始mongodb连接
        self.client = MongoClient()
        self.Client = self.client[db]
        self.db = self.Client[collection]
        self.timeout = timeout

    def __bool__(self):
        """
        这个函数，我的理解是如果下面的表达为真，则整个类为真
        至于有什么用，后面我会注明的（如果我的理解有误，请指点出来谢谢，我也是Python新手）
        $ne的意思是不匹配
        """
        record = self.db.find_one(
            {'status': {'$ne': self.COMPLETE}}
        )
        return True if record else False

    def push(self, url, title): ##这个函数用来添加新的URL进队列
        try:
            self.db.insert({'_id': url, 'status': self.OUTSTANDING, '主题': title})
            print(url, '插入队列成功')
        except errors.DuplicateKeyError as e:  ##报错则代表已经存在于队列之中了
            print(url, '已经存在于队列中了')
            pass
    def push_imgurl(self, title, url):
        try:
            self.db.insert({'_id': title, 'statue': self.OUTSTANDING, 'url': url})
            print('图片地址插入成功')
        except errors.DuplicateKeyError as e:
            print('地址已经存在了')
            pass

    def pop(self):
        """
        这个函数会查询队列中的所有状态为OUTSTANDING的值，
        更改状态，（query后面是查询）（update后面是更新）
        并返回_id（就是我们的ＵＲＬ），MongDB好使吧，^_^
        如果没有OUTSTANDING的值则调用repair()函数重置所有超时的状态为OUTSTANDING，
        $set是设置的意思，和MySQL的set语法一个意思
        """
        record = self.db.find_and_modify(
            query={'status': self.OUTSTANDING},
            update={'$set': {'status': self.PROCESSING, 'timestamp': datetime.now()}}
        )
        if record:
            return record['_id']
        else:
            self.repair()
            raise KeyError

    def pop_title(self, url):
        record = self.db.find_one({'_id': url})
        return record['主题']

    def peek(self):
        """这个函数是取出状态为 OUTSTANDING的文档并返回_id(URL)"""
        record = self.db.find_one({'status': self.OUTSTANDING})
        if record:
            return record['_id']

    def complete(self, url):
        """这个函数是更新已完成的URL完成"""
        self.db.update({'_id': url}, {'$set': {'status': self.COMPLETE}})

    def repair(self):
        """这个函数是重置状态$lt是比较"""
        record = self.db.find_and_modify(
           query={
               'timestamp': {'$lt': datetime.now() - timedelta(seconds=self.timeout)},
               'status': {'$ne': self.COMPLETE}
           },
            update={'$set': {'status': self.OUTSTANDING}}
        )
        if record:
            print('重置URL状态', record['_id'])

    def clear(self):
        """这个函数只有第一次才调用、后续不要调用、因为这是删库啊！"""
        self.db.drop()

好了，队列我们做好了，下面是获取所有页面的代码：

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

from Download import request
from mongodb_queue import MogoQueue
from bs4 import BeautifulSoup


spider_queue = MogoQueue('meinvxiezhenji', 'crawl_queue')
def start(url):
    response = request.get(url, 3)
    Soup = BeautifulSoup(response.text, 'lxml')
    all_a = Soup.find('div', class_='all').find_all('a')
    for a in all_a:
        title = a.get_text()
        url = a['href']
        spider_queue.push(url, title)
    """上面这个调用就是把URL写入MongoDB的队列了"""

if __name__ == "__main__":
    start('http://www.mzitu.com/all')

"""这一段儿就不解释了哦！超级简单的"""

下面就是多进程+多线程的下载代码了：

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

import os
import time
import threading
import multiprocessing
from mongodb_queue import MogoQueue
from Download import request
from bs4 import BeautifulSoup

SLEEP_TIME = 1

def mzitu_crawler(max_threads=10):
    crawl_queue = MogoQueue('meinvxiezhenji', 'crawl_queue') ##这个是我们获取URL的队列
    ##img_queue = MogoQueue('meinvxiezhenji', 'img_queue')
    def pageurl_crawler():
        while True:
            try:
                url = crawl_queue.pop()
                print(url)
            except KeyError:
                print('队列没有数据')
                break
            else:
                img_urls = []
                req = request.get(url, 3).text
                title = crawl_queue.pop_title(url)
                mkdir(title)
                os.chdir('D:\mzitu\\' + title)
                max_span = BeautifulSoup(req, 'lxml').find('div', class_='pagenavi').find_all('span')[-2].get_text()
                for page in range(1, int(max_span) + 1):
                    page_url = url + '/' + str(page)
                    img_url = BeautifulSoup(request.get(page_url, 3).text, 'lxml').find('div', class_='main-image').find('img')['src']
                    img_urls.append(img_url)
                    save(img_url)
                crawl_queue.complete(url) ##设置为完成状态
                ##img_queue.push_imgurl(title, img_urls)
                ##print('插入数据库成功')

    def save(img_url):
        name = img_url[-9:-4]
        print(u'开始保存：', img_url)
        img = request.get(img_url, 3)
        f = open(name + '.jpg', 'ab')
        f.write(img.content)
        f.close()

    def mkdir(path):
        path = path.strip()
        isExists = os.path.exists(os.path.join("D:\mzitu", path))
        if not isExists:
            print(u'建了一个名字叫做', path, u'的文件夹！')
            os.makedirs(os.path.join("D:\mzitu", path))
            return True
        else:
            print(u'名字叫做', path, u'的文件夹已经存在了！')
            return False

    threads = []
    while threads or crawl_queue:
        """
        这儿crawl_queue用上了，就是我们__bool__函数的作用，为真则代表我们MongoDB队列里面还有数据
        threads 或者 crawl_queue为真都代表我们还没下载完成，程序就会继续执行
        """
        for thread in threads:
            if not thread.is_alive(): ##is_alive是判断是否为空,不是空则在队列中删掉
                threads.remove(thread)
        while len(threads) < max_threads or crawl_queue.peek(): ##线程池中的线程少于max_threads 或者 crawl_qeue时
            thread = threading.Thread(target=pageurl_crawler) ##创建线程
            thread.setDaemon(True) ##设置守护线程
            thread.start() ##启动线程
            threads.append(thread) ##添加进线程队列
        time.sleep(SLEEP_TIME)

def process_crawler():
    process = []
    num_cpus = multiprocessing.cpu_count()
    print('将会启动进程数为：', num_cpus)
    for i in range(num_cpus):
        p = multiprocessing.Process(target=mzitu_crawler) ##创建进程
        p.start() ##启动进程
        process.append(p) ##添加进进程队列
    for p in process:
        p.join() ##等待进程队列里面的进程结束

if __name__ == "__main__":
    process_crawler()

好啦！一个多进程多线的爬虫就完成了，（其实你可以设置一下 MongoDB，然后调整一下连接配置，在多台机器上跑哦！！嗯，就是超级简化版的分布式爬虫了，虽然很是简陋。） 本来还想下载图片那一块儿加上异步（毕竟下载图片是Ｉ＼Ｏ等待最久的时间了，），可惜异步我也没怎么整明白，就不拿出来贻笑大方了。 另外，各位小哥儿可以参考上面代码，单独处理图片地址试试（就是多个进程直接下载图片）？ 我测试了一下八分钟下载 100 套图 PS：请务必使用 第二篇博文中的下载模块，或者自己写一个自动更换代理的下载模块！！！不然寸步难行，分分钟被服务器 BAN 掉！ 小白教程就到此结束了，后面我教大家玩玩 Scrapy；目标 顶点小说网， 爬完全站的小说。 再后面带大家玩玩 抓新浪 汤不热、模拟登录 之类的。或许维护一个公共代理 IP 池之类的。 这个所有代码我放在这个位置了：https://github.com/thsheep/mzitu/

2022 年最新 Python3 网络爬虫教程

大家好，我是崔庆才，由于爬虫技术不断迭代升级，一些旧的教程已经过时、案例已经过期，最前沿的爬虫技术比如异步、JavaScript 逆向、安卓逆向、智能解析、WebAssembly、大规模分布式、Kubernetes 等技术层出不穷，我最近新出了一套最新最全面的 Python3 网络爬虫系列教程。

博主自荐：截止 2022 年，可以将最前沿最全面的爬虫技术都涵盖的教程，如异步、JavaScript 逆向、安卓逆向、智能解析、WebAssembly、大规模分布式、Kubernetes 等，市面上目前就这一套了。

最新教程对旧的爬虫技术内容进行了全面更新，搭建了全新的案例平台进行全面讲解，保证案例稳定有效不过期。

教程请移步：

【2022 版】Python3 网络爬虫学习教程

如下为原文。

前言

在上一节中介绍了 thread 多线程库。python 中的多线程其实并不是真正的多线程，并不能做到充分利用多核 CPU 资源。 如果想要充分利用，在 python 中大部分情况需要使用多进程，那么这个包就叫做 multiprocessing。 借助它，可以轻松完成从单进程到并发执行的转换。multiprocessing 支持子进程、通信和共享数据、执行不同形式的同步，提供了 Process、Queue、Pipe、Lock 等组件。 那么本节要介绍的内容有：

• Process
• Lock
• Semaphore
• Queue
• Pipe
• Pool

Process

基本使用

在 multiprocessing 中，每一个进程都用一个 Process 类来表示。首先看下它的 API

1

Process([group [, target [, name [, args [, kwargs]]]]])

• target 表示调用对象，你可以传入方法的名字
• args 表示被调用对象的位置参数元组，比如 target 是函数 a，他有两个参数 m，n，那么 args 就传入(m, n)即可
• kwargs 表示调用对象的字典
• name 是别名，相当于给这个进程取一个名字
• group 分组，实际上不使用

我们先用一个实例来感受一下：

1
2
3
4
5
6
7
8
9

import multiprocessing

def process(num):
    print 'Process:', num

if __name__ == '__main__':
    for i in range(5):
        p = multiprocessing.Process(target=process, args=(i,))
        p.start()

最简单的创建 Process 的过程如上所示，target 传入函数名，args 是函数的参数，是元组的形式，如果只有一个参数，那就是长度为 1 的元组。 然后调用 start()方法即可启动多个进程了。 另外你还可以通过 cpu_count() 方法还有 active_children() 方法获取当前机器的 CPU 核心数量以及得到目前所有的运行的进程。 通过一个实例来感受一下：

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

import multiprocessing
import time

def process(num):
    time.sleep(num)
    print 'Process:', num

if __name__ == '__main__':
    for i in range(5):
        p = multiprocessing.Process(target=process, args=(i,))
        p.start()

    print('CPU number:' + str(multiprocessing.cpu_count()))
    for p in multiprocessing.active_children():
        print('Child process name: ' + p.name + ' id: ' + str(p.pid))

    print('Process Ended')

运行结果：

1
2
3
4
5
6
7
8
9
10
11

Process: 0
CPU number:8
Child process name: Process-2 id: 9641
Child process name: Process-4 id: 9643
Child process name: Process-5 id: 9644
Child process name: Process-3 id: 9642
Process Ended
Process: 1
Process: 2
Process: 3
Process: 4

自定义类

另外你还可以继承 Process 类，自定义进程类，实现 run 方法即可。 用一个实例来感受一下：

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

from multiprocessing import Process
import time


class MyProcess(Process):
    def __init__(self, loop):
        Process.__init__(self)
        self.loop = loop

    def run(self):
        for count in range(self.loop):
            time.sleep(1)
            print('Pid: ' + str(self.pid) + ' LoopCount: ' + str(count))


if __name__ == '__main__':
    for i in range(2, 5):
        p = MyProcess(i)
        p.start()

在上面的例子中，我们继承了 Process 这个类，然后实现了 run 方法。打印出来了进程号和参数。 运行结果：

1
2
3
4
5
6
7
8
9

Pid: 28116 LoopCount: 0
Pid: 28117 LoopCount: 0
Pid: 28118 LoopCount: 0
Pid: 28116 LoopCount: 1
Pid: 28117 LoopCount: 1
Pid: 28118 LoopCount: 1
Pid: 28117 LoopCount: 2
Pid: 28118 LoopCount: 2
Pid: 28118 LoopCount: 3

可以看到，三个进程分别打印出了 2、3、4 条结果。 我们可以把一些方法独立的写在每个类里封装好，等用的时候直接初始化一个类运行即可。

deamon

在这里介绍一个属性，叫做 deamon。每个线程都可以单独设置它的属性，如果设置为 True，当父进程结束后，子进程会自动被终止。 用一个实例来感受一下，还是原来的例子，增加了 deamon 属性：

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

from multiprocessing import Process
import time


class MyProcess(Process):
    def __init__(self, loop):
        Process.__init__(self)
        self.loop = loop

    def run(self):
        for count in range(self.loop):
            time.sleep(1)
            print('Pid: ' + str(self.pid) + ' LoopCount: ' + str(count))


if __name__ == '__main__':
    for i in range(2, 5):
        p = MyProcess(i)
        p.daemon = True
        p.start()


    print 'Main process Ended!'

在这里，调用的时候增加了设置 deamon，最后的主进程（即父进程）打印输出了一句话。 运行结果：

1

Main process Ended!

结果很简单，因为主进程没有做任何事情，直接输出一句话结束，所以在这时也直接终止了子进程的运行。 这样可以有效防止无控制地生成子进程。如果这样写了，你在关闭这个主程序运行时，就无需额外担心子进程有没有被关闭了。 不过这样并不是我们想要达到的效果呀，能不能让所有子进程都执行完了然后再结束呢？那当然是可以的，只需要加入 join()方法即可。

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

from multiprocessing import Process
import time


class MyProcess(Process):
    def __init__(self, loop):
        Process.__init__(self)
        self.loop = loop

    def run(self):
        for count in range(self.loop):
            time.sleep(1)
            print('Pid: ' + str(self.pid) + ' LoopCount: ' + str(count))


if __name__ == '__main__':
    for i in range(2, 5):
        p = MyProcess(i)
        p.daemon = True
        p.start()
        p.join()


    print 'Main process Ended!'

在这里，每个子进程都调用了 join()方法，这样父进程（主进程）就会等待子进程执行完毕。 运行结果：

1
2
3
4
5
6
7
8
9
10

Pid: 29902 LoopCount: 0
Pid: 29902 LoopCount: 1
Pid: 29905 LoopCount: 0
Pid: 29905 LoopCount: 1
Pid: 29905 LoopCount: 2
Pid: 29912 LoopCount: 0
Pid: 29912 LoopCount: 1
Pid: 29912 LoopCount: 2
Pid: 29912 LoopCount: 3
Main process Ended!

发现所有子进程都执行完毕之后，父进程最后打印出了结束的结果。

Lock

在上面的一些小实例中，你可能会遇到如下的运行结果： 什么问题？有的输出错位了。这是由于并行导致的，两个进程同时进行了输出，结果第一个进程的换行没有来得及输出，第二个进程就输出了结果。所以导致这种排版的问题。 那这归根结底是因为线程同时资源（输出操作）而导致的。 那怎么来避免这种问题？那自然是在某一时间，只能一个进程输出，其他进程等待。等刚才那个进程输出完毕之后，另一个进程再进行输出。这种现象就叫做“互斥”。 我们可以通过 Lock 来实现，在一个进程输出时，加锁，其他进程等待。等此进程执行结束后，释放锁，其他进程可以进行输出。 我们现用一个实例来感受一下：

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

from multiprocessing import Process, Lock
import time


class MyProcess(Process):
    def __init__(self, loop, lock):
        Process.__init__(self)
        self.loop = loop
        self.lock = lock

    def run(self):
        for count in range(self.loop):
            time.sleep(0.1)
            #self.lock.acquire()
            print('Pid: ' + str(self.pid) + ' LoopCount: ' + str(count))
            #self.lock.release()

if __name__ == '__main__':
    lock = Lock()
    for i in range(10, 15):
        p = MyProcess(i, lock)
        p.start()

首先看一下不加锁的输出结果：

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

Pid: 45755 LoopCount: 0
Pid: 45756 LoopCount: 0
Pid: 45757 LoopCount: 0
Pid: 45758 LoopCount: 0
Pid: 45759 LoopCount: 0
Pid: 45755 LoopCount: 1
Pid: 45756 LoopCount: 1
Pid: 45757 LoopCount: 1
Pid: 45758 LoopCount: 1
Pid: 45759 LoopCount: 1
Pid: 45755 LoopCount: 2Pid: 45756 LoopCount: 2

Pid: 45757 LoopCount: 2
Pid: 45758 LoopCount: 2
Pid: 45759 LoopCount: 2
Pid: 45756 LoopCount: 3
Pid: 45755 LoopCount: 3
Pid: 45757 LoopCount: 3
Pid: 45758 LoopCount: 3
Pid: 45759 LoopCount: 3
Pid: 45755 LoopCount: 4
Pid: 45756 LoopCount: 4
Pid: 45757 LoopCount: 4
Pid: 45759 LoopCount: 4
Pid: 45758 LoopCount: 4
Pid: 45756 LoopCount: 5
Pid: 45755 LoopCount: 5
Pid: 45757 LoopCount: 5
Pid: 45759 LoopCount: 5
Pid: 45758 LoopCount: 5
Pid: 45756 LoopCount: 6Pid: 45755 LoopCount: 6

Pid: 45757 LoopCount: 6
Pid: 45759 LoopCount: 6
Pid: 45758 LoopCount: 6
Pid: 45755 LoopCount: 7Pid: 45756 LoopCount: 7

Pid: 45757 LoopCount: 7
Pid: 45758 LoopCount: 7
Pid: 45759 LoopCount: 7
Pid: 45756 LoopCount: 8Pid: 45755 LoopCount: 8

Pid: 45757 LoopCount: 8
Pid: 45758 LoopCount: 8Pid: 45759 LoopCount: 8

Pid: 45755 LoopCount: 9
Pid: 45756 LoopCount: 9
Pid: 45757 LoopCount: 9
Pid: 45758 LoopCount: 9
Pid: 45759 LoopCount: 9
Pid: 45756 LoopCount: 10
Pid: 45757 LoopCount: 10
Pid: 45758 LoopCount: 10
Pid: 45759 LoopCount: 10
Pid: 45757 LoopCount: 11
Pid: 45758 LoopCount: 11
Pid: 45759 LoopCount: 11
Pid: 45758 LoopCount: 12
Pid: 45759 LoopCount: 12
Pid: 45759 LoopCount: 13

可以看到有些输出已经造成了影响。 然后我们对其加锁：

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

from multiprocessing import Process, Lock
import time


class MyProcess(Process):
    def __init__(self, loop, lock):
        Process.__init__(self)
        self.loop = loop
        self.lock = lock

    def run(self):
        for count in range(self.loop):
            time.sleep(0.1)
            self.lock.acquire()
            print('Pid: ' + str(self.pid) + ' LoopCount: ' + str(count))
            self.lock.release()

if __name__ == '__main__':
    lock = Lock()
    for i in range(10, 15):
        p = MyProcess(i, lock)
        p.start()

我们在 print 方法的前后分别添加了获得锁和释放锁的操作。这样就能保证在同一时间只有一个 print 操作。 看一下运行结果：

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

Pid: 45889 LoopCount: 0
Pid: 45890 LoopCount: 0
Pid: 45891 LoopCount: 0
Pid: 45892 LoopCount: 0
Pid: 45893 LoopCount: 0
Pid: 45889 LoopCount: 1
Pid: 45890 LoopCount: 1
Pid: 45891 LoopCount: 1
Pid: 45892 LoopCount: 1
Pid: 45893 LoopCount: 1
Pid: 45889 LoopCount: 2
Pid: 45890 LoopCount: 2
Pid: 45891 LoopCount: 2
Pid: 45892 LoopCount: 2
Pid: 45893 LoopCount: 2
Pid: 45889 LoopCount: 3
Pid: 45890 LoopCount: 3
Pid: 45891 LoopCount: 3
Pid: 45892 LoopCount: 3
Pid: 45893 LoopCount: 3
Pid: 45889 LoopCount: 4
Pid: 45890 LoopCount: 4
Pid: 45891 LoopCount: 4
Pid: 45892 LoopCount: 4
Pid: 45893 LoopCount: 4
Pid: 45889 LoopCount: 5
Pid: 45890 LoopCount: 5
Pid: 45891 LoopCount: 5
Pid: 45892 LoopCount: 5
Pid: 45893 LoopCount: 5
Pid: 45889 LoopCount: 6
Pid: 45890 LoopCount: 6
Pid: 45891 LoopCount: 6
Pid: 45893 LoopCount: 6
Pid: 45892 LoopCount: 6
Pid: 45889 LoopCount: 7
Pid: 45890 LoopCount: 7
Pid: 45891 LoopCount: 7
Pid: 45892 LoopCount: 7
Pid: 45893 LoopCount: 7
Pid: 45889 LoopCount: 8
Pid: 45890 LoopCount: 8
Pid: 45891 LoopCount: 8
Pid: 45892 LoopCount: 8
Pid: 45893 LoopCount: 8
Pid: 45889 LoopCount: 9
Pid: 45890 LoopCount: 9
Pid: 45891 LoopCount: 9
Pid: 45892 LoopCount: 9
Pid: 45893 LoopCount: 9
Pid: 45890 LoopCount: 10
Pid: 45891 LoopCount: 10
Pid: 45892 LoopCount: 10
Pid: 45893 LoopCount: 10
Pid: 45891 LoopCount: 11
Pid: 45892 LoopCount: 11
Pid: 45893 LoopCount: 11
Pid: 45893 LoopCount: 12
Pid: 45892 LoopCount: 12
Pid: 45893 LoopCount: 13

嗯，一切都没问题了。 所以在访问临界资源时，使用 Lock 就可以避免进程同时占用资源而导致的一些问题。

Semaphore

信号量，是在进程同步过程中一个比较重要的角色。可以控制临界资源的数量，保证各个进程之间的互斥和同步。 如果你学过操作系统，那么一定对这方面非常了解，如果你还不了解信号量是什么，可以参考 信号量解析 来了解一下它是做什么的。 那么接下来我们就用一个实例来演示一下进程之间利用 Semaphore 做到同步和互斥，以及控制临界资源数量。

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

from multiprocessing import Process, Semaphore, Lock, Queue
import time

buffer = Queue(10)
empty = Semaphore(2)
full = Semaphore(0)
lock = Lock()

class Consumer(Process):

    def run(self):
        global buffer, empty, full, lock
        while True:
            full.acquire()
            lock.acquire()
            buffer.get()
            print('Consumer pop an element')
            time.sleep(1)
            lock.release()
            empty.release()


class Producer(Process):
    def run(self):
        global buffer, empty, full, lock
        while True:
            empty.acquire()
            lock.acquire()
            buffer.put(1)
            print('Producer append an element')
            time.sleep(1)
            lock.release()
            full.release()


if __name__ == '__main__':
    p = Producer()
    c = Consumer()
    p.daemon = c.daemon = True
    p.start()
    c.start()
    p.join()
    c.join()
    print 'Ended!'

如上代码实现了注明的生产者和消费者问题，定义了两个进程类，一个是消费者，一个是生产者。 定义了一个共享队列，利用了 Queue 数据结构，然后定义了两个信号量，一个代表缓冲区空余数，一个表示缓冲区占用数。 生产者 Producer 使用 empty.acquire()方法来占用一个缓冲区位置，然后缓冲区空闲区大小减小 1，接下来进行加锁，对缓冲区进行操作。然后释放锁，然后让代表占用的缓冲区位置数量+1，消费者则相反。 运行结果如下：

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

Producer append an element
Producer append an element
Consumer pop an element
Consumer pop an element
Producer append an element
Producer append an element
Consumer pop an element
Consumer pop an element
Producer append an element
Producer append an element
Consumer pop an element
Consumer pop an element
Producer append an element
Producer append an element

可以发现两个进程在交替运行，生产者先放入缓冲区物品，然后消费者取出，不停地进行循环。 通过上面的例子来体会一下信号量的用法。

Queue

在上面的例子中我们使用了 Queue，可以作为进程通信的共享队列使用。 在上面的程序中，如果你把 Queue 换成普通的 list，是完全起不到效果的。即使在一个进程中改变了这个 list，在另一个进程也不能获取到它的状态。 因此进程间的通信，队列需要用 Queue。当然这里的队列指的是 multiprocessing.Queue 依然是用上面那个例子，我们一个进程向队列中放入数据，然后另一个进程取出数据。

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

from multiprocessing import Process, Semaphore, Lock, Queue
import time
from random import random

buffer = Queue(10)
empty = Semaphore(2)
full = Semaphore(0)
lock = Lock()

class Consumer(Process):

    def run(self):
        global buffer, empty, full, lock
        while True:
            full.acquire()
            lock.acquire()
            print 'Consumer get', buffer.get()
            time.sleep(1)
            lock.release()
            empty.release()


class Producer(Process):
    def run(self):
        global buffer, empty, full, lock
        while True:
            empty.acquire()
            lock.acquire()
            num = random()
            print 'Producer put ', num
            buffer.put(num)
            time.sleep(1)
            lock.release()
            full.release()


if __name__ == '__main__':
    p = Producer()
    c = Consumer()
    p.daemon = c.daemon = True
    p.start()
    c.start()
    p.join()
    c.join()
    print 'Ended!'

运行结果：

1
2
3
4
5
6
7
8

Producer put  0.719213647437
Producer put  0.44287326683
Consumer get 0.719213647437
Consumer get 0.44287326683
Producer put  0.722859424381
Producer put  0.525321338921
Consumer get 0.722859424381
Consumer get 0.525321338921

可以看到生产者放入队列中数据，然后消费者将数据取出来。 get 方法有两个参数，blocked 和 timeout，意思为阻塞和超时时间。默认 blocked 是 true，即阻塞式。 当一个队列为空的时候如果再用 get 取则会阻塞，所以这时候就需要吧 blocked 设置为 false，即非阻塞式，实际上它就会调用 get_nowait()方法，此时还需要设置一个超时时间，在这么长的时间内还没有取到队列元素，那就抛出 Queue.Empty 异常。 当一个队列为满的时候如果再用 put 放则会阻塞，所以这时候就需要吧 blocked 设置为 false，即非阻塞式，实际上它就会调用 put_nowait()方法，此时还需要设置一个超时时间，在这么长的时间内还没有放进去元素，那就抛出 Queue.Full 异常。 另外队列中常用的方法 Queue.qsize() 返回队列的大小 ，不过在 Mac OS 上没法运行。 原因：

def qsize(self): # Raises NotImplementedError on Mac OSX because of broken sem_getvalue() return self._maxsize - self._sem._semlock._get_value()

Queue.empty() 如果队列为空，返回 True, 反之 False Queue.full() 如果队列满了，返回 True,反之 False Queue.get([block[, timeout]]) 获取队列，timeout 等待时间 Queue.get_nowait() 相当 Queue.get(False) Queue.put(item) 阻塞式写入队列，timeout 等待时间 Queue.put_nowait(item) 相当 Queue.put(item, False)

Pipe

管道，顾名思义，一端发一端收。 Pipe 可以是单向(half-duplex)，也可以是双向(duplex)。我们通过 mutiprocessing.Pipe(duplex=False)创建单向管道 (默认为双向)。一个进程从 PIPE 一端输入对象，然后被 PIPE 另一端的进程接收，单向管道只允许管道一端的进程输入，而双向管道则允许从两端输入。 用一个实例来感受一下：

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

from multiprocessing import Process, Pipe


class Consumer(Process):
    def __init__(self, pipe):
        Process.__init__(self)
        self.pipe = pipe

    def run(self):
        self.pipe.send('Consumer Words')
        print 'Consumer Received:', self.pipe.recv()


class Producer(Process):
    def __init__(self, pipe):
        Process.__init__(self)
        self.pipe = pipe

    def run(self):
        print 'Producer Received:', self.pipe.recv()
        self.pipe.send('Producer Words')


if __name__ == '__main__':
    pipe = Pipe()
    p = Producer(pipe[0])
    c = Consumer(pipe[1])
    p.daemon = c.daemon = True
    p.start()
    c.start()
    p.join()
    c.join()
    print 'Ended!'

在这里声明了一个默认为双向的管道，然后将管道的两端分别传给两个进程。两个进程互相收发。观察一下结果：

1
2
3

Producer Received: Consumer Words
Consumer Received: Producer Words
Ended!

以上是对 pipe 的简单介绍。

Pool

在利用 Python 进行系统管理的时候，特别是同时操作多个文件目录，或者远程控制多台主机，并行操作可以节约大量的时间。当被操作对象数目不大时，可以直接利用 multiprocessing 中的 Process 动态成生多个进程，十几个还好，但如果是上百个，上千个目标，手动的去限制进程数量却又太过繁琐，此时可以发挥进程池的功效。 Pool 可以提供指定数量的进程，供用户调用，当有新的请求提交到 pool 中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；但如果池中的进程数已经达到规定最大值，那么该请求就会等待，直到池中有进程结束，才会创建新的进程来它。 在这里需要了解阻塞和非阻塞的概念。 阻塞和非阻塞关注的是程序在等待调用结果（消息，返回值）时的状态。 阻塞即要等到回调结果出来，在有结果之前，当前进程会被挂起。 Pool 的用法有阻塞和非阻塞两种方式。非阻塞即为添加进程后，不一定非要等到改进程执行完就添加其他进程运行，阻塞则相反。 现用一个实例感受一下非阻塞的用法：

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

from multiprocessing import Lock, Pool
import time


def function(index):
    print 'Start process: ', index
    time.sleep(3)
    print 'End process', index


if __name__ == '__main__':
    pool = Pool(processes=3)
    for i in xrange(4):
        pool.apply_async(function, (i,))

    print "Started processes"
    pool.close()
    pool.join()
    print "Subprocess done."

在这里利用了 apply_async 方法，即非阻塞。 运行结果：

1
2
3
4
5
6
7
8
9
10

Started processes
Start process: Start process:  0
1
Start process:  2
End processEnd process 0
1
Start process:  3
End process 2
End process 3
Subprocess done.

可以发现在这里添加三个进程进去后，立马就开始执行，不用非要等到某个进程结束后再添加新的进程进去。 下面再看看阻塞的用法：

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

from multiprocessing import Lock, Pool
import time


def function(index):
    print 'Start process: ', index
    time.sleep(3)
    print 'End process', index


if __name__ == '__main__':
    pool = Pool(processes=3)
    for i in xrange(4):
        pool.apply(function, (i,))

    print "Started processes"
    pool.close()
    pool.join()
    print "Subprocess done."

在这里只需要把 apply_async 改成 apply 即可。 运行结果如下：

1
2
3
4
5
6
7
8
9
10

Start process:  0
End process 0
Start process:  1
End process 1
Start process:  2
End process 2
Start process:  3
End process 3
Started processes
Subprocess done.

这样一来就好理解了吧？ 下面对函数进行解释： apply_async(func[, args[, kwds[, callback]]]) 它是非阻塞，apply(func[, args[, kwds]])是阻塞的。 close() 关闭 pool，使其不在接受新的任务。 terminate() 结束工作进程，不在处理未完成的任务。 join() 主进程阻塞，等待子进程的退出， join 方法要在 close 或 terminate 之后使用。 当然每个进程可以在各自的方法返回一个结果。apply 或 apply_async 方法可以拿到这个结果并进一步进行处理。

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

from multiprocessing import Lock, Pool
import time


def function(index):
    print 'Start process: ', index
    time.sleep(3)
    print 'End process', index
    return index

if __name__ == '__main__':
    pool = Pool(processes=3)
    for i in xrange(4):
        result = pool.apply_async(function, (i,))
        print result.get()
    print "Started processes"
    pool.close()
    pool.join()
    print "Subprocess done."

运行结果：

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

Start process:  0
End process 0
0
Start process:  1
End process 1
1
Start process:  2
End process 2
2
Start process:  3
End process 3
3
Started processes
Subprocess done.

另外还有一个非常好用的 map 方法。 如果你现在有一堆数据要处理，每一项都需要经过一个方法来处理，那么 map 非常适合。 比如现在你有一个数组，包含了所有的 URL，而现在已经有了一个方法用来抓取每个 URL 内容并解析，那么可以直接在 map 的第一个参数传入方法名，第二个参数传入 URL 数组。 现在我们用一个实例来感受一下：

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

from multiprocessing import Pool
import requests
from requests.exceptions import ConnectionError


def scrape(url):
    try:
        print requests.get(url)
    except ConnectionError:
        print 'Error Occured ', url
    finally:
        print 'URL ', url, ' Scraped'


if __name__ == '__main__':
    pool = Pool(processes=3)
    urls = [
        'https://www.baidu.com',
        'http://www.meituan.com/',
        'http://blog.csdn.net/',
        'http://xxxyxxx.net'
    ]
    pool.map(scrape, urls)

在这里初始化一个 Pool，指定进程数为 3，如果不指定，那么会自动根据 CPU 内核来分配进程数。 然后有一个链接列表，map 函数可以遍历每个 URL，然后对其分别执行 scrape 方法。 运行结果：

1
2
3
4
5
6
7
8

<Response [403]>
URL  http://blog.csdn.net/  Scraped
<Response [200]>
URL  https://www.baidu.com  Scraped
Error Occured  http://xxxyxxx.net
URL  http://xxxyxxx.net  Scraped
<Response [200]>
URL  http://www.meituan.com/  Scraped

可以看到遍历就这么轻松地实现了。

结语

多进程 multiprocessing 相比多线程功能强大太多，而且使用范围更广，希望本文对大家有帮助！

本文参考

https://docs.python.org/2/library/multiprocessing.html http://www.cnblogs.com/vamei/archive/2012/10/12/2721484.html http://www.cnblogs.com/kaituorensheng/p/4445418.html https://my.oschina.net/yangyanxing/blog/296052

好了！开头要说点啥，我想你们已经知道了！ 没错！我又来装逼了·· 前面两篇博文，不知道大家消化得怎么了。不知道各位有没注意到，前面两篇博文完成的工作，只能保证下载；你电脑不能关机，不能断网，总之不能出意外！否则啊！！！ ！！！！你就得重头开始啊！！！！ 今天，我们来想想办法让它不重头下载；我们来记录我们已经下载过的地址！ヾ(＠⌒ ー ⌒＠)ノ这样就可以实现不重新下载啦！ 本来刚开始我是准备用本地 txt 来记录的，不过仔细一想用本地 txt 逼格不够啊！要不用 MySQL 吧！然后我自己就用了 MySQL。 然而你以为我会在这教程里面用 MySQL 嘛！哈哈哈！我们来用 MongoDB！！这数据库最近很火啊！逼格直线提升啊！哈哈哈！点我去官网下载 安装 mongoDB: 在 C 盘建一个用来存储数据的文件夹 MongoDB； 创建以下两个目录： C:\data\log\mongod.log 存储日志 C:\data\db 存储数据 在 C:\MongoDB 文件夹下面创建一个 mongod.cfg 的配置文件写入以下配置： 一定要取消隐藏后缀名，不然更改不会生效！

1
2
3
4
5

systemLog:
 destination: file
 path: C:\data\log\mongod.log
storage:
 dbPath: C:\data\db

在管理员权限的 cmd 中执行以下命令将 mongoDB 安装成服务:

1

"C:\mongodb\bin\mongod.exe" --config "C:\mongodb\mongod.cfg" --install

上面两张图片是 GIF 点击是可以看到过程的哦！！！ヾ(=ﾟ･ﾟ=)ﾉ喵 ♪ 服务器安装完了，CMD 启动一下： 搞定！ 好啦！数据库装完了，我们来接着上一篇博文的内容继续啦！ 保险起见建议大家还是看一下 MongoDB 的基础（只需要知道那些命令是做了啥，这样就好啦！） 首先我们我们这一次需要一个模块 PyMongo；这是 Python 用来操作 MongoDB 的模块，不要担心使用起来很简单的！

1

pip install PyMongo

现在我们在上一篇博文完成的代码中导入模块：

1

from pymongo import MongoClient

第一步： 在 class mzitu(): 下面添加这样一个函数：

1
2
3
4
5
6
7

def __init__(self):
    client = MongoClient() ##与MongDB建立连接（这是默认连接本地MongDB数据库）
    db = client['meinvxiezhenji'] ## 选择一个数据库
    self.meizitu_collection = db['meizitu'] ##在meizixiezhenji这个数据库中，选择一个集合
    self.title = '' ##用来保存页面主题
    self.url = '' ##用来保存页面地址
    self.img_urls = [] ##初始化一个 列表 用来保存图片地址

好啦！第一步搞定， 第二步： 我们更改一下 def all_url 函数：

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

def all_url(self, url):
    html = down.get(url, 3)
    all_a = BeautifulSoup(html.text, 'lxml').find('div', class_='all').find_all('a')
    for a in all_a:
        title = a.get_text()
        self.title = title ##将主题保存到self.title中
        print(u'开始保存：', title)
        path = str(title).replace("?", '_')
        self.mkdir(path)
        os.chdir("D:\mzitu\\"+path)
        href = a['href']
        self.url = href ##将页面地址保存到self.url中
        if self.meizitu_collection.find_one({'主题页面': href}):  ##判断这个主题是否已经在数据库中、不在就运行else下的内容，在则忽略。
            print(u'这个页面已经爬取过了')
        else:
            self.html(href)

第三步： 我们来改一下 def html 这个函数：

1
2
3
4
5
6
7
8

def html(self, href):
    html = down.get(href, 3)
    max_span = BeautifulSoup(html.text, 'lxml').find_all('span')[10].get_text()
    page_num = 0  ##这个当作计数器用 （用来判断图片是否下载完毕）
    for page in range(1, int(max_span) + 1):
        page_num = page_num + 1 ##每for循环一次就+1  （当page_num等于max_span的时候，就证明我们的在下载最后一张图片了）
        page_url = href + '/' + str(page)
        self.img(page_url, max_span, page_num)  ##把上面我们我们需要的两个变量，传递给下一个函数。

第四步： 我们来改一下 def img 这个函数：

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

def img(self, page_url, max_span, page_num): ##添加上面传递的参数
    img_html = down.get(page_url, 3)
    img_url = BeautifulSoup(img_html.text, 'lxml').find('div', class_='main-image').find('img')['src']
    self.img_urls.append(img_url) ##每一次 for page in range(1, int(max_span) + 1)获取到的图片地址都会添加到 img_urls这个初始化的列表
    if int(max_span) == page_num: ##我们传递下来的两个参数用上了 当max_span和Page_num相等时，就是最后一张图片了，最后一次下载图片并保存到数据库中。
        self.save(img_url)
        post = {  ##这是构造一个字典，里面有啥都是中文，很好理解吧！
            '标题': self.title,
            '主题页面': self.url,
            '图片地址': self.img_urls,
            '获取时间': datetime.datetime.now()
        }
        self.meizitu_collection.save(post) ##将post中的内容写入数据库。
        print(u'插入数据库成功')
    else:  ##max_span 不等于 page_num执行这下面
        self.save(img_url)

self.meizitu_collection.save(post) 这个是怎么来的我要说一下，可能有点迷糊： def init(self): 函数中： client = MongoClient() db = client[‘meinvxiezhenji’] self.meizitu_collection = db[‘meizitu’] 所以意思就是：在 meizixiezhenji 这个数据库中的 meizitu 这个集合保存 post 这个字典里面的数据哦！这么解释懂了吧？ヾ(＠⌒ ー ⌒＠)ノ 好了、一个可以实现去重的爬虫就实现了！φ(゜ ▽ ゜*)♪ 是不是好简单 哈哈哈 顺带还存储了一堆信息（才不会告诉你们这才是我需要的呢） 好了 完整的代码贴上来了！ PS:需要先说一下 MongDB 是不需要先建数据库和集合的，会自动判断 存在则直接写入数据，不存在 则先创建需要的数据库和集合，再写入数据（是不是超爽？哈哈哈）

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

from bs4 import BeautifulSoup
import os
from Download import down ##导入模块变了一下
from pymongo import MongoClient
import datetime

class mzitu():

    def __init__(self):
        client = MongoClient() ##与MongDB建立连接（这是默认连接本地MongDB数据库）
        db = client['meinvxiezhenji'] ## 选择一个数据库
        self.meizitu_collection = db['meizitu'] ##在meizixiezhenji这个数据库中，选择一个集合
        self.title = '' ##用来保存页面主题
        self.url = '' ##用来保存页面地址
        self.img_urls = [] ##初始化一个 列表  用来保存图片地址

    def all_url(self, url):
        html = down.get(url, 3)
        all_a = BeautifulSoup(html.text, 'lxml').find('div', class_='all').find_all('a')
        for a in all_a:
            title = a.get_text()
            self.title = title ##将主题保存到self.title中
            print(u'开始保存：', title)
            path = str(title).replace("?", '_')
            self.mkdir(path)
            os.chdir("D:\mzitu\\"+path)
            href = a['href']
            self.url = href ##将页面地址保存到self.url中
            if self.meizitu_collection.find_one({'主题页面': href}):  ##判断这个主题是否已经在数据库中、不在就运行else下的内容，在则忽略。
                print(u'这个页面已经爬取过了')
            else:
                self.html(href)

    def html(self, href):
        html = down.get(href, 3)
        max_span = BeautifulSoup(html.text, 'lxml').find_all('span')[10].get_text()
        page_num = 0  ##这个当作计数器用 （用来判断图片是否下载完毕）
        for page in range(1, int(max_span) + 1):
            page_num = page_num + 1 ##每for循环一次就+1  （当page_num等于max_span的时候，就证明我们的在下载最后一张图片了）
            page_url = href + '/' + str(page)
            self.img(page_url, max_span, page_num)  ##把上面我们我们需要的两个变量，传递给下一个函数。

    def img(self, page_url, max_span, page_num): ##添加上面传递的参数
        img_html = down.get(page_url, 3)
        img_url = BeautifulSoup(img_html.text, 'lxml').find('div', class_='main-image').find('img')['src']
        self.img_urls.append(img_url) ##每一次 for page in range(1, int(max_span) + 1)获取到的图片地址都会添加到 img_urls这个初始化的列表
        if int(max_span) == page_num: ##我们传递下来的两个参数用上了 当max_span和Page_num相等时，就是最后一张图片了，最后一次下载图片并保存到数据库中。
            self.save(img_url)
            post = {  ##这是构造一个字典，里面有啥都是中文，很好理解吧！
                '标题': self.title,
                '主题页面': self.url,
                '图片地址': self.img_urls,
                '获取时间': datetime.datetime.now()
            }
            self.meizitu_collection.save(post) ##将post中的内容写入数据库。
            print(u'插入数据库成功')
        else:  ##max_span 不等于 page_num执行这下面
            self.save(img_url)


    def save(self, img_url):
        name = img_url[-9:-4]
        print(u'开始保存：', img_url)
        img = down.get(img_url, 3)
        f = open(name + '.jpg', 'ab')
        f.write(img.content)
        f.close()

    def mkdir(self, path):
        path = path.strip()
        isExists = os.path.exists(os.path.join("D:\mzitu", path))
        if not isExists:
            print(u'建了一个名字叫做', path, u'的文件夹！')
            os.makedirs(os.path.join("D:\mzitu", path))
            return True
        else:
            print(u'名字叫做', path, u'的文件夹已经存在了！')
            return False




Mzitu = mzitu() ##实例化
Mzitu.all_url('http://www.mzitu.com/all') ##给函数all_url传入参数  你可以当作启动爬虫（就是入口）

2022 年最新 Python3 网络爬虫教程

大家好，我是崔庆才，由于爬虫技术不断迭代升级，一些旧的教程已经过时、案例已经过期，最前沿的爬虫技术比如异步、JavaScript 逆向、安卓逆向、智能解析、WebAssembly、大规模分布式、Kubernetes 等技术层出不穷，我最近新出了一套最新最全面的 Python3 网络爬虫系列教程。

博主自荐：截止 2022 年，可以将最前沿最全面的爬虫技术都涵盖的教程，如异步、JavaScript 逆向、安卓逆向、智能解析、WebAssembly、大规模分布式、Kubernetes 等，市面上目前就这一套了。

最新教程对旧的爬虫技术内容进行了全面更新，搭建了全新的案例平台进行全面讲解，保证案例稳定有效不过期。

教程请移步：

【2022 版】Python3 网络爬虫学习教程

如下为原文。

前言

我们之前写的爬虫都是单个线程的？这怎么够？一旦一个地方卡到不动了，那不就永远等待下去了？为此我们可以使用多线程或者多进程来处理。 首先声明一点！ 多线程和多进程是不一样的！一个是 thread 库，一个是 multiprocessing 库。而多线程 thread 在 Python 里面被称作鸡肋的存在！而没错！本节介绍的是就是这个库 thread。 不建议你用这个，不过还是介绍下了，如果想看可以看看下面，不想浪费时间直接看 multiprocessing 多进程

鸡肋点

名言：

“Python下多线程是鸡肋，推荐使用多进程！”

那当然有同学会问了，为啥？

背景

1、GIL是什么？ GIL的全称是Global Interpreter Lock(全局解释器锁)，来源是python设计之初的考虑，为了数据安全所做的决定。 2、每个CPU在同一时间只能执行一个线程（在单核CPU下的多线程其实都只是并发，不是并行，并发和并行从宏观上来讲都是同时处理多路请求的概念。但并发和并行又有区别，并行是指两个或者多个事件在同一时刻发生；而并发是指两个或多个事件在同一时间间隔内发生。） 在Python多线程下，每个线程的执行方式：

• 获取GIL
• 执行代码直到sleep或者是python虚拟机将其挂起。
• 释放GIL

可见，某个线程想要执行，必须先拿到GIL，我们可以把GIL看作是“通行证”，并且在一个python进程中，GIL只有一个。拿不到通行证的线程，就不允许进入CPU执行。 在Python2.x里，GIL的释放逻辑是当前线程遇见IO操作或者ticks计数达到100（ticks可以看作是Python自身的一个计数器，专门做用于GIL，每次释放后归零，这个计数可以通过 sys.setcheckinterval 来调整），进行释放。 而每次释放GIL锁，线程进行锁竞争、切换线程，会消耗资源。并且由于GIL锁存在，python里一个进程永远只能同时执行一个线程(拿到GIL的线程才能执行)，这就是为什么在多核CPU上，python的多线程效率并不高。

那么是不是python的多线程就完全没用了呢？

在这里我们进行分类讨论： 1、CPU密集型代码(各种循环处理、计数等等)，在这种情况下，由于计算工作多，ticks计数很快就会达到阈值，然后触发GIL的释放与再竞争（多个线程来回切换当然是需要消耗资源的），所以python下的多线程对CPU密集型代码并不友好。 2、IO密集型代码(文件处理、网络爬虫等)，多线程能够有效提升效率(单线程下有IO操作会进行IO等待，造成不必要的时间浪费，而开启多线程能在线程A等待时，自动切换到线程B，可以不浪费CPU的资源，从而能提升程序执行效率)。所以python的多线程对IO密集型代码比较友好。 而在python3.x中，GIL不使用ticks计数，改为使用计时器（执行时间达到阈值后，当前线程释放GIL），这样对CPU密集型程序更加友好，但依然没有解决GIL导致的同一时间只能执行一个线程的问题，所以效率依然不尽如人意。

多核性能

多核多线程比单核多线程更差，原因是单核下多线程，每次释放GIL，唤醒的那个线程都能获取到GIL锁，所以能够无缝执行，但多核下，CPU0释放GIL后，其他CPU上的线程都会进行竞争，但GIL可能会马上又被CPU0拿到，导致其他几个CPU上被唤醒后的线程会醒着等待到切换时间后又进入待调度状态，这样会造成线程颠簸(thrashing)，导致效率更低

多进程为什么不会这样？

每个进程有各自独立的GIL，互不干扰，这样就可以真正意义上的并行执行，所以在python中，多进程的执行效率优于多线程(仅仅针对多核CPU而言)。 所以在这里说结论：多核下，想做并行提升效率，比较通用的方法是使用多进程，能够有效提高执行效率。 所以，如果不想浪费时间，可以直接看多进程。

直接利用函数创建多线程

Python中使用线程有两种方式：函数或者用类来包装线程对象。

函数式：调用thread模块中的start_new_thread()函数来产生新线程。语法如下：

1

thread.start_new_thread(function, args[, kwargs])

参数说明:

• function - 线程函数。
• args - 传递给线程函数的参数,他必须是个tuple类型。
• kwargs - 可选参数。

先用一个实例感受一下：

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

# -*- coding: UTF-8 -*-

import thread
import time


# 为线程定义一个函数
def print_time(threadName, delay):
    count = 0
    while count < 5:
        time.sleep(delay)
        count += 1
        print "%s: %s" % (threadName, time.ctime(time.time()))


# 创建两个线程
try:
    thread.start_new_thread(print_time, ("Thread-1", 2,))
    thread.start_new_thread(print_time, ("Thread-2", 4,))
except:
    print "Error: unable to start thread"


while 1:
   pass

print "Main Finished"

运行结果如下：

1
2
3
4
5
6
7
8
9
10

Thread-1: Thu Nov  3 16:43:01 2016
Thread-2: Thu Nov  3 16:43:03 2016
Thread-1: Thu Nov  3 16:43:03 2016
Thread-1: Thu Nov  3 16:43:05 2016
Thread-2: Thu Nov  3 16:43:07 2016
Thread-1: Thu Nov  3 16:43:07 2016
Thread-1: Thu Nov  3 16:43:09 2016
Thread-2: Thu Nov  3 16:43:11 2016
Thread-2: Thu Nov  3 16:43:15 2016
Thread-2: Thu Nov  3 16:43:19 2016

可以发现，两个线程都在执行，睡眠2秒和4秒后打印输出一段话。 注意到，在主线程写了

1
2

while 1:
   pass

这是让主线程一直在等待 如果去掉上面两行，那就直接输出

1

Main Finished

程序执行结束。

使用Threading模块创建线程

使用Threading模块创建线程，直接从threading.Thread继承，然后重写init方法和run方法：

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

#!/usr/bin/python
# -*- coding: UTF-8 -*-

import threading
import time

import thread

exitFlag = 0

class myThread (threading.Thread):   #继承父类threading.Thread
    def __init__(self, threadID, name, counter):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.counter = counter
    def run(self):                   #把要执行的代码写到run函数里面 线程在创建后会直接运行run函数
        print "Starting " + self.name
        print_time(self.name, self.counter, 5)
        print "Exiting " + self.name

def print_time(threadName, delay, counter):
    while counter:
        if exitFlag:
            thread.exit()
        time.sleep(delay)
        print "%s: %s" % (threadName, time.ctime(time.time()))
        counter -= 1

# 创建新线程
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)

# 开启线程
thread1.start()
thread2.start()

print "Exiting Main Thread"

运行结果：

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

Starting Thread-1Starting Thread-2
 
Exiting Main Thread
Thread-1: Thu Nov  3 18:42:19 2016
Thread-2: Thu Nov  3 18:42:20 2016
Thread-1: Thu Nov  3 18:42:20 2016
Thread-1: Thu Nov  3 18:42:21 2016
Thread-2: Thu Nov  3 18:42:22 2016
Thread-1: Thu Nov  3 18:42:22 2016
Thread-1: Thu Nov  3 18:42:23 2016
Exiting Thread-1
Thread-2: Thu Nov  3 18:42:24 2016
Thread-2: Thu Nov  3 18:42:26 2016
Thread-2: Thu Nov  3 18:42:28 2016
Exiting Thread-2