今天这篇文章是要告诉你，业内多名实力强劲的开发者组建了一个服务于广大开发者的团队。现在，你可能会有下面这些疑问：

• 为什么要组成团队呢？
• 这个团队将会给广大开发者带来什么？
• 团队成员有哪些？

好了，接下来用 3 分钟时间去了解这个团队吧！

夜幕团队简介

夜幕团队 NightTeam 于 2019 年 9 月 9 日正式成立，团队由爬虫领域中实力强劲的多名开发者组成：崔庆才、周子淇、陈祥安、唐轶飞、冯威、蔡晋、戴煌金、张冶青和韦世东。 NightTeam 涉猎的编程语言包括但不限于 Python、Rust、C++、Go，领域涵盖爬虫、深度学习、服务研发和对象存储等，团队技术实力十分雄厚。

为什么要组建一个团队？

据以往经验来看，产出一篇优质的技术文章所耗费的时间是相当长的，读者很难从单个作者那里获得成体系且覆盖面较广的知识。 对于作者而言，粉丝的积累、文章的持续编写都是一个慢跑的过程，很多优秀的作者会因为没有粉丝、投入产出比差距太大等因素暂停写作。 更有甚者，文章内容质量越来越低、标题越来越唬、广告越来越多，一门心思放在如何涨粉和变现上。如此循环，就会影响技术圈和技术生态的发展。 如果将那些优秀的作者联合起来（即合纵连横），共同运营一系列的技术媒体号，在不增加负担的情况下还能保证优质文章的产出，会怎么样呢？

我们也不知道，但是我们已经意识到了这个问题，也尝试着寻找答案。这就是夜幕团队 NightTeam 组建的大环境背景。

团队希望做什么事？

互联网是开放的，技术也是开放的。适当的共享可以加速我们的进步，无论是作者还是读者，都能够从分享的过程中获得一些东西。

在开发中，我们会用到一些库和框架。当我刚编程入门的时候，就想着有一天也要编写开源项目，为其他开发者提供帮助，这正是夜幕团队想要做的事。 当然，我们想要做的不仅仅是编写一个开源项目，我们更希望将知识分享出去，在技术圈中传播开来，让更多的人得到帮助。

团队能够为开发者带来什么？

读者的能力和阶段各不相同，每个人收获的内容也不同。宽泛来说，读者可以从夜幕团队 NightTeam 输出的内容中获得对待问题的处理方式、分析问题的思路、解决问题的技巧、问题背后的逻辑等。 假如你是一名中级爬虫工程师，那么夜幕团队 NightTeam 输出的内容可能会为你解决工作中遇到的一些反爬虫问题带来思路。

如果你是一名后端开发者，你也许会从我们发布的类似于【动图演示 - Redis 持久化 RDB/AOF 详解与实践】这样的文章中了解到 Redis 持久化的两种选择的差异和具体操作过程。

团队以什么形式输出内容？

大多数情况下，我们会用文章的形式输出内容。但有时候也会采用直播或者视频教程的方式，兴许还会有现场交流的机会。 为了增加传播广度和影响力，我们不仅仅在微信公众号上发布文章，还会将文章同步到业内著名的几个平台，例如掘金社区、CSDN、SF、V2EX、知乎、今日头条等。

团队成员介绍

团队的成员都是爬虫领域比较活跃的作者，同时也拥有非常强的实力，不会是那些只负责回答小白问题骗钱的盗名之辈。以下将不分先后的列出团队成员姓名、昵称和各自的介绍。 周子淇

昵称 Loco 前微信公众号「小周码字」号主、知乎专栏「手把手教你写爬虫」作者，幂度爬虫工程师。啥方向都搞，除了爬虫相关的文章以外还会写一些灰黑产操作研究、机器学习、造轮子、物联网设备研究、脑洞分享等各种奇奇怪怪的东西。

韦世东

昵称 Asyncins 图灵签约作者、电子工业出版社约稿作者、华为云认证云享专家、掘金社区优秀作者、GitChat 认证作者、搜狐产品技术约稿作者、开源项目 aiowebsocket 作者、微信公众号「Rust之禅」号主、「进击的Coder」运营者之一，有着丰富的爬虫经验，擅长反爬虫的绕过技巧。

崔庆才

昵称 静觅 畅销书《Python3网络爬虫开发实战》作者、微信公众号「进击的Coder」号主，微软中国工程师。主要研究网络爬虫、机器学习、Web 开发相关内容。

陈祥安

昵称 CXA 微信公众号「Python学习开发」号主、CSDN 线下沙龙特邀讲师、华为云享社区专家、阿里云栖社区专家、哔哩哔哩《陈祥安分析Python面试题》系列 UP 主、GitChat 热门文章《Python 常见的 170 道面试题全解析：2019 版》作者，马蜂窝高级爬虫工程师。

唐轶飞

昵称 大鱼 BruceDone 微信公众号「大鱼鱼塘」号主、「http://brucedone.com」站长，腾讯后端工程师。多年 Code 经验，擅长后端开发，语言了解但不限于 .NET、Python、Golang、SQL，兴趣包含但不限于爬虫，后端，数据库，深度学习。

冯 威

昵称 妄为 微信公众号「妄为写代码」号主，爬虫 Coder，佛系程序员。专注 JavaScript、Android 逆向以及验证码破解，对逆向有着丰富的经验。

蔡 晋

昵称 悦来客栈的老板 微信公众号「菜鸟学Python编程」号主，平时喜欢研究各大网站的反爬，熟悉常见网站的反爬操作，对反爬有着独到的见解。

戴煌金

昵称 咸鱼 微信公众号「咸鱼学Python」号主、华为云享专家。专注Python爬虫、JavaScript逆向，立志做一条最咸的咸鱼。

张冶青

昵称：MarvinZ 微信公众号「Crawlab漫游指南」号主、爬虫管理平台 Crawlab 作者、文章发布平台 ArtiPub 作者，知名外企前端开发工程师。专注前端、爬虫和数据分析。

如何与夜幕取得联系？

你可能想跟夜幕团队交流一些技术方面的问题，你可以发送消息“夜幕读者群”到我们的公众号「NightTeam」加入读者群，团队成员都在群里等你。 一些重要的事可以通过邮件与夜幕取得联系，夜幕团队的邮箱为 contact@nightteam.cn。 GitHub 也准备好了，我们会逐渐将开源项目迁移到团队的仓库中，地址为 https://github.com/nightteam

舆情爬虫是网络爬虫一个比较重要的分支，舆情爬虫往往需要爬虫工程师爬取几百几千个新闻站点。比如一个新闻页面我们需要爬取其标题、正文、时间、作者等信息，如果用传统的方式来实现，每一个站点都要配置非常多的规则，如果要维护一个几百上千的站点，那人力成本简直太高了。 如果有一种方式可以在保证差不多的准确率的前提下，大幅提高提取效率的话，就需要用到智能文本提取了。 本文首先介绍一下智能文本提取的基本原理，让大家对智能提取有基本的了解。然后介绍几个比较基础的工具包，准确率并不是很高，可以尝试一用。最后再介绍几篇比较前沿的技术供大家参考。

智能文本提取

目前来说，智能文本提取可以分为三类：

• 基于网页文档内容的提取方法
• 基于 DOM 结构信息的提取方法
• 基于视觉信息的提取方法

基于网页文档的提取方法将 HTML 文档视为文本进行处理，适用于处理含有大量文本信息且结构简单易于处理的单记录网页，或者具有实时要求的在线分析网页应用。 这种方式主要利用自然语言处理相关技术实现，通过理解 文本语义、分析上下文、设定提取规则等，实现对大段网页文档的快速处理。其中，较为知名的方法有 TSIMMIS、Web-OQL、Serrano、FAR-SW 和 FOREST，但这些方法由于通常需要人工的参与，且存在耗时长、效率低的弊端。 基于 DOM 结构信息的方法将 HTML 文档解析为相应的 DOM 树，然后根据 DOM 树的语法结构创建提取规则， 相对于以前的方法而言有了更高的性能和准确率。 W4F 和 XWRAP 将 HTML 文档解析成 DOM 树，然后通过组件化引导用户通过人工选择或者标记生成目标包装器代码。Omini、IEPAD 和 ITE 提取 DOM 树上的关键路径， 获取其中存在的重复模式。MDR 和 DEPTA 挖掘了页面中的数据区域，得到数据记录的模式。CECWS 通过聚类算法从数据库中提取出自同一网站的一组页面，并进行 DOM 树结构的对比，删除其中的静态部分，保留动态内容作为信息提取的结果。虽然此类方法相对于上一类方法 具有较高的提取精度，且克服了对大段连续文本的依赖， 但由于网页的 DOM 树通常较深，含有大量 DOM 节点， 因此基于 DOM 结构信息的方法具有较高的时间和空间消耗。目前来说，大部分原理还是基于 DOM 节点的文本密度、标点符号密度等计算的，其准确率还是比较可观的。今天所介绍的 Readability 和 Newspaper 的库的实现原理就是类似。 目前比较先进的是基于视觉信息的网页信息提取方法，通过浏览器接口或者内核对目标网页预渲染，然后基于网页的视觉规律提取网页数据记录。经典的 VIPS 算法首先从 DOM 树中提取出所有合适的页面区域，然后根据这些页面和分割条重新构建 Web 页面的语义结构。作为对 VIPS 的拓展，ViNT、ViPER、ViDE 也成功利用了网页的视觉特征来实现数据提取。CMDR 为通过神经网络学习多记录型页面中的特征，结合基于 DOM 结构信息的 MDR 方法，挖掘社区论坛页面的数据区域。与上述方法不同，VIBS 将图像领域的 CNN 卷积神经网络运用于网页的截图，同时通过类 VIPS 算法生成视觉块，最后结合两个阶段的结果识别网页的正文区域。另外还有最新的国内提出的 VBIE 方法，基于网页视觉的基础上改进，可以实现无监督的网页信息提取。

以上内容主要参考自论文：《王卫红等：基于可视块的多记录型复杂网页信息提取算法》，算法可从该论文参考文献查阅。

下面我们来介绍两个比较基础的工具包 Readability 和 Newspaper 的用法，这两个包经我测试其实准确率并不是很好，主要是让大家大致对智能解析有初步的理解。后面还会介绍一些更加强大的智能化解析算法。

Readability

Readability 实际上是一个算法，并不是一个针对某个语言的库。其主要原理就是计算了 DOM 的文本密度，另外根据一些常见的 DOM 属性如 id、class 等计算了一些 DOM 的权重，最后分析得到了对应的 DOM 区块，进而提取出具体的文本内容。 现在搜索 Readability 其实已经找不到了，取而代之的是一个 JavaScript 工具包，叫做 mercury-parser，据我所知应该是 Readability 不维护了，换成了 mercury-parser。后者现在也做成了一个 Chrome 插件，大家可以下载使用一下。 回归正题，这次主要介绍的是 Python 的 Readability 实现，现在其实有很多开源版本，本文选取的是 https://github.com/buriy/python-readability，是基于最早的 Python 版本的 Readability 库 https://github.com/timbertson/python-readability 二次开发的，现在已经发布到了 PyPi，大家可以直接下载安装使用。 安装很简单，通过 pip 安装即可：

1

pip3 install readability-lxml

安装好了之后便可以通过导入 readability 使用了，下面我们随便从网上找一个新闻页面，比如：https://tech.163.com/19/0909/08/EOKA3CFB00097U7S.html，其页面截图如下： 我们的目的就是它的正文、标题等内容。下面我们用 Readability 试一下，示例如下：

1
2
3
4
5
6
7
8

import requests
from readability import Document

url = 'https://tech.163.com/19/0909/08/EOKA3CFB00097U7S.html'
html = requests.get(url).content
doc = Document(html)
print('title:', doc.title())
print('content:', doc.summary(html_partial=True))

在这里我们直接用 requests 库对网页进行了请求，获取了其 HTML 页面内容，赋值为 html。 然后引入了 readability 里的 Document 类，使用 html 变量对其进行初始化，然后我们分别调用了 title 方法和 summary 方法获得了其标题和正文内容。 这里 title 方法就是获取文章标题的，summary 就是获取文章正文的，但是它获取的正文可能包含一些 HTML 标签。这个 summary 方法可以接收一个 html_partial 参数，如果设置为 True，返回的结果则不会再带有 <html><body> 标签。 看下运行结果：

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

title: 今年iPhone只有小改进？分析师：还有其他亮点_网易科技
content: <div><div class="post_text" id="endText">
                    <p class="otitle">
                        （原标题：Apple Bets More Cameras Can Keep iPhone Humming）
                    </p>
                    <p class="f_center"><img alt="今年iPhone只有小改进？分析师：还有其他亮点" src="http://cms-bucket.ws.126.net/2019/09/09/d65ba32672934045a5bfadd27f704bc1.jpeg"/><span>图示：苹果首席执行官蒂姆·库克(Tim Cook)在6月份举行的苹果全球开发者大会上。</span></p><p>网易科技讯 9月9日消息，据国外媒体报道，和过去的12个年头一样，新款
... 中间省略 ...
                    <p>苹果还即将推出包括电视节目和视频游戏等内容的新订阅服务。分析师表示，该公司最早可能在本周宣布TV+和Arcade等服务的价格和上线时间。</p><p>Strategy Analytics的尼尔·莫斯顿(Neil Mawston)表示，可穿戴设备和服务的结合将是苹果业务超越iPhone的关键。他说，上一家手机巨头诺基亚公司在试图进行类似业务转型时就陷入了困境之中。（辰辰）</p><p><b>相关报道：</b></p><p><a href="https://tech.163.com/19/0908/09/EOHS53RK000999LD.html" target="_self" urlmacroreplace="false">iPhone 11背部苹果Logo改为居中：为反向无线充电</a></p><p><a href="https://tech.163.com/19/0907/08/EOF60CBC00097U7S.html" target="_self" urlmacroreplace="false">2019年新iPhone传言汇总，你觉得哪些能成真</a>  </p><p/>
                        <p/>
                        <div class="ep-source cDGray">
                            <span class="left"><a href="http://tech.163.com/"><img src="https://static.ws.126.net/cnews/css13/img/end_tech.png" alt="王凤枝" class="icon"/></a> 本文来源：网易科技报道  </span>
                            <span class="ep-editor">责任编辑：王凤枝_NT2541</span>
                        </div>
                </div>
</div>

可以看到，标题提取是正确的。正文其实也是正确的，不过这里还包含了一些 HTML 标签，比如 <img>、<p> 等，我们可以进一步通过一些解析库来解析。 看下源码吧，比如提取标题的方法：

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

def normalize_entities(cur_title):
    entities = {
        u'u2014':'-',
        u'u2013':'-',
        u'—': '-',
        u'–': '-',
        u'u00A0': ' ',
        u'u00AB': '"',
        u'u00BB': '"',
        u'"': '"',
    }
    for c, r in entities.items():
        if c in cur_title:
            cur_title = cur_title.replace(c, r)

    return cur_title

def norm_title(title):
    return normalize_entities(normalize_spaces(title))

def get_title(doc):
    title = doc.find('.//title')
    if title is None or title.text is None or len(title.text) == 0:
        return '[no-title]'

    return norm_title(title.text)

 def title(self):
    """Returns document title"""
    return get_title(self._html(True))

title 方法实际上就是调用了一个 get_title 方法，它怎么做的？实际上就是用了一个 XPath 只解析了 <title> 标签里面的内容，别的没了。如果没有，那就返回 [no-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

def summary(self, html_partial=False):
    ruthless = True
    while True:
        self._html(True)
        for i in self.tags(self.html, 'script', 'style'):
            i.drop_tree()
        for i in self.tags(self.html, 'body'):
            i.set('id', 'readabilityBody')
        if ruthless:
            self.remove_unlikely_candidates()
        self.transform_misused_divs_into_paragraphs()
        candidates = self.score_paragraphs()

        best_candidate = self.select_best_candidate(candidates)

        if best_candidate:
            article = self.get_article(candidates, best_candidate,
                                       html_partial=html_partial)
        else:
            if ruthless:
                ruthless = False
                continue
            else:
                article = self.html.find('body')
                if article is None:
                    article = self.html
        cleaned_article = self.sanitize(article, candidates)
        article_length = len(cleaned_article or '')
        retry_length = self.retry_length
        of_acceptable_length = article_length >= retry_length
        if ruthless and not of_acceptable_length:
            ruthless = False
            continue
        else:
            return cleaned_article

这里我删除了一些冗余的调试的代码，只保留了核心的代码，其核心实现就是先去除一些干扰内容，然后找出一些疑似正文的 candidates，然后再去寻找最佳匹配的 candidates 最后提取其内容返回即可。 然后再找到获取 candidates 方法里面的 score_paragraphs 方法，又追踪到一个 score_node 方法，就是为每一个节点打分的，其实现如下：

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

def score_node(self, elem):
   content_score = self.class_weight(elem)
   name = elem.tag.lower()
   if name in ["div", "article"]:
       content_score += 5
   elif name in ["pre", "td", "blockquote"]:
       content_score += 3
   elif name in ["address", "ol", "ul", "dl", "dd", "dt", "li", "form", "aside"]:
       content_score -= 3
   elif name in ["h1", "h2", "h3", "h4", "h5", "h6", "th", "header", "footer", "nav"]:
       content_score -= 5
   return {
       'content_score': content_score,
       'elem': elem
   }

这什么意思呢？你看如果这个节点标签是 div 或者 article 等可能表征正文区块的话，就加 5 分，如果是 aside 等表示侧栏的内容就减 3 分。这些打分也没有什么非常标准的依据，可能是根据经验累积的规则。 另外还有一些方法里面引用了一些正则匹配来进行打分或者替换，其定义如下：

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

 REGEXES = {
    'unlikelyCandidatesRe': re.compile('combx|comment|community|disqus|extra|foot|header|menu|remark|rss|shoutbox|sidebar|sponsor|ad-break|agegate|pagination|pager|popup|tweet|twitter', re.I),
    'okMaybeItsACandidateRe': re.compile('and|article|body|column|main|shadow', re.I),
    'positiveRe': re.compile('article|body|content|entry|hentry|main|page|pagination|post|text|blog|story', re.I),
    'negativeRe': re.compile('combx|comment|com-|contact|foot|footer|footnote|masthead|media|meta|outbrain|promo|related|scroll|shoutbox|sidebar|sponsor|shopping|tags|tool|widget', re.I),
    'divToPElementsRe': re.compile('<(a|blockquote|dl|div|img|ol|p|pre|table|ul)', re.I),
    #'replaceBrsRe': re.compile('(<br[^>]*>[ nrt]*){2,}',re.I),
    #'replaceFontsRe': re.compile('<(/?)font[^>]*>',re.I),
    #'trimRe': re.compile('^s+|s+$/'),
    #'normalizeRe': re.compile('s{2,}/'),
    #'killBreaksRe': re.compile('(<brs*/?>(s|&nbsp;?)*){1,}/'),
    'videoRe': re.compile('https?://(www.)?(youtube|vimeo).com', re.I),
    #skipFootnoteLink:      /^s*([?[a-z0-9]{1,2}]?|^|edit|citation needed)s*$/i,
}

比如这里定义了 unlikelyCandidatesRe，就是不像 candidates 的 pattern，比如 foot、comment 等等，碰到这样的标签或 pattern 的话，在计算分数的时候都会减分，另外还有其他的 positiveRe、negativeRe 也是一样的原理，分别对匹配到的内容进行加分或者减分。 这就是 Readability 的原理，是基于一些规则匹配的打分模型，很多规则其实来源于经验的累积，分数的计算规则应该也是不断地调优得出来的。 另外其他的就没了，Readability 并没有提供提取时间、作者的方法，另外此种方法的准确率也是有限的，但多少还是省去了一些人工成本。

Newspaper

另外还有一个智能解析的库，叫做 Newspaper，提供的功能更强一些，但是准确率上个人感觉和 Readability 差不太多。 这个库分为 Python2 和 Python3 两个版本，Python2 下的版本叫做 newspaper，Python3 下的版本叫做 newspaper3k，这里我们使用 Python3 版本来进行测试。 其 GitHub 地址是：https://github.com/codelucas/newspaper，官方文档地址是：[https://newspaper.readthedocs.io](https://newspaper.readthedocs.io/>)。 在安装之前需要安装一些依赖库，可以参考官方的说明：https://github.com/codelucas/newspaper#get-it-now。 安装好必要的依赖库之后，就可以使用 pip 安装了：

1

pip3 install newspaper3k

安装成功之后便可以导入使用了。 下面我们先用官方提供的实例来过一遍它的用法，官方提供的示例是使用了这个链接：https://fox13now.com/2013/12/30/new-year-new-laws-obamacare-pot-guns-and-drones/，其页面截图如下： 下面用一个实例来感受一下：

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

from newspaper import Article

url = 'https://fox13now.com/2013/12/30/new-year-new-laws-obamacare-pot-guns-and-drones/'
article = Article(url)
article.download()
# print('html:', article.html)

article.parse()
print('authors:', article.authors)
print('date:', article.publish_date)
print('text:', article.text)
print('top image:', article.top_image)
print('movies:', article.movies)

article.nlp()
print('keywords:', article.keywords)
print('summary:', article.summary)

这里从 newspaper 库里面先导入了 Article 这个类，然后直接传入 url 即可，首先需要调用它的 download 方法，将网页爬取下来，否则直接进行解析会抛出错误的。

但我总感觉这个设计挺不友好的，parse 方法不能判断下，如果没执行 download 就自动执行 download 方法吗？如果不 download 其他的不什么都干不了吗？

好的，然后我们再执行 parse 方法进行网页的智能解析，这个功能就比较全了，能解析 authors、publish_date、text 等等，除了正文还能解析作者、发布时间等等。 另外这个库还提供了一些 NLP 的方法，比如获取关键词、获取文本摘要等等，在使用前需要先执行以下 nlp 方法。 最后运行结果如下：

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

authors: ['Cnn Wire']
date: 2013-12-30 00:00:00
text: By Leigh Ann Caldwell

WASHINGTON (CNN) — Not everyone subscribes to a New Year’s resolution, but Americans will be required to follow new laws in 2014.

Some 40,000 measures taking effect range from sweeping, national mandates under Obamacare to marijuana legalization in Colorado, drone prohibition in Illinois and transgender protections in California.

Although many new laws are controversial, they made it through legislatures, public referendum or city councils and represent the shifting composition of American beliefs.
...
...
Colorado: Marijuana becomes legal in the state for buyers over 21 at a licensed retail dispensary.

(Sourcing: much of this list was obtained from the National Conference of State Legislatures).
top image: https://localtvkstu.files.wordpress.com/2012/04/national-news-e1486938949489.jpg?quality=85&strip=all
movies: []
keywords: ['drones', 'national', 'guns', 'wage', 'law', 'pot', 'leave', 'family', 'states', 'state', 'latest', 'obamacare', 'minimum', 'laws']
summary: Oregon: Family leave in Oregon has been expanded to allow eligible employees two weeks of paid leave to handle the death of a family member.
Arkansas: The state becomes the latest state requiring voters show a picture ID at the voting booth.
Minimum wage and former felon employmentWorkers in 13 states and four cities will see increases to the minimum wage.
New Jersey residents voted to raise the state’s minimum wage by $1 to $8.25 per hour.
California is also raising its minimum wage to $9 per hour, but workers must wait until July to see the addition.

这里省略了一些输出结果。 可以看到作者、日期、正文、关键词、标签、缩略图等信息都被打印出来了，还算是不错的。 但这个毕竟是官方的实例，肯定是好的，我们再测试一下刚才的例子，看看效果如何，网址还是：https://tech.163.com/19/0909/08/EOKA3CFB00097U7S.html，改写代码如下：

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

from newspaper import Article

url = 'https://tech.163.com/19/0909/08/EOKA3CFB00097U7S.html'
article = Article(url, language='zh')
article.download()
# print('html:', article.html)

article.parse()
print('authors:', article.authors)
print('title:', article.title)
print('date:', article.publish_date)
print('text:', article.text)
print('top image:', article.top_image)
print('movies:', article.movies)

article.nlp()
print('keywords:', article.keywords)
print('summary:', article.summary)

这里我们将链接换成了新闻的链接，另外在 Article 初始化的时候还加了一个参数 language，其值为 zh，代表中文。 然后我们看下运行结果：

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

Building prefix dict from /usr/local/lib/python3.7/site-packages/jieba/dict.txt ...
Dumping model to file cache /var/folders/1g/l2xlw12x6rncs2p9kh5swpmw0000gn/T/jieba.cache
Loading model cost 1.7178938388824463 seconds.
Prefix dict has been built succesfully.
authors: []
title: 今年iPhone只有小改进？分析师：还有其他亮点
date: 2019-09-09 08:10:26+08:00
text: （原标题：Apple Bets More Cameras Can Keep iPhone Humming）

图示：苹果首席执行官蒂姆·库克(Tim Cook)在6月份举行的苹果全球开发者大会上。

网易科技讯 9月9日消息，据国外媒体报道，和过去的12个年头一样，新款iPhone将成为苹果公司本周所举行年度宣传活动的主角。但人们的注意力正转向需要推动增长的其他苹果产品和服务。
...
...
Strategy Analytics的尼尔·莫斯顿(Neil Mawston)表示，可穿戴设备和服务的结合将是苹果业务超越iPhone的关键。他说，上一家手机巨头诺基亚公司在试图进行类似业务转型时就陷入了困境之中。（辰辰）

相关报道：

iPhone 11背部苹果Logo改为居中：为反向无线充电

2019年新iPhone传言汇总，你觉得哪些能成真
top image: https://www.163.com/favicon.ico
movies: []
keywords: ['trust高级投资组合经理丹摩根dan', 'iphone', 'mawston表示可穿戴设备和服务的结合将是苹果业务超越iphone的关键他说上一家手机巨头诺基亚公司在试图进行类似业务转型时就陷入了困境之中辰辰相关报道iphone', 'xs的销售疲软状况迫使苹果在1月份下调了业绩预期这是逾15年来的第一次据贸易公司susquehanna', 'xs机型发布后那种令人失望的业绩重演iphone', '今年iphone只有小改进分析师还有其他亮点', 'more', 'xr和iphone', 'morgan说他们现在没有任何真正深入的进展只是想继续让iphone这款业务继续转下去他乐观地认为今年发布的新款手机将有足够多的新功能为一个非常成熟的产品增加额外的功能让火车继续前进这种仅限于此的态度说明了苹果自2007年发布首款iphone以来所面临的挑战iphone销售占苹果公司总营收的一半以上这让苹果陷入了一个尴尬的境地既要维持核心产品的销量另一方面又需要减少对它的依赖瑞银ubs今年5月份对8000名智能手机用户进行了相关调查其发布的年度全球调查报告显示最近iphone在人脸识别技术等方面的进步并没有引起一些消费者的共鸣他们基本上都认为苹果产品没有过去几年那么独特或者惊艳品牌也没有过去几年那么有吸引力很多人使用老款手机的时间更长自己认为也没有必要升级到平均售价949美元的新款iphone苹果需要在明年销售足够多的iphone以避免像去年9月份iphone', 'keep', '原标题apple']
summary: （原标题：Apple Bets More Cameras Can Keep iPhone Humming）图示：苹果首席执行官蒂姆·库克(Tim Cook)在6月份举行的苹果全球开发者大会上。网易科技讯 9月9日消息，据国外媒体报道，和过去的12个年头一样，新款iPhone将成为苹果公司本周所举行...亚公司在试图进行类似业务转型时就陷入了困境之中。（辰辰）相关报道：iPhone 11背部苹果Logo改为居中：为反向无线充电2019年新iPhone传言汇总，你觉得哪些能成真

中间正文很长省略了一部分，可以看到运行时首先加载了一些中文的库包，比如 jieba 所依赖的词表等等。 解析结果中，日期的确是解析对了，因为这个日期格式的的确比较规整，但这里还自动给我们加了东八区的时区，贴心了。作者没有提取出来，可能是没匹配到 来源 两个字吧，或者词库里面没有，标题、正文的提取还算比较正确，也或许这个案例的确是比较简单。 另外对于 NLP 部分，获取的关键词比较迷，长度有点太长了。summary 也有点冗余。 另外 Newspaper 还提供了一个较为强大的功能，就是 build 构建信息源。官方的介绍其功能就是构建一个新闻源，可以根据传入的 URL 来提取相关文章、分类、RSS 订阅信息等等。 我们用实例感受一下：

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

import newspaper

source = newspaper.build('http://www.sina.com.cn/', language='zh')
for category in source.category_urls():
    print(category)

for article in source.articles:
    print(article.url)
    print(article.title)

for feed_url in source.feed_urls():
    print(feed_url)

在这里我们传入了新浪的官网，调用了 build 方法，构建了一个 source，然后输出了相关的分类、文章、RSS 订阅等内容，运行结果如下：

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

http://cul.news.sina.com.cn
http://www.sina.com.cn/
http://sc.sina.com.cn
http://jiangsu.sina.com.cn
http://gif.sina.com.cn
....
http://tj.sina.com.cn
http://travel.sina.com.cn
http://jiaoyi.sina.com.cn
http://cul.sina.com.cn
https://finance.sina.com.cn/roll/2019-06-12/doc-ihvhiqay5022316.shtml
经参头版：激发微观主体活力加速国企改革
http://eladies.sina.com.cn/feel/xinli/2018-01-25/0722/doc-ifyqwiqk0463751.shtml
我们别再联系了
http://finance.sina.com.cn/roll/2018-05-13/doc-ihamfahx2958233.shtml
新违约时代到来！违约“常态化”下的市场出清与换血
http://sports.sina.com.cn/basketball/2019worldcup/2019-09-08/doc-iicezzrq4390554.shtml
罗健儿26分韩国收首胜
...
http://travel.sina.com.cn/outbound/pages/2019-09-05/detail-iicezzrq3622449.shtml
菲律宾海滨大道 夜晚让人迷离
http://travel.sina.com.cn/outbound/pages/2016-08-19/detail-ifxvcnrv0334779.shtml
关岛 用双脚尽情享受阳光与海滩
http://travel.sina.com.cn/domestic/pages/2019-09-04/detail-iicezzrq3325092.shtml
秋行查干浩特草原
http://travel.sina.com.cn/outbound/pages/2019-09-03/detail-iicezueu3050710.shtml
白羊座的土豪之城迪拜
http://travel.sina.com.cn/video/baidang/2019-08-29/detail-ihytcitn2747327.shtml
肯辛顿宫藏着维多利亚的秘密
http://cd.auto.sina.com.cn/bdcs/2017-08-15/detail-ifyixias1051586.shtml

可以看到它输出了非常多的类别链接，另外还有很多文章列表，由于没有 RSS 订阅内容，这里没有显示。 下面把站点换成我的博客：https://cuiqingcai.com，博客截图如下： 看看运行结果：

1
2

https://cuiqingcai.com
https://cuiqingcai.com

似乎不太行啊，一篇文章都没有，RSS 也没有，可见其功能还有待优化。 Newspaper 的基本用法介绍到这里，更加详细的用法可以参考官方文档：https://newspaper.readthedocs.io。个人感觉其中的智能解析可以用用，不过据我的个人经验，感觉还是很多解析不对或者解析不全的， 以上便是 Readability 和 Newspaper 的介绍。

其他方案

另外除了这两个库其实还有一些比较优秀的算法，由于我们处理的大多为中文文档，所以一些在中文上面的研究是比较有效的，在这里列几个值得借鉴的中文论文供大家参考：

• 洪鸿辉等，基于文本及符号密度的网页正文提取方法
• 梁东等，基于支持向量机的网页正文内容提取方法
• 王卫红等，基于可视块的多记录型复杂网页信息提取算法

今天还看到一位大佬「青南」根据上面第一篇论文所实现的 GeneralNewsExtractor，GitHub 地址为：https://github.com/kingname/GeneralNewsExtractor，经测试准确率还不错，比 Readability 和 Newspaper 的解析效果要好。我也跟作者进行了交流，后续可能还会基于其他的 Feature 或依赖于视觉化的方法进行优化，大家可以关注下，谢谢！

这两天想必大家应该被一个软件刷屏了，它的名字叫做 Zao，中文音译就叫“造”。它为什么这么火呢？是因为我们可以上传自己的一张照片，他就能把我们的脸替换成一些热门视频的男主或女主的脸，也就是视频换脸。 比如有人尝试了把尼古拉斯赵四的脸换到美国队长的脸上，美队的气质简直就是被垄断了，大家可以扫码看看： 视频换脸技术大家应该早有耳闻，但这个软件有点意思，它抓住了几个点使得它一炮而红。 第一是这个软件的效果确实不错，我拿自己也做了实验，发现确实它渲染的一些结果几乎毫无违和感，毕竟这个软件核心拼的就是技术。 第二这个软件贴近于日常生活，我们可以把自己的照片上传，让我们真正成为视频里的主角。另外视频选材很有讲究，都是一些剪辑过的明星精彩镜头，这样我们生成的视频镜头会让我们有变成明星的感觉，非常有代入感。

技术实现

作为一名程序员，当然最关心的可能就是它的技术实现了，毋庸置疑它肯定是利用了深度学习的一些技术。我看了一些文章和调研，大体了解了一下，下面稍微分析一下里面用到的一些技术。 整体而言呢，这个过程分为三步，他们分别是：

• 人脸定位
• 人脸转换
• 人脸融合

人脸定位

现在深度学习对于人脸识别和定位的研究技术已经非常成熟和精准了，其核心就是使用了卷积神经网络，即 CNN，不同的模型架构对于识别的准确率有不用的表现。 对于人脸的定位，一般是使用脸部的关键点定位的，这些点叫做 Landmarks。在一张人脸图像上，每张脸的轮廓和五官的位置都会被打上点，比如整个脸部的轮廓用一些点描出来，鼻子、眼睛、唇形同样用一些点描出来。 一般来说一张脸会用 68 个点来标记出来，每识别的模型接收一张人脸图像，输出这 68 个点的坐标，这样我们就可以实现人脸定位了。 现在现成的模型也很多了，比如 dlib，opencv 等开源工具包可以直接拿来使用了，如果要更精准地话可以使用更复杂的卷积神经网络模型来实现，大家可以了解下相关论文。

人脸生成

有了标记点以后，这个软件就可以把我们的人脸提取出来了，但是这有个问题，我们上传的是一张静态图片，总不能直接生硬地替换进去吧，比如我们上传的是一张正脸照片，那视频里的一些侧脸画面直接贴上那不就没法看了吗？ 这时候就要用到另外一个核心技术叫做人脸生成技术，有了它我们就可以对人脸进行生成了，比如根据一张正脸图生成一张侧脸图。目前人脸生成技术主要有两种，有 GAN（生成对抗网络）和 VAE（变分自编码器），下面简单介绍一下它们的原理。 对于 GAN 来说，它叫做生成对抗网络，为什么叫对抗网络呢？是因为模型在训练的过程中一直有两个东西在做对抗，这俩东西分别叫 Generator（生成器）和 Discriminator（判别器）。前者主要负责生成一张人脸，越像越牛逼。后者主要负责判断分辨前者生成的人脸是不是真的，判定越准越牛逼。二者在这个过程中为了变得越来越牛逼，前者就会尽力去生成更像的人脸来欺骗后者，后者也会尽力去判别生成的人脸是不是真的来打击前者。这样二者在不断地训练和对抗过程中，前者生成的结果就会越来越好了。 对于 VAE 呢，它是通过一些无监督学习的方式将人脸信息进行压缩，由编码器把它表示成一个短向量，这些向量里就包含了人脸的基本信息，比如肤色、唇形等信息，这样整个模型就可以学习到人脸的共性。然后，解码器将向量解码，将其转换为某一特定的人脸。这样就等于经过一层中间向量完成了从一张人脸到另一张人脸的转换。

图像融合

最后的阶段就是图像融合了，也就是把生成的新的人脸和原来图像的背景融合，使之不会产生违和感。 在这个软件中，视频是由一帧一帧组成的，那么在转换的时候也需要一帧一帧处理，最后处理完成后再合成整个视频。 以上也就是我所了解到的变脸的一些方法。

安全性

有人说，这个技术不是什么好技术。万一有人拿着我们的照片一变脸，就能够把我们任意的表情和头部动作模拟出来，拿着去做认证，比如刷脸支付什么的咋办，那我们的钱不就被盗刷了吗？ 对于这个问题，支付宝官方也做了回应，支付宝称刷脸支付实际上会通过软硬件结合的方式进行检测，其会判断被刷物体是否是照片、视频或者软件模拟的方式生成的，可以有效避免身份冒用情况。其中有一个核心技术就是通过 3D 结构光摄像头来进行信息采集和识别，如果被拍摄物体是平面的，也就是说如果是照片或者视频，是无法通过检测的。 这时候我自然而然想到，既然用的是 3D 结构光摄像头，那么如果用了 3D 打印技术把一个人的肖像打印出来，或者用一个非常逼真的蜡像来进行刷脸识别，能不能通过呢？我看了一些报道，发现不少案例的确通过了刷脸测试，比如解开了 iPhone 面部识别锁等等。但要通过 3D 打印技术来模拟一个人的肖像成本还是蛮高的，所以基本上也不太会有人来搞这些。 如果对此还心有余悸的话，支付宝还回应称，即便是真的被盗刷了，支付宝也会通过保险公司进行全额赔付。 所以基本上是不用担心其安全性的，尤其是 Zao 这个软件的出现是没有对刷脸支付的风险造成大的影响的，其就是增加了一个活体视频模拟的实现，对刷脸支付的安全性没有出现大的突破性威胁。

隐私性

这个就要好好说一下了，这个软件的出现同时引起了另一个轩然大波，那就是其中的隐私条款。 其隐私条款有一条是这样的：

用户上传发布内容后，意味着同意授予 ZAO 及其关联公司以及 ZAO 用户在“全球范围内完全免费、不可撤销、永久、可转授权和可再许可的权利”，“包括但不限于可以对用户内容进行全部或部分的修改与编辑（如将短视频中的人脸或者声音换成另一个人的人脸或者声音等）以及对修改前后的用户内容进行信息网络传播以及《著作权法》规定的由著作权人享有的全部著作财产权利及邻接权利”。

这条款没人说还真没注意到，因为一般咱用一个软件，一般不会去仔细看它的条款，那么密密麻麻的一坨，有几个人会去仔细看呢？但要不同意，这个软件还没法用，所以用过这个软件的人，这个条款一定是已经同意了。 这条条款其实是很过分的，同意授予 Zao 及其关联公司以及 Zao 用户在“全球范围内完全免费、不可撤销、永久、可转授权和可再许可的权利。注意这里有几个字，完全免费、不可撤销、永久、可转授权、可再许可，这几个词就代表我们已经把我们的肖像权永久授予了 Zao 及其关联公司了，而且不能撤销，账号注销了也不能撤销，也就是以后它们可以有权利永久滥用我们的肖像。更可怕的是，其中还有一个词叫可转授权，那也就是说，Zao 可以对我们的肖像权进行转授权，你懂得，给点钱，啥办不到呢？这就更无法控制了，这可能就意味着，世界上任何一个人可能都能获得我们的肖像权。 所以说，如果你还没用的话，一定要谨慎谨慎再谨慎！ 哎，反正我已经同意了，貌似我现在也没什么办法了。

社会影响

这个软件的出现，更深一点想，其实它所隐含的影响还是蛮大的。 有了这个变脸技术，如果有人获得了我们在条款里面所”捐出“的肖像权，拿着我们的照片去生产那种你懂得的影片，把视频里面的男主或者女主换成我们的人脸，然后到处传播，或者以此作为敲诈勒索的工具。即便我们有理，那也说不清了，首先这个条款已经说了它们可以有权利随意使用我们的肖像，所以告侵犯肖像权已经行不通了，而且即使我们有证据证明这是假的，但这种视频的传播也一定会带来非常大的影响。 按照现在大众们的观念，比如说一张图，我们如果不信的话可以说它是 P 的，但如果换做是视频的话，很多人可能就会相信了，因为很多人不知道视频中的肖像也可以伪造得这么真了，毕竟很多人并不知道这种技术。因此，有了这种技术的出现，以后视频类的证据，可能也不可信了。因此这个软件的出现，可以说从另一个侧面昭示，以后视频也不能作为犯案的证据和验证人的真伪的依据了。 所以以后可能是这样子的：

• 坐在电脑面前的网络女主播，即便不开美颜和滤镜，你所看到的她也不是真的她了。
• 你要给人打个钱，说开个视频吧，我看看是不是真的你，即便看到的是他，你也不能信了。
• 有人要 Qiao Zha 你，把你的人脸换成 Zuo An 分子的脸，你到哪里说理去？
• 某一天，你作为男女主角，出现在了 P 站和 91….

我一开始想的还没这么深，边想边写，写到这，我自己都开始后怕了… 怎么甚至感觉，以后的社会可能会乱套了呢？这可能就是 AI 发展的一个隐患吧。 所以写到最后，虽然这个软件很有意思，但还是劝大家还没有用的就不要用了吧，真的很可怕。同时我也不知道这个软件这样的条款和做法会不会有什么问题，但还是希望能引起有关部门的注意。 以后，也希望大家也可以在使用软件的时候，要更加谨慎和小心，有条款就稍微看一看，尤其是对于这种和用户隐私相关的软件，要更加心存戒备。

参考文章

本文参考来源：

• 机器之心：刷屏的 ZAO 换脸 APP 你玩了吗？
• 支付宝推出的刷脸支付是基于“活体检测”技术做支撑

开发者如何学好 MongoDB

作为一名研发，数据库是或多或少都会接触到的技术。MongoDB 是热门的 NoSQL 之一，我们怎样才能学好 MongoDB 呢？ 本篇文章，我们将从以下几方面讨论这个话题：

1. MongoDB 是什么
2. 我如何确定我需要学习 MongoDB
3. 开发者应该掌握 MongoDB 的哪些知识
4. 学习的选择和困境

我们先来了解一下，MongoDB 为何物。 NoSQL 泛指非关系型数据库，该词是关系型数据库（即 SQL）的相对称呼。MongoDB 是非关系型数据库（NoSQL）中较为人熟知的一种。它拥有很多优秀特性，例如高性能、高可用、支持丰富的查询语句、无需预定义数据模型和水平可伸缩等，适合存储结构化、半结构化的文档和特定格式的文档，这些特性使它受到众多开发者的青睐。 我们通过几个例子来看看 MySQL 与 MongoDB 的差异。 与 MySQL 数据库不同的是，MongoDB 不需要预先定义表和字段，这正是它灵活性的体现。MongoDB 可以拥有多个数据库，每个数据库可以拥有多个集合，每个集合可以存储多份文档，这种关系与 SQL 数据库中的“数据库、表、数据”相当。下图描述了 MongoDB 中数据库、集合和文档的关系： 数据库 fotoo 中有两个集合，它们分别是 player 和 books。每个集合中都包含了许多文档，例如集合 books 中关于书籍《红楼梦》的文档，集合 player 中关于球员 James 的文档。 在查询方面，一个简单的 MySQL 查询语句为 SELECT * FROM tablename，对应的 MongoDB 查询语句为 db.tablename.find()。在面对多步骤的查询条件时，MongoDB 更游刃有余。例如： “统计数据库 artic 中 score 大于 70 且小于 90 的文档数量” 这样的需求，用 MongoDB 的聚合操作就可以轻松完成，对应示例如下：

1
2
3
4

\> db.artic.aggregate([
... {$match: {score: {$gt: 70, $lt: 90}}},
... {$group: {_id: null, number: {$sum: 1}}}
... ])

这个例子或许简单了些，在 MySQL 中我们可以用 count 和 where 完成，但如果复杂度再提高四五个等级呢？例如在此基础上增加对某个字段的运算、替换、排序、分组计数、增删字段，用 MySQL 来实现就会很头疼，而 MongoDB 的聚合可以让我们轻松地完成这类复杂需求。

我如何确定我需要学习 MongoDB

MongoDB 是近些年涌现的几十种 NoSQL 中第一梯队的成员，另外一个为人熟知的是 Redis。你可能会有”我如何确定我需要学习 MongoDB 呢？“ 这样的疑问，面对这个问题，我们可以通过 MongoDB 的特点和应用场景着手。

• MongoDB 适合存储结构确定或不确定的文档。例如爬虫爬取的信息常缺失字段的情况或字段参差不齐的情况；
• 对数据库可用性要求较高的情况。MySQL 这类数据库要做到负载均衡、自动容灾和数据同步需要借助外部工具，而 MongoDB 的复制集可以让我们轻松完成这一系列的工作。相对接借助第三方工具来说，复制集的稳定性更高。
• 分库分表是 WEB 开发中常用到的数据库优化手段，MySQL 的分库分表要考虑的问题非常多，例如字段冗余、数据组装跨节点分页、排序和数据迁移等，而 MongoDB 的分片可以让我们轻松完成“分库分表”的工作。MongoDB 的分片机制使我们不必将心思放在由“分库分表”带来的问题，而是专注于具体需求。
• 同样的，MySQL 的权限控制、定义数据模型、数据库备份和恢复等功能在 MongoDB 上也有。
• MongoDB 中支持地理位置的存储和查询，这意味着 MongoDB 可以用于共享单车、共享雨伞、汽车定位等业务中。

我们常用的关系型数据库无法满足 WEB2.0 时代的需求，在实际应用中暴露了很多难以克服的问题。NoSQL 的产生就是为了解决例如海量数据的存储、弹性可伸缩和灵活性等方面的挑战，所以作为一名合格的开发者，应该抽空学习 SQL 以外的数据库知识。

开发者应该掌握 MongoDB 的哪些知识

学习前，我们需要明白自身定位：专业 DBA 或者日常开发使用。MongoDB 有完善的培训体系和对应的认证考试，对于希望成为专业 DBA 的朋友我建议到 MongoDB 官方网站了解。而对于仅需要满足日常开发需求的朋友，我建议学习的内容如下：

• MongoDB 在各个平台的安装方法
• MongoDB 数据库和集合的基本操作
• MongoDB 文档 CRUD 操作，包括能够丰富 CRUD 的投影和修饰符等
• MongoDB 流式聚合操作，这能够在数据库层面轻松完成复杂数据的处理，而不是用编程语言来处理
• MongoDB 的数据模型，虽然它可以存储不规则的文档，但有些情况下定义数据模型可以提高查询效率

当然，除了这些基本操作之外我们还可以学习更多的知识提高个人竞争力，这些知识是：

• MongoDB 执行计划和索引，执行计划可以让我们清楚的了解到查询语句的效率，而索引则是优化查询效率的常用手段
• MongoDB 的复制集，这是提高 MongoDB 可用性，保证数据服务不停机的最佳手段
• MongoDB 的分片，分片能够在数据量变得庞大之后保证效率
• MongoDB 的事物，如果你将 MongoDB 用于 WEB 网站，那么事物是你必须学习的知识
• MongoDB 数据库备份和还原，有了复制集后，备份就显得不是那么重要了，但并不是没有这个需求。而且 MongoDB 的备份可以精细到文档，这就非常有意义了。

学习的选择和困境

有一定工作经验的开发者，大多数情况下都会选择自学。有些在网上搜索对应的文章，有些则直接翻阅官方文档。我推荐的方式是翻阅官方文档，在遇到难以理解的观点时通过搜索引擎查找网友分享的文章。 自学的优点很多，缺点也很明显。例如：

• 断断续续的学习，难以保持专注导致知识吸收不好
• 耗费时间很长，虽然知道应该学习哪些方面的知识，但文档并不是按你所想而规划的，所以翻阅文档要费很多功夫
• 知识不成体系，东看看西看看，没有归纳容易忘记
• 学习就需要记笔记，这又是一件很费时间的事情
• 官方文档有些观点难以理解，卡在半路很难受
• 零星学了一两个月，也不确定学会了没有，内心毫无把握

如果不自学，就得找一些成体系的课程来帮助自己快速进步，少走弯路。知识付费时代，在条件允许的情况下适当地投入也是很好的选择。但面对动辄几百块的视频课程，不少开发者还是感觉略有压力，毕竟我们搬砖的经济压力也非常大。培训班就更不用说了，很少有专业教授单个数据库知识的，而且费用比视频课程更贵。 考虑到这些问题，这里推荐韦世东的 GitChat 文章 《超高性价比的 MongoDB 零基础快速入门实战教程》，这也是一个收费教程，但它售价不到 10 块钱。文章作者韦世东是：图灵签约作者、电子工业出版社约稿作者，华为云认证云享专家、掘金社区优秀作者、GitChat 认证作者，开源项目 aiowebsocket 作者。所以在文章质量上，大家可以放心。 这篇文章的内容几乎囊括了上面我们提到的所有知识点，看完这篇仅 5 万词的文章，你将收获：

• 文档的 CRUD 操作和 Cursor 对象
• 掌握流式聚合操作，轻松面对任何数据处理需求
• 了解 MongoDB 的查询效率和优化
• 如何提高 MongoDB 的可用性
• 如何应对数据服务故障
• 理解 MongoDB 的访问控制
• 学会用数据模型降低数据冗余，提高效率
• 掌握 mongodump 数据备份与还原方法

这样就可以胜任日常开发中对数据库操作能力的要求了。这篇文章适合对 MongoDB 感兴趣的零基础开发者或者有一定基础，想要继续巩固和加深学习的开发者。文章篇幅很长，内容详尽，不乏优质配图，例如描述复制集节点关系的图： 描述节主点掉线，重新选举主节点的图 如果你觉得有学习 MongoDB 的需要，且这篇文章规划的内容是你想要的内容，那么请长按下方图片识别二维码，前往订阅文章吧！

在做程序开发的时候，我们经常会用到一些测试数据，相信大多数同学是这么来造测试数据的：

1
2
3
4
5
6
7
8

test1
test01
test02
测试1
测试2
测试数据1
这是一段测试文本
这是一段很长很长很长的测试文本...

中枪的请举手。 不仅要自己手动敲这些测试数据，还敲的这么假。那有啥办法呢？难不成有什么东西能自动给我造点以假乱真的数据啊？你别说，还真有！ 在 Python 中有个神库，叫做 Faker，它可以自动帮我们来生成各种各样的看起来很真的”假“数据，让我们来看看吧！

安装

首先让我们来看看这个库的安装方法，实际上装起来非常简单，使用 pip 安装即可，Python3 版本的安装命令如下：

1

pip3 install faker

安装好了之后，我们使用最简单的例子来生成几个假数据试试：

1
2
3
4
5
6

from faker import Faker

faker = Faker()
print('name:', faker.name())
print('address:', faker.address())
print('text:', faker.text())

首先我们从 faker 这个包里面导入一个 Faker 类，然后将其实例化为 faker 对象，依次调用它的 name、address、text 方法，看下运行效果：

1
2
3
4
5
6

name: Nicholas Wilson
address: 70561 Simmons Road Apt. 893
Lake Raymondville, HI 35240
text: Both begin bring federal space.
Official start idea specific. Able under young fire.
Who show line traditional easy people. Until economic lead event case. Technology college his director style.

看到这里给我们生成了看起来很真的英文姓名、地址、长文本。 但我们是中国人，我们肯定想要生成中文的吧，不用担心，这个库对非常多的语言都有支持，当然也包括中文了，具体的支持的语言列表可以见：https://faker.readthedocs.io/en/master/locales.html。 这里几个比较常见的语言代号列一下：

• 简体中文：zh_CN
• 繁体中文：zh_TW
• 美国英文：en_US
• 英国英文：en_GB
• 德文：de_DE
• 日文：ja_JP
• 韩文：ko_KR
• 法文：fr_FR

那么如果要生成中文，只需要在 Faker 类的第一个参数传入对应的语言代号即可，例如简体中文就传入 zh_CN，所以上面的代码改写如下：

1
2
3
4
5
6

from faker import Faker

faker = Faker('zh_CN')
print('name:', faker.name())
print('address:', faker.address())
print('text:', faker.text())

运行结果如下：

1
2
3
4
5
6
7

name: 何琳
address: 宁夏回族自治区六盘水县南溪北镇街f座 912311
text: 经营软件积分开始次数专业.美国留言一种管理人民解决两个.支持只有地方一切.
文化目前东西的是不过所以.系统觉得这种为什一下他们.时候以及这样继续是一状态威望.
网站密码情况.问题一点那个还是.其实过程详细.
中国历史环境电话规定.经验上海控制不要生活.朋友运行项目我们.
以后今天那些使用免费国家加入但是.内容简介空间次数最大一个.日期通过得到日本北京.

可以看到一段中文的姓名、地址、长文本便生成了。看起来地址是省份、地级市、县级市、街道是随机组合的，文本也是一些随机的词组合而成的，但其实这样已经比文章一开头列的测试数据强太多了。 上面的代码每次运行得到的结果都是不同的，因为生成的结果都是随机组合而成的。

Provider

接下来让我们详细看下 faker 可以都生成什么类型的数据，具体的可用 API 可以看 https://faker.readthedocs.io/en/master/locales/zh_CN.html，这里面列出来了可用的所有方法。 但打开之后可以发现，这里面多了一个 Provider 对象，那么这个 Provider 是怎么一回事呢？ 实际上这个 faker 库在设计上，为了解耦，将 Provider 对象做成了 Faker 对象的”插件“。Faker 可以添加一个个 Provider 对象，Provider 对象为 Faker 对象提供了生成某项数据的核心实现。就相当于 Faker 对象是一个生成器，它的生成功能依赖于什么呢？依赖于 Provider，是 Provider 提供给了 Faker 对象生成某项数据的能力。 正是因为 Faker 对象内置了一些 Provider 对象，Faker 对象才可以生成刚才所要求的姓名、地址和文本。 那么这时候我们肯定就很好奇了，既然 Faker 对象有生成数据的能力，那么它一定内置了一些默认的 Provider 对象，下面我们来打印看一下：

1
2
3
4

from faker import Faker

faker = Faker('zh_CN')
print(faker.providers)

运行结果如下：

1

[<faker.providers.user_agent.Provider object at 0x10249de48>, <faker.providers.ssn.zh_CN.Provider object at 0x10249dc18>, <faker.providers.python.Provider object at 0x10249dd68>, <faker.providers.profile.Provider object at 0x10249dcc0>, <faker.providers.phone_number.zh_CN.Provider object at 0x10249dc88>, <faker.providers.person.zh_CN.Provider object at 0x10249de80>, <faker.providers.misc.Provider object at 0x10249df60>, <faker.providers.lorem.zh_CN.Provider object at 0x10249dc50>, <faker.providers.job.zh_CN.Provider object at 0x10249de10>, <faker.providers.isbn.Provider object at 0x10249c6d8>, <faker.providers.internet.zh_CN.Provider object at 0x10249c828>, <faker.providers.geo.en_US.Provider object at 0x102484748>, <faker.providers.file.Provider object at 0x102484828>, <faker.providers.date_time.en_US.Provider object at 0x1023789e8>, <faker.providers.currency.Provider object at 0x102484780>, <faker.providers.credit_card.Provider object at 0x1024845f8>, <faker.providers.company.zh_CN.Provider object at 0x102499ef0>, <faker.providers.color.en_US.Provider object at 0x1023532e8>, <faker.providers.barcode.Provider object at 0x101cb6d30>, <faker.providers.bank.en_GB.Provider object at 0x102378f98>, <faker.providers.automotive.en_US.Provider object at 0x1017a5c50>, <faker.providers.address.zh_CN.Provider object at 0x101787c18>]

还真不少，通过名字可以看到有 user_agent、phone_number、isbn、credit_card 等 Provider，其中具有语言差异化的 Provider 还单独区分了语言，比如 phone_number 代表电话号码，这个不同语言的不同，所以这里就又分了一层 zh_CN，作了语言的区分。 这样一来，通用的 Provider 就直接处在某个 Provider 类别的模块中，具有语言差异的 Provider 就又根据不同的语言进一步划分了模块，设计上非常科学，易扩展又不冗余。 知道了 Faker 具有这么多 Provider 之后，我们来看看刚才调用的 name、address 等方法又和 Provider 有什么关系呢？ 我们将 name、address、text 等方法打印一下看看：

1
2
3
4
5
6

from faker import Faker

faker = Faker('zh_CN')
print('name:', faker.name)
print('address:', faker.address)
print('text:', faker.text)

注意这里没有调用，而是直接打印了这三个方法，这样可以直接输出方法的对象形式的描述，结果如下：

1
2
3

name: <bound method Provider.name of <faker.providers.person.zh_CN.Provider object at 0x10f6dea58>>
address: <bound method Provider.address of <faker.providers.address.zh_CN.Provider object at 0x10e9e6cf8>>
text: <bound method Provider.text of <faker.providers.lorem.zh_CN.Provider object at 0x10f6dfda0>>

恍然大悟，原来我们调用的方法就是 Faker 对象调用的 Provider 里面的对应方法，比如 name 就是 faker.providers.person.zhCN.Provider 里面的 name 方法，二者是一致的，我们扒一扒源码验证下，源码在：[[https://github.com/joke2k/faker/blob/master/faker/providers/person/__init](https://github.com/joke2k/faker/blob/master/faker/providers/person/__init_)_.py]([https://github.com/joke2k/faker/blob/master/faker/providers/person/__init__.py)，果不其然，里面定义了](https://github.com/joke2k/faker/blob/master/faker/providers/person/__init__.py)，果不其然，里面定义了) name 方法，然后 Faker 动态地将这个方法引入进来了，就可以使用了。

方法列举

既然有这么多 Provider，下面我们再详细地看看还有哪些常用的方法吧，下面进行一部分简单的梳理，参考来源文档地址为：https://faker.readthedocs.io/en/master/providers.html。

Address

Address，用于生成一些和地址相关的数据，如地址、城市、邮政编码、街道等内容， 用法如下：

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

faker.address()
# '新疆维吾尔自治区杰县南湖武汉街D座 253105'
faker.building_number()
# 'B座'
faker.city()
# '璐县'
faker.city_name()
# '贵阳'
faker.city_suffix()
# '县'
faker.country()
# '阿拉斯加'
faker.country_code(representation="alpha-2")
# 'CR'
faker.district()
# '西峰'
faker.postcode()
# '726749'
faker.province()
# '福建省'
faker.street_address()
# '余路N座'
faker.street_name()
# '李路'
faker.street_suffix()
# '路'

Color

Color，用于生成和颜色相关的数据，如 HEX、RGB、RGBA 等格式的颜色，用法如下：

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

faker.color_name()
# 'DarkKhaki'
faker.hex_color()
# '#97d14e'
faker.rgb_color()
# '107,179,51'
faker.rgb_css_color()
# 'rgb(20,46,70)'
faker.safe_color_name()
# 'navy'
faker.safe_hex_color()
# '#dd2200'

Company

Company，用于生成公司相关数据，如公司名、公司前缀、公司后缀等内容，用法如下：

1
2
3
4
5
6
7
8
9
10

faker.bs()
# 'grow rich initiatives'
faker.catch_phrase()
# 'Self-enabling encompassing function'
faker.company()
# '恒聪百汇网络有限公司'
faker.company_prefix()
# '晖来计算机'
faker.company_suffix()
# '信息有限公司'

Credit Card

Credit Card，用于生成信用卡相关数据，如过期时间、银行卡号、安全码等内容，用法如下：

1
2
3
4
5
6
7
8
9
10

faker.credit_card_expire(start="now", end="+10y", date_format="%m/%y")
# '08/20'
faker.credit_card_full(card_type=None)
# 'Mastercardn玉兰 范n5183689713096897 01/25nCVV: 012n'
faker.credit_card_number(card_type=None)
# '4009911097184929918'
faker.credit_card_provider(card_type=None)
# 'JCB 15 digit'
faker.credit_card_security_code(card_type=None)
# '259'

Date Time

Date Time，用于生成时间相关数据，如年份、月份、星期、出生日期等内容，可以返回 datetime 类型的数据，用法如下：

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

faker.am_pm()
# 'AM'
faker.century()
# 'X'
faker.date(pattern="%Y-%m-%d", end_datetime=None)
# '1997-06-16'
faker.date_between(start_date="-30y", end_date="today")
# datetime.date(2000, 8, 30)
faker.date_between_dates(date_start=None, date_end=None)
# datetime.date(2019, 7, 30)
faker.date_object(end_datetime=None)
# datetime.date(1978, 3, 12)
faker.date_of_birth(tzinfo=None, minimum_age=0, maximum_age=115)
# datetime.date(2012, 6, 3)
faker.date_this_century(before_today=True, after_today=False)
# datetime.date(2011, 6, 12)
faker.date_this_decade(before_today=True, after_today=False)
# datetime.date(2011, 8, 22)
faker.date_this_month(before_today=True, after_today=False)
# datetime.date(2019, 7, 25)
faker.date_this_year(before_today=True, after_today=False)
# datetime.date(2019, 7, 22)
faker.date_time(tzinfo=None, end_datetime=None)
# datetime.datetime(2018, 8, 11, 22, 3, 34)
faker.date_time_ad(tzinfo=None, end_datetime=None, start_datetime=None)
# datetime.datetime(1566, 8, 26, 16, 25, 30)
faker.date_time_between(start_date="-30y", end_date="now", tzinfo=None)
# datetime.datetime(2015, 1, 31, 4, 14, 10)
faker.date_time_between_dates(datetime_start=None, datetime_end=None, tzinfo=None)
# datetime.datetime(2019, 7, 30, 17, 51, 44)
faker.date_time_this_century(before_now=True, after_now=False, tzinfo=None)
# datetime.datetime(2002, 9, 25, 23, 59, 49)
faker.date_time_this_decade(before_now=True, after_now=False, tzinfo=None)
# datetime.datetime(2010, 5, 25, 20, 20, 52)
faker.date_time_this_month(before_now=True, after_now=False, tzinfo=None)
# datetime.datetime(2019, 7, 19, 18, 4, 6)
faker.date_time_this_year(before_now=True, after_now=False, tzinfo=None)
# datetime.datetime(2019, 3, 15, 11, 4, 18)
faker.day_of_month()
# '04'
faker.day_of_week()
# 'Monday'
faker.future_date(end_date="+30d", tzinfo=None)
# datetime.date(2019, 8, 12)
faker.future_datetime(end_date="+30d", tzinfo=None)
# datetime.datetime(2019, 8, 24, 2, 59, 4)
faker.iso8601(tzinfo=None, end_datetime=None)
# '1987-07-01T18:33:56'
faker.month()
# '11'
faker.month_name()
# 'August'
faker.past_date(start_date="-30d", tzinfo=None)
# datetime.date(2019, 7, 25)
faker.past_datetime(start_date="-30d", tzinfo=None)
# datetime.datetime(2019, 7, 18, 22, 46, 51)
faker.time(pattern="%H:%M:%S", end_datetime=None)
# '16:22:30'
faker.time_delta(end_datetime=None)
# datetime.timedelta(0)
faker.time_object(end_datetime=None)
# datetime.time(22, 12, 15)
faker.time_series(start_date="-30d", end_date="now", precision=None, distrib=None, tzinfo=None)
# <generator object Provider.time_series at 0x7fcbce0604f8>
faker.timezone()
# 'Indian/Comoro'
faker.unix_time(end_datetime=None, start_datetime=None)
# 1182857626
faker.year()
# '1970'

File

File，用于生成文件和文件路径相关的数据，包括文件扩展名、文件路径、MIME_TYPE、磁盘分区等内容，用法如下：

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

faker.file_extension(category=None)
# 'flac'
faker.file_name(category=None, extension=None)
# '然后.numbers'
faker.file_path(depth=1, category=None, extension=None)
# '/关系/科技.mov'
faker.mime_type(category=None)
# 'video/ogg'
faker.unix_device(prefix=None)
# '/dev/sdd'
faker.unix_partition(prefix=None)
# '/dev/xvds3'

Geo

Geo，用于生成和地理位置相关的数据，包括经纬度，时区等等信息，用法如下：

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

faker.coordinate(center=None, radius=0.001)
# Decimal('-114.420686')
faker.latitude()
# Decimal('-9.772541')
faker.latlng()
# (Decimal('-27.0730915'), Decimal('-5.919460'))
faker.local_latlng(country_code="US", coords_only=False)
# ('41.47892', '-87.45476', 'Schererville', 'US', 'America/Chicago')
faker.location_on_land(coords_only=False)
# ('12.74482', '4.52514', 'Argungu', 'NG', 'Africa/Lagos')
faker.longitude()
# Decimal('40.885895')

Internet

Internet，用于生成和互联网相关的数据，包括随机电子邮箱、域名、IP 地址、URL、用户名、后缀名等内容，用法如下：

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

faker.ascii_company_email(*args, **kwargs)
# 'xuna@xiaqian.cn'
faker.ascii_email(*args, **kwargs)
# 'min59@60.cn'
faker.ascii_free_email(*args, **kwargs)
# 'min75@gmail.com'
faker.ascii_safe_email(*args, **kwargs)
# 'cliu@example.com'
faker.company_email(*args, **kwargs)
# 'ilong@99.cn'
faker.domain_name(levels=1)
# 'xiulan.cn'
faker.domain_word(*args, **kwargs)
# 'luo'
faker.email(*args, **kwargs)
# 'maoxiulan@hotmail.com'
faker.free_email(*args, **kwargs)
# 'yanshen@gmail.com'
faker.free_email_domain(*args, **kwargs)
# 'yahoo.com'
faker.hostname(*args, **kwargs)
# 'lt-18.pan.cn'
faker.image_url(width=None, height=None)
# 'https://placekitten.com/51/201'
faker.ipv4(network=False, address_class=None, private=None)
# '192.233.68.5'
faker.ipv4_network_class()
# 'a'
faker.ipv4_private(network=False, address_class=None)
# '10.9.97.93'
faker.ipv4_public(network=False, address_class=None)
# '192.51.22.7'
faker.ipv6(network=False)
# 'de57:9c6f:a38c:9864:10ec:6442:775d:5f02'
faker.mac_address()
# '99:80:5c:ab:8c:a9'
faker.safe_email(*args, **kwargs)
# 'tangjuan@example.net'
faker.slug(*args, **kwargs)
# ''
faker.tld()
# 'cn'
faker.uri()
# 'http://fangfan.org/app/tag/post/'
faker.uri_extension()
# '.php'
faker.uri_page()
# 'about'
faker.uri_path(deep=None)
# 'app'
faker.url(schemes=None)
# 'http://mingli.cn/'
faker.user_name(*args, **kwargs)
# 'jie54'

Job

Job，用于生成和职业相关的数据，用法如下：

1
2

faker.job()
# '烫工'

Lorem

Lorem，用于生成一些假文字数据，包括句子、自然段、长文本、关键词等，另外可以传入不同的参数来控制生成的长度，用法如下：

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

faker.paragraph(nb_sentences=3, variable_nb_sentences=True, ext_word_list=None)
# '包括的是报告那些一点.图片地址基本全部.'
faker.paragraphs(nb=3, ext_word_list=None)
# [   '计划规定这样所以组织商品其中.参加成为不同发表地区.精华科技谢谢大家需要.一下手机上海中文工程.',
#     '非常相关是一就是一个一种文章发生.增加那些以及之后以下你的.',
#     '学生应该出来分析增加关系组织.评论来源朋友注册应该需要单位.感觉最后无法发现选择人民.']
faker.sentence(nb_words=6, variable_nb_words=True, ext_word_list=None)
# '介绍结果自己解决处理.'
faker.sentences(nb=3, ext_word_list=None)
# ['查看其实一次学习登录浏览是一他们.', '而且资源的人事情.', '科技价格免费大学教育.']
faker.text(max_nb_chars=200, ext_word_list=None)
# ('只是当前国内中文所以.威望系统在线虽然.n'
#  '图片人民非常合作这种谢谢更新.名称详细直接社会一直首页完全.n'
#  '重要更多只要市场.必须只是学生音乐.系统美国类别这些一切环境.n'
#  '但是的话人民美国关于.n'
#  '情况专业国际看到研究.音乐环境市场搜索发现.n'
#  '工具还是到了今天位置人民.留言作者品牌工程项目必须.上海精华现在我们新闻应该关系.n'
#  '更新经济能力全部资源如果.手机能够登录国内.')
faker.texts(nb_texts=3, max_nb_chars=200, ext_word_list=None)
# [   '成功可能推荐你的行业.地区而且推荐.n'
#     '网络不断是一主要必须.开始安全服务.n'
#     '应该网上通过以后通过大学.管理要求有关国际阅读当前.为了应该结果点击公司开始怎么.n'
#     '成功一次最大生产网站.这种加入她的地址有限.n'
#     '根据新闻汽车起来非常主题显示必须.有些建设来自作者电话支持.n'
#     '只是资源还是由于经济事情喜欢.为什中文大小得到服务.网络密码是否免费参加一次社区欢迎.',
#     '部门活动技术.商品影响发生行业密码完成.就是部门结果资料学习当然.或者帮助城市要求首页市场教育你们.n'
#     '专业完全分析处理城市大学什么.n'
#     '文件非常国际全部起来积分公司.资料的是电影没有.这是本站需要.n'
#     '合作重要没有现在市场开发空间.您的会员推荐成功教育进行中国.n'
#     '文件不是如果评论.因为经验设备规定.n'
#     '加入一起影响网上大家运行在线如果.工程企业这种以后.',
#     '空间市场出现必须基本电话.显示一个标准其他设计作品.工程不断新闻问题更多更新这么.n'
#     '一起简介网上内容不会.任何知道各种两个.类别事情经营那么投资市场.n'
#     '那些使用介绍公司朋友人民你们浏览.应该表示一点一般说明主要谢谢.电话回复起来经验一个来源加入.n'
#     '地区法律其他表示虽然.参加社会喜欢有限论坛一般发布.类别目前文化可以.n'
#     '报告质量工作主要.企业发布完全.得到名称作者等级两个论坛只要电话.']
faker.word(ext_word_list=None)
# '注意'
faker.words(nb=3, ext_word_list=None, unique=False)
# ['责任', '组织', '以后']

在这里每个方法的参数是不同的，具体的参数解释可以见源代码每个方法的注释：https://github.com/joke2k/faker/blob/master/faker/providers/lorem/init.py，

Misc

Misc，用于生成生成一些混淆数据，比如密码、sha1、sha256、md5 等加密后的内容，用法如下：

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

faker.boolean(chance_of_getting_true=50)
# True
faker.md5(raw_output=False)
# '3166fa26ffd3f2a33e020dfe11191ac6'
faker.null_boolean()
# False
faker.password(length=10, special_chars=True, digits=True, upper_case=True, lower_case=True)
# 'W7Ln8La@%O'
faker.sha1(raw_output=False)
# 'c8301a2a79445439ee5287f38053e4b3a05eac79'
faker.sha256(raw_output=False)
# '1e909d331e20cf241aaa2da894deae5a3a75e5cdc35c053422d9b8e7ccfa0402'
faker.uuid4(cast_to=<class 'str'>)
# '6e6fe387-6877-48d9-94ea-4263c4c71aa5'

Person

Person，用于生成和人名相关的数据，包括姓氏、名字、全名、英文名等内容，还能区分男女名字，用法如下：

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

faker.first_name()
# '颖'
faker.first_name_female()
# '芳'
faker.first_name_male()
# '利'
faker.first_romanized_name()
# 'Jing'
faker.last_name()
# '温'
faker.last_name_female()
# '寇'
faker.last_name_male()
# '陈'
faker.last_romanized_name()
# 'Lei'
faker.name()
# '黄明'
faker.name_female()
# '张凯'
faker.name_male()
# '黄鹏'

User-Agent

User-Agent，用于生成和浏览器 User-Agent 相关的内容，可以定制各种浏览器，还可以传入版本信息来控制生成的内容，用法如下：

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

faker.chrome(version_from=13, version_to=63, build_from=800, build_to=899)
# ('Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/5332 (KHTML, like Gecko) '
#  'Chrome/40.0.837.0 Safari/5332')
faker.firefox()
# ('Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_8_9; rv:1.9.4.20) '
#  'Gecko/2019-05-02 05:58:44 Firefox/3.6.19')
faker.internet_explorer()
# 'Mozilla/5.0 (compatible; MSIE 8.0; Windows NT 5.2; Trident/3.0)'
faker.linux_platform_token()
# 'X11; Linux i686'
faker.linux_processor()
# 'x86_64'
faker.mac_platform_token()
# 'Macintosh; U; PPC Mac OS X 10_12_5'
faker.mac_processor()
# 'U; Intel'
faker.opera()
# 'Opera/9.77.(Windows NT 4.0; vi-VN) Presto/2.9.182 Version/11.00'
faker.safari()
# ('Mozilla/5.0 (Macintosh; PPC Mac OS X 10_7_1 rv:5.0; or-IN) '
#  'AppleWebKit/535.9.4 (KHTML, like Gecko) Version/5.0.2 Safari/535.9.4')
faker.user_agent()
# 'Opera/8.69.(X11; Linux i686; ml-IN) Presto/2.9.170 Version/11.00'
faker.windows_platform_token()
# 'Windows NT 6.1'

以上仅仅列了一部分，还有更多的功能大家可以查看官方文档的内容，链接为：https://faker.readthedocs.io/en/master/locales/zh_CN.html。

其他 Provider

另外还有一些社区贡献的 Provider，如 WiFi、微服务相关的，大家可以查看文档的说明，另外需要额外安装这些扩展包并自行添加 Provider，文档见：https://faker.readthedocs.io/en/master/communityproviders.html。 添加 Provider 需要调用 add_provider 方法，用法示例如下：

1
2
3
4
5
6

from faker import Faker
from faker.providers import internet

faker = Faker()
faker.add_provider(internet)
print(faker.ipv4_private())

还有更多的内容大家可以参考官方文档，链接：https://faker.readthedocs.io/。

实例引入

我们知道 Python 是一种动态语言，在声明一个变量时我们不需要显式地声明它的类型，例如下面的例子：

1
2

a = 2
print('1 + a =', 1 + a)

运行结果：

1

1 + a = 3

这里我们首先声明了一个变量 a，并将其赋值为了 2，然后将最后的结果打印出来，程序输出来了正确的结果。但在这个过程中，我们没有声明它到底是什么类型。 但如果这时候我们将 a 变成一个字符串类型，结果会是怎样的呢？改写如下：

1
2

a = '2'
print('1 + a =', 1 + a)

运行结果：

1

TypeError: unsupported operand type(s) for +: 'int' and 'str'

直接报错了，错误原因是我们进行了字符串类型的变量和数值类型变量的加和，两种数据类型不同，是无法进行相加的。 如果我们将上面的语句改写成一个方法定义：

1
2

def add(a):
    return a + 1

这里定义了一个方法，传入一个参数，然后将其加 1 并返回。 如果这时候如果用下面的方式调用，传入的参数是一个数值类型：

1

add(2)

则可以正常输出结果 3。但如果我们传入的参数并不是我们期望的类型，比如传入一个字符类型，那么就会同样报刚才类似的错误。 但又由于 Python 的特性，很多情况下我们并不用去声明它的类型，因此从方法定义上面来看，我们实际上是不知道一个方法的参数到底应该传入什么类型的。 这样其实就造成了很多不方便的地方，在某些情况下一些复杂的方法，如果不借助于一些额外的说明，我们是不知道参数到底是什么类型的。 因此，Python 中的类型注解就显得比较重要了。

类型注解

在 Python 3.5 中，Python PEP 484 引入了类型注解（type hints），在 Python 3.6 中，PEP 526 又进一步引入了变量注解（Variable Annotations），所以上面的代码我们改写成如下写法：

1
2
3
4
5

a: int = 2
print('5 + a =', 5 + a)

def add(a: int) -> int:
    return a + 1

具体的语法是可以归纳为两点：

• 在声明变量时，变量的后面可以加一个冒号，后面再写上变量的类型，如 int、list 等等。
• 在声明方法返回值的时候，可以在方法的后面加一个箭头，后面加上返回值的类型，如 int、list 等等。

在 PEP 8 中，具体的格式是这样规定的：

• 在声明变量类型时，变量后方紧跟一个冒号，冒号后面跟一个空格，再跟上变量的类型。
• 在声明方法返回值的时候，箭头左边是方法定义，箭头右边是返回值的类型，箭头左右两边都要留有空格。

有了这样的声明，以后我们如果看到这个方法的定义，我们就知道传入的参数类型了，如调用 add 方法的时候，我们就知道传入的需要是一个数值类型的变量，而不是字符串类型，非常直观。 但值得注意的是，这种类型和变量注解实际上只是一种类型提示，对运行实际上是没有影响的，比如调用 add 方法的时候，我们传入的不是 int 类型，而是一个 float 类型，它也不会报错，也不会对参数进行类型转换，如：

1

add(1.5)

我们传入的是一个 float 类型的数值 1.5，看下运行结果：

1

2.5

可以看到，运行结果正常输出，而且 1.5 并没有经过强制类型转换变成 1，否则结果会变成 2。 因此，类型和变量注解只是提供了一种提示，对于运行实际上没有任何影响。 不过有了类型注解，一些 IDE 是可以识别出来并提示的，比如 PyCharm 就可以识别出来在调用某个方法的时候参数类型不一致，会提示 WARNING。 比如上面的调用，如果在 PyCharm 中，就会有如下提示内容：

1
2

Expected type 'int', got 'float' instead
This inspection detects type errors in function call expressions. Due to dynamic dispatch and duck typing, this is possible in a limited but useful number of cases. Types of function parameters can be specified in docstrings or in Python 3 function annotations.

另外也有一些库是支持类型检查的，比如 mypy，安装之后，利用 mypy 即可检查出 Python 脚本中不符合类型注解的调用情况。 上面只是用一个简单的 int 类型做了实例，下面我们再看下一些相对复杂的数据结构，例如列表、元组、字典等类型怎么样来声明。 可想而知了，列表用 list 表示，元组用 tuple 表示，字典用 dict 来表示，那么很自然地，在声明的时候我们就很自然地写成这样了：

1
2
3

names: list = ['Germey', 'Guido']
version: tuple = (3, 7, 4)
operations: dict = {'show': False, 'sort': True}

这么看上去没有问题，确实声明为了对应的类型，但实际上并不能反映整个列表、元组的结构，比如我们只通过类型注解是不知道 names 里面的元素是什么类型的，只知道 names 是一个列表 list 类型，实际上里面都是字符串 str 类型。我们也不知道 version 这个元组的每一个元素是什么类型的，实际上是 int 类型。但这些信息我们都无从得知。因此说，仅仅凭借 list、tuple 这样的声明是非常“弱”的，我们需要一种更强的类型声明。 这时候我们就需要借助于 typing 模块了，它提供了非常“强“的类型支持，比如 List[str]、Tuple[int, int, int] 则可以表示由 str 类型的元素组成的列表和由 int 类型的元素组成的长度为 3 的元组。所以上文的声明写法可以改写成下面的样子：

1
2
3
4
5

from typing import List, Tuple, Dict

names: List[str] = ['Germey', 'Guido']
version: Tuple[int, int, int] = (3, 7, 4)
operations: Dict[str, bool] = {'show': False, 'sort': True}

这样一来，变量的类型便可以非常直观地体现出来了。 目前 typing 模块也已经被加入到 Python 标准库中，不需要安装第三方模块，我们就可以直接使用了。

typing

下面我们再来详细看下 typing 模块的具体用法，这里主要会介绍一些常用的注解类型，如 List、Tuple、Dict、Sequence 等等，了解了每个类型的具体使用方法，我们可以得心应手的对任何变量进行声明了。 在引入的时候就直接通过 typing 模块引入就好了，例如：

1

from typing import List, Tuple

List

List、列表，是 list 的泛型，基本等同于 list，其后紧跟一个方括号，里面代表了构成这个列表的元素类型，如由数字构成的列表可以声明为：

1

var: List[int or float] = [2, 3.5]

另外还可以嵌套声明都是可以的：

1

var: List[List[int]] = [[1, 2], [2, 3]]

Tuple、NamedTuple

Tuple、元组，是 tuple 的泛型，其后紧跟一个方括号，方括号中按照顺序声明了构成本元组的元素类型，如 Tuple[X, Y] 代表了构成元组的第一个元素是 X 类型，第二个元素是 Y 类型。 比如想声明一个元组，分别代表姓名、年龄、身高，三个数据类型分别为 str、int、float，那么可以这么声明：

1

person: Tuple[str, int, float] = ('Mike', 22, 1.75)

同样地也可以使用类型嵌套。 NamedTuple，是 collections.namedtuple 的泛型，实际上就和 namedtuple 用法完全一致，但个人其实并不推荐使用 NamedTuple，推荐使用 attrs 这个库来声明一些具有表征意义的类。

Dict、Mapping、MutableMapping

Dict、字典，是 dict 的泛型；Mapping，映射，是 collections.abc.Mapping 的泛型。根据官方文档，Dict 推荐用于注解返回类型，Mapping 推荐用于注解参数。它们的使用方法都是一样的，其后跟一个中括号，中括号内分别声明键名、键值的类型，如：

1
2

def size(rect: Mapping[str, int]) -> Dict[str, int]:
    return {'width': rect['width'] + 100, 'height': rect['width'] + 100}

这里将 Dict 用作了返回值类型注解，将 Mapping 用作了参数类型注解。 MutableMapping 则是 Mapping 对象的子类，在很多库中也经常用 MutableMapping 来代替 Mapping。

Set、AbstractSet

Set、集合，是 set 的泛型；AbstractSet、是 collections.abc.Set 的泛型。根据官方文档，Set 推荐用于注解返回类型，AbstractSet 用于注解参数。它们的使用方法都是一样的，其后跟一个中括号，里面声明集合中元素的类型，如：

1
2

def describe(s: AbstractSet[int]) -> Set[int]:
    return set(s)

这里将 Set 用作了返回值类型注解，将 AbstractSet 用作了参数类型注解。

Sequence

Sequence，是 collections.abc.Sequence 的泛型，在某些情况下，我们可能并不需要严格区分一个变量或参数到底是列表 list 类型还是元组 tuple 类型，我们可以使用一个更为泛化的类型，叫做 Sequence，其用法类似于 List，如：

1
2

def square(elements: Sequence[float]) -> List[float]:
    return [x ** 2 for x in elements]

NoReturn

NoReturn，当一个方法没有返回结果时，为了注解它的返回类型，我们可以将其注解为 NoReturn，例如：

1
2

def hello() -> NoReturn:
    print('hello')

Any

Any，是一种特殊的类型，它可以代表所有类型，静态类型检查器的所有类型都与 Any 类型兼容，所有的无参数类型注解和返回类型注解的都会默认使用 Any 类型，也就是说，下面两个方法的声明是完全等价的：

1
2
3
4
5

def add(a):
    return a + 1

def add(a: Any) -> Any:
    return a + 1

原理类似于 object，所有的类型都是 object 的子类。但如果我们将参数声明为 object 类型，静态参数类型检查便会抛出错误，而 Any 则不会，具体可以参考官方文档的说明：https://docs.python.org/zh-cn/3/library/typing.html?highlight=typing#the-any-type。

TypeVar

TypeVar，我们可以借助它来自定义兼容特定类型的变量，比如有的变量声明为 int、float、None 都是符合要求的，实际就是代表任意的数字或者空内容都可以，其他的类型则不可以，比如列表 list、字典 dict 等等，像这样的情况，我们可以使用 TypeVar 来表示。 例如一个人的身高，便可以使用 int 或 float 或 None 来表示，但不能用 dict 来表示，所以可以这么声明：

1
2
3
4

height = 1.75
Height = TypeVar('Height', int, float, None)
def get_height() -> Height:
    return height

这里我们使用 TypeVar 声明了一个 Height 类型，然后将其用于注解方法的返回结果。

NewType

NewType，我们可以借助于它来声明一些具有特殊含义的类型，例如像 Tuple 的例子一样，我们需要将它表示为 Person，即一个人的含义，但但从表面上声明为 Tuple 并不直观，所以我们可以使用 NewType 为其声明一个类型，如：

1
2

Person = NewType('Person', Tuple[str, int, float])
person = Person(('Mike', 22, 1.75))

这里实际上 person 就是一个 tuple 类型，我们可以对其像 tuple 一样正常操作。

Callable

Callable，可调用类型，它通常用来注解一个方法，比如我们刚才声明了一个 add 方法，它就是一个 Callable 类型：

1

print(Callable, type(add), isinstance(add, Callable))

运行结果：

1

typing.Callable <class 'function'> True

在这里虽然二者 add 利用 type 方法得到的结果是 function，但实际上利用 isinstance 方法判断确实是 True。 Callable 在声明的时候需要使用 Callable[[Arg1Type, Arg2Type, ...], ReturnType] 这样的类型注解，将参数类型和返回值类型都要注解出来，例如：

1
2
3
4
5

def date(year: int, month: int, day: int) -> str:
    return f'{year}-{month}-{day}'

def get_date_fn() -> Callable[[int, int, int], str]:
    return date

这里首先声明了一个方法 date，接收三个 int 参数，返回一个 str 结果，get_date_fn 方法返回了这个方法本身，它的返回值类型就可以标记为 Callable，中括号内分别标记了返回的方法的参数类型和返回值类型。

Union

Union，联合类型，Union[X, Y] 代表要么是 X 类型，要么是 Y 类型。 联合类型的联合类型等价于展平后的类型：

1

Union[Union[int, str], float] == Union[int, str, float]

仅有一个参数的联合类型会坍缩成参数自身，比如：

1

Union[int] == int

多余的参数会被跳过，比如：

1

Union[int, str, int] == Union[int, str]

在比较联合类型的时候，参数顺序会被忽略，比如：

1

Union[int, str] == Union[str, int]

这个在一些方法参数声明的时候比较有用，比如一个方法，要么传一个字符串表示的方法名，要么直接把方法传过来：

1
2
3
4
5
6

def process(fn: Union[str, Callable]):
    if isinstance(fn, str):
        # str2fn and process
        pass
    elif isinstance(fn, Callable):
        fn()

这样的声明在一些类库方法定义的时候十分常见。

Optional

Optional，意思是说这个参数可以为空或已经声明的类型，即 Optional[X] 等价于 Union[X, None]。 但值得注意的是，这个并不等价于可选参数，当它作为参数类型注解的时候，不代表这个参数可以不传递了，而是说这个参数可以传为 None。 如当一个方法执行结果，如果执行完毕就不返回错误信息， 如果发生问题就返回错误信息，则可以这么声明：

1
2

def judge(result: bool) -> Optional[str]:
    if result: return 'Error Occurred'

Generator

如果想代表一个生成器类型，可以使用 Generator，它的声明比较特殊，其后的中括号紧跟着三个参数，分别代表 YieldType、SendType、ReturnType，如：

1
2
3
4
5

def echo_round() -> Generator[int, float, str]:
    sent = yield 0
    while sent >= 0:
        sent = yield round(sent)
    return 'Done'

在这里 yield 关键字后面紧跟的变量的类型就是 YieldType，yield 返回的结果的类型就是 SendType，最后生成器 return 的内容就是 ReturnType。 当然很多情况下，生成器往往只需要 yield 内容就够了，我们是不需要 SendType 和 ReturnType 的，可以将其设置为空，如：

1
2
3
4

def infinite_stream(start: int) -> Generator[int, None, None]:
    while True:
        yield start
        start += 1

案例实战

接下来让我们看一个实际的项目，看看经常用到的类型一般是怎么使用的。 这里我们看的库是 requests-html，是由 Kenneth Reitz 所开发的，其 GitHub 地址为：https://github.com/psf/requests-html，下面我们主要看看它的源代码中一些类型是如何声明的。 这个库的源代码其实就一个文件，那就是 https://github.com/psf/requests-html/blob/master/requests_html.py，我们看一下它里面的一些 typing 的定义和方法定义。 首先 Typing 的定义部分如下：

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

from typing import Set, Union, List, MutableMapping, Optional

_Find = Union[List['Element'], 'Element']
_XPath = Union[List[str], List['Element'], str, 'Element']
_Result = Union[List['Result'], 'Result']
_HTML = Union[str, bytes]
_BaseHTML = str
_UserAgent = str
_DefaultEncoding = str
_URL = str
_RawHTML = bytes
_Encoding = str
_LXML = HtmlElement
_Text = str
_Search = Result
_Containing = Union[str, List[str]]
_Links = Set[str]
_Attrs = MutableMapping
_Next = Union['HTML', List[str]]
_NextSymbol = List[str]

这里可以看到主要用到的类型有 Set、Union、List、MutableMapping、Optional，这些在上文都已经做了解释，另外这里使用了多次 Union 来声明了一些新的类型，如 _Find 则要么是是 Element 对象的列表，要么是单个 Element 对象，_Result 则要么是 Result 对象的列表，要么是单个 Result 对象。另外 _Attrs 其实就是字典类型，这里用 MutableMapping 来表示了，没有用 Dict，也没有用 Mapping。 接下来再看一个 Element 类的声明：

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

class Element(BaseParser):
    """An element of HTML.
    :param element: The element from which to base the parsing upon.
    :param url: The URL from which the HTML originated, used for ``absolute_links``.
    :param default_encoding: Which encoding to default to.
    """

    __slots__ = [
        'element', 'url', 'skip_anchors', 'default_encoding', '_encoding',
        '_html', '_lxml', '_pq', '_attrs', 'session'
    ]

    def __init__(self, *, element, url: _URL, default_encoding: _DefaultEncoding = None) -> None:
        super(Element, self).__init__(element=element, url=url, default_encoding=default_encoding)
        self.element = element
        self.tag = element.tag
        self.lineno = element.sourceline
        self._attrs = None

    def __repr__(self) -> str:
        attrs = ['{}={}'.format(attr, repr(self.attrs[attr])) for attr in self.attrs]
        return "<Element {} {}>".format(repr(self.element.tag), ' '.join(attrs))

    @property
    def attrs(self) -> _Attrs:
        """Returns a dictionary of the attributes of the :class:`Element <Element>`
        (`learn more <https://www.w3schools.com/tags/ref_attributes.asp>`_).
        """
        if self._attrs is None:
            self._attrs = {k: v for k, v in self.element.items()}

            # Split class and rel up, as there are ussually many of them:
            for attr in ['class', 'rel']:
                if attr in self._attrs:
                    self._attrs[attr] = tuple(self._attrs[attr].split())

        return self._attrs

这里 __init__ 方法接收非常多的参数，同时使用 _URL 、_DefaultEncoding 进行了参数类型注解，另外 attrs 方法使用了 _Attrs 进行了返回结果类型注解。 整体看下来，每个参数的类型、返回值都进行了清晰地注解，代码可读性大大提高。 以上便是类型注解和 typing 模块的详细介绍。

相对免费代理来说，付费代理的稳定性相对更高一点，本节介绍一下爬虫付费代理的相关使用过程。

1. 付费代理分类

在这里将付费代理分为两类：

• 提供接口获取海量代理，按天或者按量付费，如讯代理
• 搭建了代理隧道，直接设置固定域名代理，如阿布云

本节讲解一下这两种代理的使用方法，分别以两家代表性的代理网站为例进行讲解。

2. 讯代理

讯代理个人使用过代理有效率还是蛮高的，此处非广告，其官网为：http://www.xdaili.cn/，如图 9-5 所示： 图 9-5 讯代理官网 有多种类别的代理可供选购，摘抄其官网的各类别代理介绍如下：

• 优质代理： 适合对代理 IP 需求量非常大，但能接受代理有效时长较短（10~30 分钟)，小部分不稳定的客户
• 独享动态： 适合对代理 IP 稳定性要求非常高，且可以自主控制的客户，支持地区筛选。
• 独享秒切： 适合对代理 IP 稳定性要求非常高，且可以自主控制的客户，快速获取 IP，地区随机分配
• 动态混拨： 适合对代理 IP 需求量大，代理 IP 使用时效短（3 分钟），切换快的客户
• 优质定制： 如果优质代理的套餐不能满足您的需求，请使用定制服务

一般选择第一类别优质代理即可，代理量比较大，但是代理的稳定性没那么高，有一些代理也是不可用的，所以这种代理的使用方式就需要借助于上一节所说的代理池，我们自己再做一次筛选，确保代理可用。 可以购买一天的试一下效果，购买之后会提供一个 API 来提取代理，如图 9-6 所示： 图 9-6 提取页面 比如在这里我的提取 API 为：http://www.xdaili.cn/ipagent/greatRecharge/getGreatIp?spiderId=da289b78fec24f19b392e04106253f2a&orderno=YZ20177140586mTTnd7&returnType=2&count=20，可能已过期，在此仅做演示。 在这里指定了提取数量为 20，提取格式为 Json，直接访问链接即可提取代理，结果如图 9-7 所示： 图 9-7 提取结果 接下来我们要做的就是解析这个 Json，然后将其放入我们的代理池中。 当然如果信赖讯代理的话也可以不做代理池筛选，直接使用，不过我个人还是推荐再使用代理池筛选一遍，提高可用几率。 根据上一节代理池的写法，我们只需要在 Crawler 中再加入一个 crawl 开头的方法即可。 方法实现如下：

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

def crawl_xdaili(self):
        """
        获取讯代理
        :return: 代理
        """
        url = 'http://www.xdaili.cn/ipagent/greatRecharge/getGreatIp?spiderId=da289b78fec24f19b392e04106253f2a&orderno=YZ20177140586mTTnd7&returnType=2&count=20'
        html = get_page(url)
        if html:
            result = json.loads(html)
            proxies = result.get('RESULT')
            for proxy in proxies:
                yield proxy.get('ip') + ':' + proxy.get('port')

这样我们就在代理池中接入了讯代理，获取讯代理的结果之后，解析 Json，返回代理即可。 这样代理池运行之后就会抓取和检测该接口返回的代理了，如果可用，那么就会被设为 100，通过代理池接口即可获取到。 以上以讯代理为例说明了此种批量提取代理的使用方法。

3. 阿布云代理

阿布云代理提供了代理隧道，代理速度快而且非常稳定，此处依然非广告，其官网为：https://www.abuyun.com/，如图 9-8 所示： 图 9-8 阿布云官网 阿布云的代理主要分为两种，专业版和动态版，另外还有定制版，摘抄官网的介绍如下：

• 专业版，多个请求锁定一个代理 IP，海量 IP 资源池需求，近 300 个区域全覆盖，代理 IP 可连续使用 1 分钟，适用于请求 IP 连续型业务
• 动态版，每个请求一个随机代理 IP，海量 IP 资源池需求，近 300 个区域全覆盖，适用于爬虫类业务
• 定制版，灵活按照需求定制，定制 IP 区域，定制 IP 使用时长，定制 IP 每秒请求数

关于专业版和动态版的更多介绍可以查看官网：https://www.abuyun.com/http-proxy/dyn-intro.html。 对于爬虫来说，推荐使用动态版，购买之后可以在后台看到代理隧道的用户名和密码，如图 9-9 所示： 图 9-9 阿布云代理后台 可以发现整个代理的连接域名为 proxy.abuyun.com，端口为 9020，均是固定的，但是使用之后每次的 IP 都会更改，这其实就是利用了代理隧道实现。 其官网原理介绍如下：

• 云代理通过代理隧道的形式提供高匿名代理服务，支持 HTTP/HTTPS 协议。
• 云代理在云端维护一个全局 IP 池供代理隧道使用，池中的 IP 会不间断更新，以保证同一时刻 IP 池中有几十到几百个可用代理 IP。
• 需要注意的是代理 IP 池中有部分 IP 可能会在当天重复出现多次。
• 动态版 HTTP 代理隧道会为每个请求从 IP 池中挑选一个随机代理 IP。
• 无须切换代理 IP，每一个请求一个随机代理 IP。
• HTTP 代理隧道有并发请求限制，默认每秒只允许 5 个请求。如果需要更多请求数，请额外购买。

注意默认套餐的并发请求是 5 个，如果需要更多需要另外购买。 使用的教程在官网也有，链接为：https://www.abuyun.com/http-proxy/dyn-manual-python.html，提供了 Requests、Urllib、Scrapy 的接入方式。 以 Requests 为例，接入示例如下：

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 requests

url = 'http://httpbin.org/get'

# 代理服务器
proxy_host = 'proxy.abuyun.com'
proxy_port = '9020'

# 代理隧道验证信息
proxy_user = 'H01234567890123D'
proxy_pass = '0123456789012345'

proxy_meta = 'http://%(user)s:%(pass)s@%(host)s:%(port)s' % {
    'host': proxy_host,
    'port': proxy_port,
    'user': proxy_user,
    'pass': proxy_pass,
}
proxies = {
    'http': proxy_meta,
    'https': proxy_meta,
}
response = requests.get(url, proxies=proxies)
print(response.status_code)
print(response.text)

在这里其实就是使用了代理认证，在前面我们也提到过类似的设置方法，运行结果如下：

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

200
{
  "args": {},
  "headers": {
    "Accept": "*/*",
    "Accept-Encoding": "gzip, deflate",
    "Connection": "close",
    "Host": "httpbin.org",
    "User-Agent": "python-requests/2.18.1"
  },
  "origin": "60.207.237.111",
  "url": "http://httpbin.org/get"
}

输出结果的 origin 即为代理 IP 的实际地址，可以多次运行测试，可以发现每次请求 origin 都会在变化，这就是动态版代理的效果。 这种效果其实跟我们之前的代理池的随机代理效果类似，都是随机取出了一个当前可用代理。 但是此服务相比于维护代理池来说，使用更加方便，配置简单，省时省力，在价格可以接受的情况下，个人推荐此种代理。

4. 结语

以上便是付费代理的相关使用方法，稳定性相比免费代理更高，可以自行选购合适的代理。

我们在上一节了解了代理的设置方法，利用代理我们可以解决目标网站封 IP 的问题，而在网上又有大量公开的免费代理，其中有一部分可以拿来使用，或者我们也可以购买付费的代理 IP，价格也不贵。但是不论是免费的还是付费的，都不能保证它们每一个都是可用的，毕竟可能其他人也可能在用此 IP 爬取同样的目标站点而被封禁，或者代理服务器突然出故障或网络繁忙。一旦我们选用了一个不可用的代理，势必会影响我们爬虫的工作效率。 所以说，在用代理时，我们需要提前做一下筛选，将不可用的代理剔除掉，保留下可用代理，接下来在获取代理时从可用代理里面取出直接使用就好了。 所以本节我们来搭建一个高效易用的代理池。

1. 准备工作

要实现代理池我们首先需要成功安装好了 Redis 数据库并启动服务，另外还需要安装 Aiohttp、Requests、RedisPy、PyQuery、Flask 库，如果没有安装可以参考第一章的安装说明。

2. 代理池的目标

代理池要做到易用、高效，我们一般需要做到下面的几个目标：

• 基本模块分为四块，获取模块、存储模块、检查模块、接口模块。
• 获取模块需要定时去各大代理网站抓取代理，代理可以是免费公开代理也可以是付费代理，代理的形式都是 IP 加端口，尽量从不同来源获取，尽量抓取高匿代理，抓取完之后将可用代理保存到数据库中。
• 存储模块负责存储抓取下来的代理。首先我们需要保证代理不重复，另外我们还需要标识代理的可用情况，而且需要动态实时处理每个代理，所以说，一种比较高效和方便的存储方式就是使用 Redis 的 Sorted Set，也就是有序集合。
• 检测模块需要定时将数据库中的代理进行检测，在这里我们需要设置一个检测链接，最好是爬取哪个网站就检测哪个网站，这样更加有针对性，如果要做一个通用型的代理，那可以设置百度等链接来检测。另外我们需要标识每一个代理的状态，如设置分数标识，100 分代表可用，分数越少代表越不可用，检测一次如果可用，我们可以将其立即设置为 100 满分，也可以在原基础上加 1 分，当不可用，可以将其减 1 分，当减到一定阈值后就直接从数据库移除。通过这样的标识分数，我们就可以区分出代理的可用情况，选用的时候会更有针对性。
• 接口模块需要用 API 来提供对外服务的接口，其实我们可以直接连数据库来取，但是这样就需要知道数据库的连接信息，不太安全，而且需要配置连接，所以一个比较安全和方便的方式就是提供一个 Web API 接口，通过访问接口即可拿到可用代理。另外由于可用代理可能有多个，我们可以提供随机返回一个可用代理的接口，这样保证每个可用代理都可以取到，实现负载均衡。

以上便是设计代理的一些基本思路，那么接下来我们就设计一下整体的架构，然后用代码该实现代理池。

3. 代理池的架构

根据上文的描述，代理池的架构可以是这样的，如图 9-1 所示： 图 9-1 代理池架构 代理池分为四个部分，获取模块、存储模块、检测模块、接口模块。

• 存储模块使用 Redis 的有序集合，用以代理的去重和状态标识，同时它也是中心模块和基础模块，将其他模块串联起来。
• 获取模块定时从代理网站获取代理，将获取的代理传递给存储模块，保存到数据库。
• 检测模块定时通过存储模块获取所有代理，并对其进行检测，根据不同的检测结果对代理设置不同的标识。
• 接口模块通过 Web API 提供服务接口，其内部还是连接存储模块，获取可用的代理。

4. 代理池的实现

接下来我们分别用代码来实现一下这四个模块。

存储模块

存储在这里我们使用 Redis 的有序集合，集合的每一个元素都是不重复的，对于代理代理池来说，集合的元素就变成了一个个代理，也就是 IP 加端口的形式，如 60.207.237.111:8888，这样的一个代理就是集合的一个元素。另外有序集合的每一个元素还都有一个分数字段，分数是可以重复的，是一个浮点数类型，也可以是整数类型。该集合会根据每一个元素的分数对集合进行排序，数值小的排在前面，数值大的排在后面，这样就可以实现集合元素的排序了。 对于代理池来说，这个分数可以作为我们判断一个代理可用不可用的标志，我们将 100 设为最高分，代表可用，0 设为最低分，代表不可用。从代理池中获取代理的时候会随机获取分数最高的代理，注意这里是随机，这样可以保证每个可用代理都会被调用到。 分数是我们判断代理稳定性的重要标准，在这里我们设置分数规则如下：

• 分数 100 为可用，检测器会定时循环检测每个代理可用情况，一旦检测到有可用的代理就立即置为 100，检测到不可用就将分数减 1，减至 0 后移除。
• 新获取的代理添加时将分数置为 10，当测试可行立即置 100，不可行分数减 1，减至 0 后移除。

这是一种解决方案，当然可能还有更合理的方案。此方案的设置有一定的原因，在此总结如下：

• 当检测到代理可用时立即置为 100，这样可以保证所有可用代理有更大的机会被获取到。你可能会说为什么不直接将分数加 1 而是直接设为最高 100 呢？设想一下，我们有的代理是从各大免费公开代理网站获取的，如果一个代理并没有那么稳定，平均五次请求有两次成功，三次失败，如果按照这种方式来设置分数，那么这个代理几乎不可能达到一个高的分数，也就是说它有时是可用的，但是我们筛选是筛选的分数最高的，所以这样的代理就几乎不可能被取到，当然如果想追求代理稳定性的化可以用这种方法，这样可确保分数最高的一定是最稳定可用的。但是在这里我们采取可用即设置 100 的方法，确保只要可用的代理都可以被使用到。
• 当检测到代理不可用时，将分数减 1，减至 0 后移除，一共 100 次机会，也就是说当一个可用代理接下来如果尝试了 100 次都失败了，就一直减分直到移除，一旦成功就重新置回 100，尝试机会越多代表将这个代理拯救回来的机会越多，这样不容易将曾经的一个可用代理丢弃，因为代理不可用的原因可能是网络繁忙或者其他人用此代理请求太过频繁，所以在这里设置为 100 级。
• 新获取的代理分数设置为 10，检测如果不可用就减 1，减到 0 就移除，如果可用就置 100。由于我们很多代理是从免费网站获取的，所以新获取的代理无效的可能性是非常高的，可能不足 10%，所以在这里我们将其设置为 10，检测的机会没有可用代理 100 次那么多，这也可以适当减少开销。

以上便是代理分数的一个设置思路，不一定是最优思路，但个人实测实用性还是比较强的。 所以我们就需要定义一个类来操作数据库的有序集合，定义一些方法来实现分数的设置，代理的获取等等。 实现如下：

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

MAX_SCORE = 100
MIN_SCORE = 0
INITIAL_SCORE = 10
REDIS_HOST = 'localhost'
REDIS_PORT = 6379
REDIS_PASSWORD = None
REDIS_KEY = 'proxies'

import redis
from random import choice

class RedisClient(object):
    def __init__(self, host=REDIS_HOST, port=REDIS_PORT, password=REDIS_PASSWORD):
        """
        初始化
        :param host: Redis 地址
        :param port: Redis 端口
        :param password: Redis密码
        """
        self.db = redis.StrictRedis(host=host, port=port, password=password, decode_responses=True)

    def add(self, proxy, score=INITIAL_SCORE):
        """
        添加代理，设置分数为最高
        :param proxy: 代理
        :param score: 分数
        :return: 添加结果
        """
        if not self.db.zscore(REDIS_KEY, proxy):
            return self.db.zadd(REDIS_KEY, score, proxy)

    def random(self):
        """
        随机获取有效代理，首先尝试获取最高分数代理，如果不存在，按照排名获取，否则异常
        :return: 随机代理
        """
        result = self.db.zrangebyscore(REDIS_KEY, MAX_SCORE, MAX_SCORE)
        if len(result):
            return choice(result)
        else:
            result = self.db.zrevrange(REDIS_KEY, 0, 100)
            if len(result):
                return choice(result)
            else:
                raise PoolEmptyError

    def decrease(self, proxy):
        """
        代理值减一分，小于最小值则删除
        :param proxy: 代理
        :return: 修改后的代理分数
        """
        score = self.db.zscore(REDIS_KEY, proxy)
        if score and score > MIN_SCORE:
            print('代理', proxy, '当前分数', score, '减1')
            return self.db.zincrby(REDIS_KEY, proxy, -1)
        else:
            print('代理', proxy, '当前分数', score, '移除')
            return self.db.zrem(REDIS_KEY, proxy)

    def exists(self, proxy):
        """
        判断是否存在
        :param proxy: 代理
        :return: 是否存在
        """
        return not self.db.zscore(REDIS_KEY, proxy) == None

    def max(self, proxy):
        """
        将代理设置为MAX_SCORE
        :param proxy: 代理
        :return: 设置结果
        """
        print('代理', proxy, '可用，设置为', MAX_SCORE)
        return self.db.zadd(REDIS_KEY, MAX_SCORE, proxy)

    def count(self):
        """
        获取数量
        :return: 数量
        """
        return self.db.zcard(REDIS_KEY)

    def all(self):
        """
        获取全部代理
        :return: 全部代理列表
        """
        return self.db.zrangebyscore(REDIS_KEY, MIN_SCORE, MAX_SCORE)

首先定义了一些常量，如 MAX_SCORE、MIN_SCORE、INITIAL_SCORE 分别代表最大分数、最小分数、初始分数。REDIS_HOST、REDIS_PORT、REDIS_PASSWORD 分别代表了 Redis 的连接信息，即地址、端口、密码。REDIS_KEY 是有序集合的键名，可以通过它来获取代理存储所使用的有序集合。 接下来定义了一个 RedisClient 类，用以操作 Redis 的有序集合，其中定义了一些方法来对集合中的元素进行处理，主要功能如下：

• init() 方法是初始化的方法，参数是 Redis 的连接信息，默认的连接信息已经定义为常量，在 init() 方法中初始化了一个 StrictRedis 的类，建立 Redis 连接。这样当 RedisClient 类初始化的时候就建立了 Redis 的连接。
• add() 方法向数据库添加代理并设置分数，默认的分数是 INITIAL_SCORE 也就是 10，返回结果是添加的结果。
• random() 方法是随机获取代理的方法，首先获取 100 分的代理，然后随机选择一个返回，如果不存在 100 分的代理，则按照排名来获取，选取前 100 名，然后随机选择一个返回，否则抛出异常。
• decrease() 方法是在代理检测无效的时候设置分数减 1 的方法，传入代理，然后将此代理的分数减 1，如果达到最低值，那么就删除。
• exists() 方法判断代理是否存在集合中
• max() 方法是将代理的分数设置为 MAX_SCORE，即 100，也就是当代理有效时的设置。
• count() 方法返回当前集合的元素个数。
• all() 方法返回所有的代理列表，供检测使用。

定义好了这些方法，我们可以在后续的模块中调用此类来连接和操作数据库，非常方便。如我们想要获取随机可用的代理，只需要调用 random() 方法即可，得到的就是随机的可用代理。

获取模块

获取模块的逻辑相对简单，首先需要定义一个 Crawler 来从各大网站抓取代理，示例如下：

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

import json
from .utils import get_page
from pyquery import PyQuery as pq

class ProxyMetaclass(type):
    def __new__(cls, name, bases, attrs):
        count = 0
        attrs['__CrawlFunc__'] = []
        for k, v in attrs.items():
            if 'crawl_' in k:
                attrs['__CrawlFunc__'].append(k)
                count += 1
        attrs['__CrawlFuncCount__'] = count
        return type.__new__(cls, name, bases, attrs)

class Crawler(object, metaclass=ProxyMetaclass):
    def get_proxies(self, callback):
        proxies = []
        for proxy in eval("self.{}()".format(callback)):
            print('成功获取到代理', proxy)
            proxies.append(proxy)
        return proxies

    def crawl_daili66(self, page_count=4):
        """
        获取代理66
        :param page_count: 页码
        :return: 代理
        """
        start_url = 'http://www.66ip.cn/{}.html'
        urls = [start_url.format(page) for page in range(1, page_count + 1)]
        for url in urls:
            print('Crawling', url)
            html = get_page(url)
            if html:
                doc = pq(html)
                trs = doc('.containerbox table tr:gt(0)').items()
                for tr in trs:
                    ip = tr.find('td:nth-child(1)').text()
                    port = tr.find('td:nth-child(2)').text()
                    yield ':'.join([ip, port])

    def crawl_proxy360(self):
        """
        获取Proxy360
        :return: 代理
        """
        start_url = 'http://www.proxy360.cn/Region/China'
        print('Crawling', start_url)
        html = get_page(start_url)
        if html:
            doc = pq(html)
            lines = doc('div[name="list_proxy_ip"]').items()
            for line in lines:
                ip = line.find('.tbBottomLine:nth-child(1)').text()
                port = line.find('.tbBottomLine:nth-child(2)').text()
                yield ':'.join([ip, port])

    def crawl_goubanjia(self):
        """
        获取Goubanjia
        :return: 代理
        """
        start_url = 'http://www.goubanjia.com/free/gngn/index.shtml'
        html = get_page(start_url)
        if html:
            doc = pq(html)
            tds = doc('td.ip').items()
            for td in tds:
                td.find('p').remove()
                yield td.text().replace(' ', '')

为了实现灵活，在这里我们将获取代理的一个个方法统一定义一个规范，如统一定义以 crawl 开头，这样扩展的时候只需要添加 crawl 开头的方法即可。 在这里实现了几个示例，如抓取代理 66、Proxy360、Goubanjia 三个免费代理网站，这些方法都定义成了生成器，通过 yield 返回一个个代理。首先将网页获取，然后用 PyQuery 解析，解析出 IP 加端口的形式的代理然后返回。 然后定义了一个 get_proxies() 方法，将所有以 crawl 开头的方法调用一遍，获取每个方法返回的代理并组合成列表形式返回。 你可能会想知道是怎样获取了所有以 crawl 开头的方法名称的。其实这里借助于元类来实现，定义了一个 ProxyMetaclass，Crawl 类将它设置为元类，元类中实现了 new() 方法，这个方法有固定的几个参数，其中第四个参数 attrs 中包含了类的一些属性，这其中就包含了类中方法的一些信息，我们可以遍历 attrs 这个变量即可获取类的所有方法信息。所以在这里我们在 new() 方法中遍历了 attrs 的这个属性，就像遍历一个字典一样，键名对应的就是方法的名称，接下来判断其开头是否是 crawl，如果是，则将其加入到 CrawlFunc 属性中，这样我们就成功将所有以 crawl 开头的方法定义成了一个属性，就成功动态地获取到所有以 crawl 开头的方法列表了。 所以说，如果要做扩展的话，我们只需要添加一个以 crawl 开头的方法，例如抓取快代理，我们只需要在 Crawler 类中增加 crawl_kuaidaili() 方法，仿照其他的几个方法将其定义成生成器，抓取其网站的代理，然后通过 yield 返回代理即可，所以这样我们可以非常方便地扩展，而不用关心类其他部分的实现逻辑。 代理网站的添加非常灵活，不仅可以添加免费代理，也可以添加付费代理，一些付费代理的提取方式其实也类似，也是通过 Web 的形式获取，然后进行解析，解析方式可能更加简单，如解析纯文本或 Json，解析之后以同样的方式返回即可，在此不再添加，可以自行扩展。 既然定义了这个 Crawler 类，我们就要调用啊，所以在这里再定义一个 Getter 类，动态地调用所有以 crawl 开头的方法，然后获取抓取到的代理，将其加入到数据库存储起来。

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

from db import RedisClient
from crawler import Crawler

POOL_UPPER_THRESHOLD = 10000

class Getter():
    def __init__(self):
        self.redis = RedisClient()
        self.crawler = Crawler()

    def is_over_threshold(self):
        """
        判断是否达到了代理池限制
        """
        if self.redis.count() >= POOL_UPPER_THRESHOLD:
            return True
        else:
            return False

    def run(self):
        print('获取器开始执行')
        if not self.is_over_threshold():
            for callback_label in range(self.crawler.__CrawlFuncCount__):
                callback = self.crawler.__CrawlFunc__[callback_label]
                proxies = self.crawler.get_proxies(callback)
                for proxy in proxies:
                    self.redis.add(proxy)

Getter 类就是获取器类，这其中定义了一个变量 POOL_UPPER_THRESHOLD 表示代理池的最大数量，这个数量可以灵活配置，然后定义了 is_over_threshold() 方法判断代理池是否已经达到了容量阈值，它就是调用了 RedisClient 的 count() 方法获取代理的数量，然后加以判断，如果数量达到阈值则返回 True，否则 False。如果不想加这个限制可以将此方法永久返回 True。 接下来定义了 run() 方法，首先判断了代理池是否达到阈值，然后在这里就调用了 Crawler 类的 CrawlFunc 属性，获取到所有以 crawl 开头的方法列表，依次通过 get_proxies() 方法调用，得到各个方法抓取到的代理，然后再利用 RedisClient 的 add() 方法加入数据库，这样获取模块的工作就完成了。

检测模块

在获取模块中，我们已经成功将各个网站的代理获取下来了，然后就需要一个检测模块来对所有的代理进行一轮轮的检测，检测可用就设置为 100，不可用就分数减 1，这样就可以实时改变每个代理的可用情况，在获取有效代理的时候只需要获取分数高的代理即可。 由于代理的数量非常多，为了提高代理的检测效率，我们在这里使用异步请求库 Aiohttp 来进行检测。 Requests 作为一个同步请求库，我们在发出一个请求之后需要等待网页加载完成之后才能继续执行程序。也就是这个过程会阻塞在等待响应这个过程，如果服务器响应非常慢，比如一个请求等待十几秒，那么我们使用 Requests 完成一个请求就会需要十几秒的时间，中间其实就是一个等待响应的过程，程序也不会继续往下执行，而这十几秒的时间其实完全可以去做其他的事情，比如调度其他的请求或者进行网页解析等等。 异步请求库就解决了这个问题，它类似 JavaScript 中的回调，意思是说在请求发出之后，程序可以继续接下去执行去做其他的事情，当响应到达时，会通知程序再去处理这个响应，这样程序就没有被阻塞，充分把时间和资源利用起来，大大提高效率。 对于响应速度比较快的网站，可能 Requests 同步请求和 Aiohttp 异步请求的效果差距没那么大，可对于检测代理这种事情，一般是需要十多秒甚至几十秒的时间，这时候使用 Aiohttp 异步请求库的优势就大大体现出来了，效率可能会提高几十倍不止。 所以在这里我们的代理检测使用异步请求库 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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

VALID_STATUS_CODES = [200]
TEST_URL = 'http://www.baidu.com'
BATCH_TEST_SIZE = 100

class Tester(object):
    def __init__(self):
        self.redis = RedisClient()

    async def test_single_proxy(self, proxy):
        """
        测试单个代理
        :param proxy: 单个代理
        :return: None
        """
        conn = aiohttp.TCPConnector(verify_ssl=False)
        async with aiohttp.ClientSession(connector=conn) as session:
            try:
                if isinstance(proxy, bytes):
                    proxy = proxy.decode('utf-8')
                real_proxy = 'http://' + proxy
                print('正在测试', proxy)
                async with session.get(TEST_URL, proxy=real_proxy, timeout=15) as response:
                    if response.status in VALID_STATUS_CODES:
                        self.redis.max(proxy)
                        print('代理可用', proxy)
                    else:
                        self.redis.decrease(proxy)
                        print('请求响应码不合法', proxy)
            except (ClientError, ClientConnectorError, TimeoutError, AttributeError):
                self.redis.decrease(proxy)
                print('代理请求失败', proxy)

    def run(self):
        """
        测试主函数
        :return: None
        """
        print('测试器开始运行')
        try:
            proxies = self.redis.all()
            loop = asyncio.get_event_loop()
            # 批量测试
            for i in range(0, len(proxies), BATCH_TEST_SIZE):
                test_proxies = proxies[i:i + BATCH_TEST_SIZE]
                tasks = [self.test_single_proxy(proxy) for proxy in test_proxies]
                loop.run_until_complete(asyncio.wait(tasks))
                time.sleep(5)
        except Exception as e:
            print('测试器发生错误', e.args)

在这里定义了一个类 Tester，init() 方法中建立了一个 RedisClient 对象，供类中其他方法使用。接下来定义了一个 test_single_proxy() 方法，用来检测单个代理的可用情况，其参数就是被检测的代理，注意这个方法前面加了 async 关键词，代表这个方法是异步的，方法内部首先创建了 Aiohttp 的 ClientSession 对象，此对象类似于 Requests 的 Session 对象，可以直接调用该对象的 get() 方法来访问页面，在这里代理的设置方式是通过 proxy 参数传递给 get() 方法，请求方法前面也需要加上 async 关键词标明是异步请求，这也是 Aiohttp 使用时的常见写法。 测试的链接在这里定义常量为 TEST_URL，如果针对某个网站有抓取需求，建议将 TEST_URL 设置为目标网站的地址，因为在抓取的过程中，可能代理本身是可用的，但是该代理的 IP 已经被目标网站封掉了。例如，如要抓取知乎，可能其中某些代理是可以正常使用，比如访问百度等页面是完全没有问题的，但是可能对知乎来说可能就被封了，所以可以将 TEST_URL 设置为知乎的某个页面的链接，当请求失败时，当代理被封时，分数自然会减下来，就不会被取到了。 如果想做一个通用的代理池，则不需要专门设置 TEST_URL，可以设置为一个不会封 IP 的网站，也可以设置为百度这类响应稳定的网站。 另外我们还定义了 VALID_STATUS_CODES 变量，是一个列表形式，包含了正常的状态码，如可以定义成 [200]，当然对于某些检测目标网站可能会出现其他的状态码也是正常的，可以自行配置。 获取 Response 后需要判断响应的状态，如果状态码在 VALID_STATUS_CODES 这个列表里，则代表代理可用，调用 RedisClient 的 max() 方法将代理分数设为 100，否则调用 decrease() 方法将代理分数减 1，如果出现异常也同样将代理分数减 1。 另外在测试的时候设置了批量测试的最大值 BATCH_TEST_SIZE 为 100，也就是一批测试最多测试 100 个，这可以避免当代理池过大时全部测试导致内存开销过大的问题。 随后在 run() 方法里面获取了所有的代理列表，使用 Aiohttp 分配任务，启动运行，这样就可以进行异步检测了，写法可以参考 Aiohttp 的官方示例：http://aiohttp.readthedocs.io/。 这样测试模块的逻辑就完成了。

接口模块

通过上述三个模块我们已经可以做到代理的获取、检测和更新了，数据库中就会以有序集合的形式存储各个代理还有对应的分数，分数 100 代表可用，分数越小代表越不可用。 但是我们怎样来方便地获取可用代理呢？用 RedisClient 类来直接连接 Redis 然后调用 random() 方法获取当然没问题，这样做效率很高，但是有这么几个弊端：

• 需要知道 Redis 的用户名和密码，如果这个代理池是给其他人使用的就需要告诉他连接的用户名和密码信息，这样是很不安全的。
• 代理池如果想持续运行需要部署在远程服务器上运行，如果远程服务器的 Redis 是只允许本地连接的，那么就没有办法远程直连 Redis 获取代理了。
• 如果爬虫所在的主机没有连接 Redis 的模块，或者爬虫不是由 Python 语言编写的，那么就无法使用 RedisClient 来获取代理了。
• 如果 RedisClient 类或者数据库结构有更新，那么在爬虫端还需要去同步这些更新。

综上考虑，为了使得代理池可以作为一个独立服务运行，我们最好增加一个接口模块，以 Web API 的形式暴露可用代理。 这样获取代理只需要请求一下接口即可，以上的几个缺点弊端可以解决。 我们在这里使用一个比较轻量级的库 Flask 来实现这个接口模块，实现示例如下：

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

from flask import Flask, g
from db import RedisClient

__all__ = ['app']
app = Flask(__name__)

def get_conn():
    if not hasattr(g, 'redis'):
        g.redis = RedisClient()
    return g.redis

@app.route('/')
def index():
    return '<h2>Welcome to Proxy Pool System</h2>'

@app.route('/random')
def get_proxy():
    """
    获取随机可用代理
    :return: 随机代理
    """
    conn = get_conn()
    return conn.random()

@app.route('/count')
def get_counts():
    """
    获取代理池总量
    :return: 代理池总量
    """
    conn = get_conn()
    return str(conn.count())

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

在这里我们声明了一个 Flask 对象，定义了三个接口，分别是首页、随机代理页、获取数量页。 运行之后 Flask 会启动一个 Web 服务，我们只需要访问对应的接口即可获取到可用代理。

调度模块

这个模块其实就是调用以上所定义的三个模块，将以上三个模块通过多进程的形式运行起来，示例如下：

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

TESTER_CYCLE = 20
GETTER_CYCLE = 20
TESTER_ENABLED = True
GETTER_ENABLED = True
API_ENABLED = True

from multiprocessing import Process
from api import app
from getter import Getter
from tester import Tester

class Scheduler():
    def schedule_tester(self, cycle=TESTER_CYCLE):
        """
        定时测试代理
        """
        tester = Tester()
        while True:
            print('测试器开始运行')
            tester.run()
            time.sleep(cycle)

    def schedule_getter(self, cycle=GETTER_CYCLE):
        """
        定时获取代理
        """
        getter = Getter()
        while True:
            print('开始抓取代理')
            getter.run()
            time.sleep(cycle)

    def schedule_api(self):
        """
        开启API
        """
        app.run(API_HOST, API_PORT)

    def run(self):
        print('代理池开始运行')
        if TESTER_ENABLED:
            tester_process = Process(target=self.schedule_tester)
            tester_process.start()

        if GETTER_ENABLED:
            getter_process = Process(target=self.schedule_getter)
            getter_process.start()

        if API_ENABLED:
            api_process = Process(target=self.schedule_api)
            api_process.start()