算法设计评价基本标准

算法是对特定问题求解步骤的一种描述，如果将问题看作函数，那么算法是吧输入转化为输出

算法:

是对特定问题求解步骤的一种描述，是为了解决一个或者一类问题给出的一个确定的、有限长的操作序列。算法的设计依赖于数据的存储结构，因此对确定的问题，应该需求子啊适宜的存储结构上设计出一种效率较高的算法

算法的重要特性：

有穷性：

对于任何一组合法的输入值，在执行有穷步骤之后一定能结束，即算法中的操作步骤为有限个，并且每个步骤都能在有限的时间内完成

确定性：

对于每种情况下所应该执行的路径的操作，在算法中都有确切的规定，使算法的执行者或阅读者都能明确其含义及如何执行；并且在确切的条件下只有唯一一条执行流程路径

可行性：

算法中的所有操作都必须足够基本，都可以通过已经实现的基本运算执行有限次实现

有输入:

作为算法加工对象的量值，通常体现为算法中的一组变量。有些输入量需要在算法的执行过程中输入，而有些算法表面上没有输入，但实际上已被嵌入算法之中

有输出：

它是一组与“输入”有确定关系的量值，是算法进行信息加工够得到的结果。这种确定关系即为算法的功能

算法设计目标：

正确性：

算法应满足具体问题的需求，正确反映求解问题对输入、输出加工处理等方面的需求

程序中不含语法错误，计算的结果却不能满足规格说明要求。
程序对于特定的几组输入数据能够得出满足要求的结果，而对于其他的输入数据的不出正确的计算结果；
程序对于精心选择的、经典、苛刻且带有刁难性的几组输入数据能够得到满足需求的结果；（正确的算法）
程序对于一切合法的输入数据都能得出满足要求的结果

可读性：

算法处理用于编写程序子啊计算机上执行之外，另一个重要用处是阅读和交流。 算法中加入适当的注释，介绍算法的设计思路、各个模块的功能等一些必要性的说明文字来帮助读者理解算法。 要求: 算法中加入适当的注释，介绍算法的设计思路、各个模块的功能等一些必要性的说明文字来帮助读者理解算法对算法中出现的各种自定义变量和类型能做到“见名知义”，即读者一看到某个变量（或类型名）就能知道其功能

健壮性：

当输入数据非法时，算法能够适当地做出反应或进行处理，输出表示错误性质的信息并终止执行，而不会产生莫名其妙的输出结果。

时间效率与存储占用量：

一般来说，求解同一个问题若有多种算法，则执行时间短的算法效率高占用存储空间少的算法较好算法的执行时间开销和存储空间开销往往相互制约，对高时间效率和低存储占用的要求只能根据问题的性质折中处理

算法复杂度

算法的时间复杂度：

算法的效率指的是算法的执行时间随问题“规模”（通常用整型量 n 表示）的增长而增长的趋势 “规模”在此指的是输入量的数目，比如在排序问题中，问题的规模可以是被排序的元素数目假如随着问题规模 n 的增长，算法执行时间的增长率和问题规模的增长率相同则可记为： T（n） = O（f(n)）

f(n) 为问题规模 n 的某个函数； T（n）被称为算法的（渐进）时间复杂度（Time Complexity） O 表示法不需要给出运行时间的精确值；选择 f（n），通常选择比较简单的函数形式，并忽略低次项和系数常用的有 O（1）、O（logn）、O（n）、O（nlogn）、O（n*n）等等多项式时间复杂度的关系为： O(1) < O(logn) < O(n) < O(N logn) < O(n²) < O(n³) 指数时间算法的关系为： O（2(n 方)）< O(n!) <O(n(n 方))

由于估算算法时间复杂度关心的只是算法执行时间的增长率而不是绝对时间，因此可以忽略一些因素。方法：从算法中选取一种对于所研究的问题来说是“基本操作”的原操作，以该“基本操作”在算法中重复执行的次数作为算法时间复杂度的依据。 EG：

两个 n x n 的矩阵相乘，求其时间复杂度
1
2
for i in range(10):
      for j in range(10):
问题规模是矩阵的阶 n,算法的控制结构式三重循环，基本操作是乘法操作乘法执行次数为 n³，则算法的时间复杂度为 O(n³)

算法的空间复杂度：

算法在执行期间所需要的存储量包括：

程序代码所占用空间
输入数据所占用空间
辅助变量所占用的空间

为了降低复杂度，一个直观的思路是：梳理程序，看其流程中是否有无效的计算或者无效的存储。我们需要从时间复杂度和空间复杂度两个维度来考虑。常用的降低时间复杂度的方法有递归、二分法、排序算法、动态规划等，降低空间复杂度的方法，就要围绕数据结构做文章了。降低空间复杂度的核心思路就是，能用低复杂度的数据结构能解决问题，就千万不要用高复杂度的数据结构。

如何评定一个程序算法的好坏？

简而言之：在符合算法设计标准的前提下，运行的更快、所用计算资源更少。即是更好的算法

请注意这里的比较级别词更！！！，对于算法，个人认为就是获得同一结果的同时探究最优解决之道

探究算法优化（自我一点点小体悟-个人能力有限）

抽象化：将不必要的计算过程去掉

利用高斯算法解决累计求和问题

慎选各数据结构，善用第三方算法

去重：善用迭代什么的等等使用字典的特性-不可重复性布隆过滤器去重（源于哈希算法）

时空转换：将昂贵的时间转化为廉价的空间

当‘优无可优时’,取贵舍廉空间是可以用钱买的，加个什么内存啊，加个处理器等等什么的时间是逝去就不在了

以上仅仅个人的一点点小灵感，望大家不喜勿喷

说了这么多，来道简单的算法题目导入（同一计算机，i5, python）需求如下：累计求和 1-n 的值(1. 为防止误差，验证 10 次; 2. 验证每次计算次数)

# 在同一空间复杂下(也就是说没有迭代，探究暴力解法与高斯算法)
# n = 100000
# Method one 代码如下
def func(n):
    start = time.time()
    count = 0
    theSum = 0
    for i in range(n + 1):
        theSum = theSum + n
        count += 1
    end = time.time()
    return theSum, end - start, count

for i in range(10):
    print(f"Sum is %d Required %10.10f seconds count = %d" % func(10000))
# %10.10f 表示取10位小数，运行结果如下

Sum is 100010000 Required 0.0010061264 seconds count = 10001 Sum is 100010000 Required 0.0009891987 seconds count = 10001 Sum is 100010000 Required 0.0000000000 seconds count = 10001 Sum is 100010000 Required 0.0010235310 seconds count = 10001 Sum is 100010000 Required 0.0009710789 seconds count = 10001 Sum is 100010000 Required 0.0000000000 seconds count = 10001 Sum is 100010000 Required 0.0009973049 seconds count = 10001 Sum is 100010000 Required 0.0010013580 seconds count = 10001 Sum is 100010000 Required 0.0000000000 seconds count = 10001 Sum is 100010000 Required 0.0019786358 seconds count = 10001 探究可知：n 扩大 10 倍，运算时间也会扩大 10 倍高斯算法，从 1 累加至 n,等于(首项+尾项)项数/2 直接引用结论: 1+2+3+…+(n-1) +n={（1+n）+（2+（n-1））…}/2 = （n （n + 1））/2

# Gaussian算法，无迭代算法
def fun1(n):
    start = int(time.time())
    theSum = (n * (n + 1)) / 2
    end = int(time.time())
    return theSum, end - start, n / 2

for i in range(1000000):
    print(f"Sum is %d Required %10.100f seconds count = %d" % fun1(50**100))

计算结果如下： 循环计算 10000 次，出去 I/O 所需时间几乎可以不计。 Sum is 49999999999999998486656110625518082973725163772751181324120875475173424217777037767098169202353125934013756207986941204091067867184139242319692520523619938935511795533394990905590906653083564427444224 Required 0.0000000000000000000000000000000000000000000000000123123000000000000000000000000000000000000000000000 seconds count = 5000000000000000079514455548799590234180404281972640694890663778873919386085190530406734992928407552 Sum is 49999999999999998486656110625518082973725163772751181324120875475173424217777037767098169202353125934013756207986941204091067867184139242319692520523619938935511795533394990905590906653083564427444224 Required 0.000000000000000000000000000000000000000000000000012332100000000000000000000000000000000000000000000 seconds count = 5000000000000000079514455548799590234180404281972640694890663778873919386085190530406734992928407552 Sum is 49999999999999998486656110625518082973725163772751181324120875475173424217777037767098169202353125934013756207986941204091067867184139242319692520523619938935511795533394990905590906653083564427444224 Required 0.00000000000000000000000000000000000000000000000000000002310000000000000000000000000000000000000 seconds count = 5000000000000000079514455548799590234180404281972640694890663778873919386085190530406734992928407552 Sum is 49999999999999998486656110625518082973725163772751181324120875475173424217777037767098169202353125934013756207986941204091067867184139242319692520523619938935511795533394990905590906653083564427444224 Required 0.000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000 seconds count = 5000000000000000079514455548799590234180404281972640694890663778873919386085190530406734992928407552 Sum is 49999999999999998486656110625518082973725163772751181324120875475173424217777037767098169202353125934013756207986941204091067867184139242319692520523619938935511795533394990905590906653083564427444224 Required 0.000000000000000000000000000000000000000000000000000000010032000000000000000000000000000000000000 seconds count = 5000000000000000079514455548799590234180404281972640694890663778873919386085190530406734992928407552 Sum is 49999999999999998486656110625518082973725163772751181324120875475173424217777037767098169202353125934013756207986941204091067867184139242319692520523619938935511795533394990905590906653083564427444224 Required 0.0000000000000000000000000000000000000000000000012231300000000000000000000000000000000000000000000 seconds count = 5000000000000000079514455548799590234180404281972640694890663778873919386085190530406734992928407552 Sum is 49999999999999998486656110625518082973725163772751181324120875475173424217777037767098169202353125934013756207986941204091067867184139242319692520523619938935511795533394990905590906653083564427444224 Required 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 seconds count = 5000000000000000079514455548799590234180404281972640694890663778873919386085190530406734992928407552 Sum is 49999999999999998486656110625518082973725163772751181324120875475173424217777037767098169202353125934013756207986941204091067867184139242319692520523619938935511795533394990905590906653083564427444224 Required 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 seconds count = 5000000000000000079514455548799590234180404281972640694890663778873919386085190530406734992928407552 Sum is 49999999999999998486656110625518082973725163772751181324120875475173424217777037767098169202353125934013756207986941204091067867184139242319692520523619938935511795533394990905590906653083564427444224 Required 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 seconds count = 5000000000000000079514455548799590234180404281972640694890663778873919386085190530406734992928407552 Sum is 49999999999999998486656110625518082973725163772751181324120875475173424217777037767098169202353125934013756207986941204091067867184139242319692520523619938935511795533394990905590906653083564427444224 Required 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 seconds count = 5000000000000000079514455548799590234180404281972640694890663778873919386085190530406734992928407552

作者 Payne 发表于 2020-07-14 阅读次数：本文字数： 7.7k 阅读时长 ≈ 7 分钟

网络爬虫工程师面试小笔记

————小企业，7K至10k版，面试总结。Payne

面试题之一：Python单例模式

什么是Python的单例模式？

单例模式（Singleton Pattern）是一种常用的软件设计模式，该模式主要目的是确保某一个类只有一个实例存在。当希望在整个系统中，某个类只能出现一个实例时，单例对象就派上用场了。面向对象编程单例模式，保证了在程序运行中该类只实例化一次，并提供了一个全局访问点 Python的模块就是天然的单例模式当模块在第一次导入时，就会生成 .pyc 文件当第二次导入时就会直接先加载 .pyc 文件，而不会再次执行模块代码。我们只需把相关函数和数据定义在一个模块中，就可以获得一个单例对象。

如何实现单例模式？

1.基于类：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Singleton(object):
    # def __new__(slef):类方法
        # pass 
        # 当我们没写时默认调用object__new__方法

    # 然后在执行类的实例化对象：__init__
  def __init__(self): # 实例方法
        pass

    @classmethod
    def instance(cls, *args,**kwargs):
        if not has attr(Singleton,"_instance"):
            Singleton._instance = Singleton(*args,**kwargs)
        return Singleton._intance
此时是以完成了一个简单的单例模式案例，But实际开发中随时凉凉举例说明：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Singleton(object):

    def __init__(self):
        pass

    @classmethod
    def instance(cls, *args, **kwargs):
        if not hasattr(Singleton, "_instance"):
            Singleton._instance = Singleton(*args, **kwargs)
        return Singleton._instance

import threading

def task(arg):
    obj = Singleton.instance()
    print(obj)

for i in range(10):
    t = threading.Thread(target=task,args=[i,])
    t.start()
当然此时也并没有什么问题，BUT在’ init ‘方法中加入I/O（input/output）操作就凉凉了问题出现了，按照以上方式创建的单例无法支持多线程 缘由：Python中实例化对象与初始化对象是分开执行的，又由于多线程之间是通信共享的，故出现线程安全问题。主要体现为，create一个之后kill一个，create一个又被kill一个。所以就。。。解决思路一：相互独立，分而治之。加锁独立也就是咱们所了解、知道的线程锁的概念，使得其无序变为相对有序。具体代码便不在此赘述在看看思路一(相互独立，分而治之。加锁独立) 解决思路二：‘反’实例化，加锁保护独立，确保通用性在Python3中，调用父类方法是为super()，那么是否可以增加判断：当类属性不为空时，我们便不在实例化且返回一个已实例化的类属性。这样还是不太完美，带有局限性。进一步加锁保护优化以保障多线程情况下只有一个线程同时访问。这样就保障了单例的安全 基于 new 方法实现！！！
1
2
在回到基于类的第一个代码块，并详细查看其注释。
实例化一个对象是先执行了类的__new__方法（若未写执行object.__new__），实例化对象；然后子啊执行类的__init__方法，对这个对象进行初始化。基于此实现单例。
基于装饰器

使用装饰器实现，实例如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def Singleton(cls):
    _instance = {}

    def _singleton(*args, **kargs):
        if cls not in _instance:
            _instance[cls] = cls(*args, **kargs)
        return _instance[cls]

    return _singleton

@Singleton
class A(object):
    a = 1

    def __init__(self, x=0):
        self.x = x

a1 = A(2)
a2 = A(3)
使用模块的方法

书写代码(并保存在Singleton.py中)：
1
2
3
4
class Singleton(object):
  def func(self):
        pass
singleton = Sinleton()
// from * import singleton 需使用时，直接在其他文件中导入此文件中的对象，那么这个对象即是单例模式对象还有个基于元类的就没书写了具体请看：https://blog.csdn.net/weixin_44239343/article/details/89376796

面试题之二：Redis有几种数据类型？

如果是单单是Redis那么常用数据类型为五种 他们分别是：String，List，hash，set，zset String：字符串，一个字符串Value最多可以是512M Hash：哈希，是一个String类型的field和Value的映射表 List：列表，时间是链表 Set：集合是一个String类型无序无重复集合，其通过Hash Table实现 Zset（sorted）：有序集合那么应聘时，请注意这个小坑，你Python使用Redis又几种数据类型? 这个是基于语言来回答的，所用语言+Redis数据类型杂糅 Number,String，list，tuple（这个不确定），dict，aggregate 同时又涉语言所拥有的数据类型与redis，一样的就‘合二为一’嘛以Python为例，稍后继续探究这（6+5）之间的杂糅，dict与aggregate其二者区别为主（其实我也不晓得更深的了）。以及1对1，1对多，多对1。数据结构搞起来，然后哼哼~。

面试题之三：Scrapy框架的运行流程及各模块的作用

如果简历里面写了分布式会拓展scrapy-Redis架构以及其作用。 CAP理论，估计会扯到数据这块。拓展database什么特性啊，之类的。谈优化，谈数据结构。反正数据结构与算法这块，基于此，难于此，也凉于此

面试题之四：scrapy去重所用的几种机制

谨记：先从scrapy本身的去重原理及机制说起来，最基础，优缺点，去重原理等等。一步步来，一上来就BloonFilter，风险不小啊对于此，自我总结如下：

1、scrapy 基于内存
1
2
3
4
5
scrapy源码中可以找到一个dupefilters.py去重器;

需要将dont_filter设置为False开启去重，默认是True，没有开启去重；

对于每一个url的请求，调度器都会根据请求得相关信息加密得到一个指纹信息，并且将指纹信息和set()集合中的指纹信息进 行 比对，如果set()集合中已经存在这个数据，就不在将这个Request放入队列中;
2、redis 基于内存更加快捷、速度快、易于管理
1
不说了，前面是叩门砖，Redis就是决胜之地，没啥可讲的，会的基本都会，不会的我也不会，在深挖其原理数据结构，估计得喝上一点，也怕自己一不小心怕给扯飞了
3、布隆过滤器大可能存在拥有一定的错误率
1
加分项，是满分还是SSS+。
对于此面试个人总结如下： 源于基础，死于基础（数据结构及类型，以及算法）知识点：点串线，线成面。自己也还有很长一段路走，加油，加油~

作者 Payne 发表于 2020-07-07 阅读次数：本文字数： 3.1k 阅读时长 ≈ 3 分钟

技术杂谈 发布一个智能解析框架 Gerapy Auto Extractor

之前我写过几篇文章介绍过有关爬虫的智能解析算法，包括商业化应用 Diffbot、Readability、Newspaper 这些库，另外我有一位朋友之前还专门针对新闻正文的提取算法 GeneralNewsExtractor，这段时间我也参考和研究了一下这些库的算法，同时参考一些论文，也写了一个智能解析库，在这里就做一个非正式的介绍。

引入

那首先说说我想做的是什么。比如这里有一个网站，网易新闻，https://news.163.com/rank/，这里有个新闻列表，预览图如下：任意点开一篇新闻，看到的结果如下：我现在需要做到的是在不编写任何 XPath、Selector 的情况下实现下面信息的提取：对于列表页来说，我要提取新闻的所有标题列表和对应的链接，它们就是图中的红色区域：这里红色区域分了多个区块，比如这里一共就是 40 个链接，我都需要提取出来，包括标题的名称，标题的 URL。我们看到页面里面还有很多无用的链接，如上图绿色区域，包括分类、内部导航等，这些需要排除掉。对于详情页，我主要关心的内容有标题、发布时间、正文内容，它们就是图中红色区域：其中这里也带有一些干扰项，比如绿色区域的侧边栏的内容，无用的分享链接等。总之，我想实现某种算法，实现如上两大部分的智能化提取。

框架

之前我开发了一个叫做 Gerapy https://github.com/Gerapy/Gerapy 的框架，是一个基于 Scrapy、Scrapyd 的分布式爬虫管理框架，属 1.x 版本。现在正在开发 Gerapy 2.x 版本，其定位转向了 Scrapy 的可视化配置和调试、智能化解析方向，放弃支持 Scraypd，转而支持 Docker、Kubernetes 的部署和监控。对于智能解析来说，就像刚才说的，我期望的就是上述的功能，在不编写任何 XPath 和 Selector 的情况下实现页面关键内容的提取。框架现在发布了第一个初步版本，名称叫做 Gerapy Auto Extractor，名字 Gerapy 相关，也会作为 Gerapy 的其中一个模块。 GitHub 链接：https://github.com/Gerapy/GerapyAutoExtractor 现在已经发布了 PyPi，https://pypi.org/project/gerapy-auto-extractor/，可以使用 pip3 来安装，安装方式如下：

1	pip3 install gerapy-auto-extractor

安装完了之后我们就可以导入使用了。

功能

下面简单介绍下它的功能，它能够做到列表页和详情页的解析。列表页：

标题内容
标题链接

详情页：

标题
正文
发布时间

先暂时实现了如上内容的提取，其他字段的提取暂时还未实现。

使用

要使用 Gerapy Auto Extractor，前提我们必须要先获得 HTML 代码，注意这个 HTML 代码是我们在浏览器里面看到的内容，是整个页面渲染完成之后的代码。在某些情况下如果我们简单用「查看源代码」或 requests 请求获取到的源码并不是真正渲染完成后的 HTML 代码。要获取完整 HTML 代码可以在浏览器开发者工具，打开 Elements 选项卡，然后复制你所看到的 HTML 内容即可。先测试下列表页，比如我把 https://news.163.com/rank/ 这个保存为 list.html，然后编写提取代码如下：

import json
from gerapy_auto_extractor.extractors.list import extract_list

html = open('list.html', encoding='utf-8').read()
print(json.dumps(extract_list(html), indent=2, ensure_ascii=False, default=str))

就是这么简单，核心代码就一行，就是调用了一个 extract_list 方法。运行结果如下：

[
  {
    "title": "1家6口5年"结离婚"10次:儿媳"嫁"公公岳",
    "url": "https://news.163.com/20/0705/05/FGOFE1HJ0001875P.html"
  },
  {
    "title": ""港独"议员泼水阻碍教科书议题林郑月娥深夜斥责",
    "url": "https://news.163.com/20/0705/02/FGO66FU90001899O.html"
  },
  {
    "title": "感动中国致敬留德女学生:街头怒怼"港独"有理有",
    "url": "https://news.163.com/20/0705/08/FGOPG3AM0001899O.html"
  },
  {
    "title": "香港名医讽刺港警流血少过月经受访时辩称遭盗号",
    "url": "https://news.163.com/20/0705/01/FGO42EK90001875O.html"
  },
  {
    "title": "李晨独居北京复式豪宅没想到肌肉男喜欢小花椅子",
    "url": "https://home.163.com/20/0705/07/FGOLER1200108GL2.html"
  },
  {
    "title": "不战东京!林丹官宣退役正式结束20年职业生涯",
    "url": "https://sports.163.com/20/0704/12/FGML920300058782.html"
  },
  {
    "title": "香港美女搬运工月薪1.6万每月花6千租5平出租",
    "url": "https://home.163.com/20/0705/07/FGOLEL1100108GL2.html"
  },
  {
    "title": "杭州第一大P2P"凉了":近百亿未还!被警方立案",
    "url": "https://money.163.com/20/0705/07/FGON5T7B00259DLP.html"
  },
  ...
]

可以看到想要的内容就提取出来了，结果是一个列表，包含标题内容和标题链接两个字段，由于内容过长，这里就省略了一部分。接着我们再测试下正文的提取，随便打开一篇文章，比如 https://news.ifeng.com/c/7xrdz0kysde，保存下 HTML，命名为 detail.html。编写测试代码如下：

import json
from gerapy_auto_extractor.extractors import extract_detail
html = open('detail.html', encoding='utf-8').read()
print(json.dumps(extract_detail(html), indent=2, ensure_ascii=False, default=str))

运行结果如下：

{
  "title": "内蒙古巴彦淖尔发布鼠疫疫情Ⅲ级预警",
  "datetime": "2020-07-05 18:54:15",
  "content": "2020年7月4日，乌拉特中旗人民医院报告了1例疑似腺鼠疫病例，根据《内蒙古自治区鼠疫疫情预警实施方案》（内鼠防应急发﹝2020﹞7号）和《自治区鼠疫控制应急预案（2020年版）》（内政办发﹝2020﹞17号）的要求，经研究决定，于7月5日发布鼠疫防控Ⅲ级预警信息如下：n一、预警级别及起始时间n预警级别：Ⅲ级。n2020年7月5日起进入预警期，预警时间从本预警通告发布之日持续到2020年底。n二、注意事项n当前我市存在人间鼠疫疫情传播的风险，请广大公众严格按照鼠疫防控“三不三报”的要求，切实做好个人防护，提高自我防护意识和能力。不私自捕猎疫源动物、不剥食疫源动物、不私自携带疫源动物及其产品出疫区；发现病（死）旱獭及其他动物要报告、发现疑似鼠疫病人要报告、发现不明原因的高热病人和急死病人要报告。要谨慎进入鼠疫疫源地，如有鼠疫疫源地的旅居史，出现发热等不适症状时及时赴定点医院就诊。n按照国家、自治区鼠疫控制应急预案的要求，市卫生健康委将根据鼠疫疫情预警的分级，及时发布和调整预警信息。n巴彦淖尔市卫生健康委员会n2020年7月5日n来源：巴彦淖尔市卫生健康委员会"
}

成功输出了标题、正文、发布时间等内容。这里就演示了基本的列表页、详情页的提取操作。

算法

整个算法的实现比较杂，我看了几篇论文和几个项目的源码，然后经过一些修改实现的。其中列表页解析的参考论文：

详情页解析的参考论文和项目：

这些都是不完全参考，然后加上自己的一些修改最终才形成了现在的结果。算法在这里就几句话描述一下思路，暂时先不展开讲了。列表页解析：

找到具有公共父节点的连续相邻子节点，父节点作为候选节点。
根据节点特征进行聚类融合，将符合条件的父节点融合在一起。
根据节点的特征、文本密度、视觉信息（尚未实现）挑选最优父节点。
从最优父节点内根据标题特征提取标题。

详情页解析：

标题根据 meta、title、h 节点综合提取
时间根据 meta、正则信息综合提取
正文根据文本密度、符号密度、视觉信息（尚未实现）综合提取。

后面等完善了之后再详细介绍算法的具体实现，现在如感兴趣可以去看源码。

说明

本框架仅仅发布了最初测试版本，测试覆盖度比较少，目前仅仅测试了有限的几个网站，尚未大规模测试和添加对比实验，因此准确率现在还没有标准的保证。参考：关于详情页正文的提取我主要参考了 GeneralNewsExtractor 这个项目，原项目据测试可以达到 90% 以上的准确率。列表页我测试了腾讯、网易、知乎等都是可以顺利提取的，如： 19841593922229_.pic_hd 后面会有大规模测试和修正。项目初版，肯定存在很多不足，希望大家可以多发 Issue 和提 PR。另外这里建立了一个 Gerapy 开发交流群，之前在 QQ 群的也欢迎加入，以后交流就在微信群了，大家在使用过程遇到关于 Gerapy、Gerapy Auto Extractor 的问题欢迎交流。这里放一个临时二维码，后期可能会失效，失效后大家可以到公众号「进击的 Coder」获取加群方式。

待开发功能

视觉信息的融合
文本相似度的融合
分类模型的融合
下一页翻页的信息提取
正文图片、视频的提取
对接 Gerapy

最后感谢大家的支持！

作者崔庆才发表于 2020-07-05 阅读次数：本文字数： 4.3k 阅读时长 ≈ 4 分钟

技术杂谈 Mac 终端 Git Status 显示中文乱码

最近遇到 Mac 的 Git Status 显示中文乱码的问题，类似：

1	"\343\200\220\345\267\245\344\275\234\343\200\221\345\217\221\351\202\256\344\273\266\346\234\215\345\212\241.md"

解决方案：

1	git config --global core.quotepath false

完了之后就显示正常了。

作者崔庆才发表于 2020-07-04 阅读次数：本文字数： 197 阅读时长 ≈ 1 分钟

Other MySQL基本配置

主要亮点为配置和密码找回，安装什么的就。。。

MySQL 基本配置

官网地址：www.mysql.com 安装可参考：https://cuiqingcai.com/5200.html

window：

[gallery columns=”1” size=”full” ids=”9457”] 注意终端 mysqld 开启的不能关闭！

1 2	mysqld //启动服务 mysql //启动客户端

制作服务：

关闭进程

// 查找任务进程
tasklist |findstr mysqld
//终止任务进程
taskkill /F /PID PID

安装服务与移除服务

//安装服务
mysqld --install
//移除服务
mysqld --remove

Linux：

centos:
yum -y install mariadb-server mariadb
ubuntu:
yum -y install mysqld-server msyql-client

基本使用： // 查看所有的数据库 show databases； // 进入对应的库： use database（name）查看表: select * from db;

配置环境变量：

1	vim /etc/profile

在文档最后一行加入：

PATH = /。。。:$PATH
export PATH
保存退出即可
然后在终端输入
source /etc/profile //生效

管理员密码设置与找回：

管理员账号登录(没有密码，直接回车进入。)

1	mysql -uroot -p

设置管理员密码

1
2
3

mysqladmin -uroot -p {oldPassworld(原始密码，默认为“”,空)} password {“newpassoworld”};
mysqladmin -uroot -p  password {“passoworld”};
# passoworld为你锁需要设置的密码哦

MySQL 密码找回：

密码验证思路：mysql 必定将管理员账号密码存储在某个文件夹内，使用时与输入密码验证，成功则能够连接，否则连接失败。密码找回思路：跳过 MySQL 密码的验证直接进入

停止 mysql 服务（注：需要终端的管理员权限运行）

// windows:

查询进程，并找到 PID：

tasklist | findsrt mysqld
1
2
3
4

                        
                        
                          2.  kill 掉 mysql 进程，否则是停止不了服务的，无论如何都需要 kill 掉：

![](https://cdn.cuiqingcai.com/wp-content/uploads/2020/06/change_password1.png)


                        
                        
                        
                        
 #此处的为上面查询到的PID，每次都是不一样的，所以就不写具体值了 taskkill /F /PID PID 
                          
                            
                              
                                1

                              
                              
                                

                              
                            
                          
                        
 net stop mysql 
                          
                            
                              
                                1
2
3
4

                              
                              
                                
// Linux/mac:命令不同，基本思路相同 systemctl stop mysql(centos 中默认的 mysql 是 mariadb，可将 mysql 替换成 mariadb 即可)

若安装了 mysqld(mysql 服务)需停止 MySQL 的进程服务 ，若没有安装 mysql 的服务则此步可省略 重新启动 mysql 服务，且跳过授权表 

                              
                            
                          
                        
 Windows： //启动不起来，可能需要net start mysql（这个是特殊情况） mysqld --skip-grant-tables //Linux/mac： mysqld ——safe --skip-grant-tables 
                          
                            
                              
                                1
2
3
4
5
6

                              
                              
                                
登录，重新修改密码

> // 登录(此时 MySQL 的 root 权限是没有密码的，直接回车即可进入) mysql -uroot -p // 修改密码（在连接数据库状态中）： update mysql.user set password=password("yourpassword") where user="uroot" and host="localhost"
>
>

                              
                            
                          
                        
 此语句是告诉数据库，更新密码。密码为yourpassword where 为限制条件 ，限制user为root，host为localhost MySQL的关于用户授权表是存放在mysql库user表中的 
                          
                            
                              
                                1
2
3

                              
                              
                                
刷新保存设置(这个一定需要，要不之前的功夫都白费了)：


                              
                            
                          
                        
 flush privileges; 
                          
                            
                              
                                1
2
3

                              
                              
                                
退出：


                              
                            
                          
                        
 q # 或者 exit 
                          
                            
                              
                                1
2
3
4
5
6
7
8
9

                              
                              
                                
重启启动 mysql 服务（终端中）： 安装了 MySQL 服务的：net start mysql 若没有安装则在 cmd 中 mysqld 启动一些，用另外的一个 cmd 连接即可

## 字符编码:

查看字符编码

登录进入 mysql 后


                              
                            
                          
                        
 \\s

进入 mysql 文件夹（这个可不设置，当然设置最好。）：字符编码配置默认文件：my-default.ini 新建后缀名为:’.ini‘的文件

[mysqld] character-set-server=utf8 collation-server=urf8_general_ci [client] default-character=utf8 [mysql] default-character=utf8 user =”root” password =”123456”

作者 Payne 发表于 2020-06-26 阅读次数：本文字数： 2.1k 阅读时长 ≈ 2 分钟

技术杂谈 把 Mac 终端上的标题去掉

我自己用 Mac 自带的终端很久了，感觉一直还不错。但美中不足的是终端上面的这个标题实在让人看着太糟心了，看图：上面这行标题，没什么用，又这么难看。我把偏好设置里面的显示内容都去掉了，设置如下：但是它总是还显示了一个标题，显示成这个样子：上面这个标题看得很难受，我想把它改成无任何内容，简洁清爽，如下图所示：但是现在无论我怎么改偏好设置都不行，总会带上那些信息。后来搜索了一番发现是 zsh 的问题。打开 ~/.zshrc 这个文件，找到下面这一行：

1	DISABLE_AUTO_TITLE="true"

把这行取消注释。另外偏好设置里面把所有的勾选都去掉，如图所示：另外注意这里标题处不能完全为空，需要打上一个空格，否则窗口上方会显示「终端」二字。最后在 ~/.zshrc 最后还可以加上这一行语句来清屏：

clear

这样就不会再显示 Last Login 等相关信息了。最后看下效果，打开终端就会显示如下样子，简洁清爽，舒服了。完毕。

作者崔庆才发表于 2020-05-28 阅读次数：本文字数： 406 阅读时长 ≈ 1 分钟

Other Git 学习日志之五——SSH配置

SSH 配置：

使用命令在 home 文件夹下新建一个 ssh 文件

配置 SSH 信息，命令：ssh-keygen -t rsa -C e-mail（此时的 C 必须是大写，Email 为绑定了 github 的邮箱），稍后一路回车选择默认值即可

查看 id_rsa.pub 信息，并将其复制到粘贴版中(稍后会用到！)

进入到 github 中点击右上角的头像，选择 setting ——> SSH and GPG keys ——> 将上述复制内容粘贴到编辑面板中——>完成

完成

作者 Payne 发表于 2020-05-24 阅读次数：本文字数： 217 阅读时长 ≈ 1 分钟

Other Git学习日志之四——远程库操作

远程库操作

创建远程库地址别名

git remote add [origin] [Warehouse URI] 创建别名为 origin，github 仓库地址为。。。的 git remote -v 查看相关信息

推送操作：

使用命令:

1	git push 别名(origin) 分支名(master)

注意是将本地库进行推送！！！（此时时事先完成了一些对本地库相关操作）

克隆操作：

git clone [URI]

首先复制相对应的仓库地址：

这里是克隆下来的结果显示

克隆的作用：
1. 完整的把远程库克隆下来
2. 创建 origin 远程地址别名
3. 初始化本地库
团队内协作
邀请成员加入仓库工作团队：

如果没有加入团队是没有权限向所相关的库进行推送的！！！如何设置（获得）权限呢？（在仓库中点击设置选项进入如下界面）

完成以上操作之后在进行推送即可有权限完成推送。

fetch and merge 操作（二者一起使用相当于 pull）

git remote -v

git fetch [远程库中简称(origin)] [远程库分支名(master)]

git merge [远程库中简称/远程库分支名(origin/master)]

fetch：

首先是查看了 remote
然后使用 git fetch 命令下载了远程库内容
查看本地库中的 project.txt 内容
切换到新下载的 master 目录（可使用 git reflog 查看分支状态）
查看远程库中 project.txt 内容

merge：将远程库下载的内容与本地库合并

1	git mergo origin/master

Pull 使用：

pull 冲突处理：

缘由：如果不是基于远程库的最新版本进行修改的
解决：不能推送，必须先拉，拉下来进入冲突状态，进行对内容的修改，删除不相关内容，重新处理即可。更详情请查看前面的 push 冲突解决。

团队外协作：

流程：具体的流程可以参考上面的流程图：首先是 fork 一个仓库，然后拉去请求后 clone 到本地，然后编辑更改。后推送到远程仓库（这里的克隆操作就省略了，具体的可以看上面）发送即可完成。然后接收者根据流程图步骤 6 开始操作即可

作者 Payne 发表于 2020-05-24 阅读次数：本文字数： 838 阅读时长 ≈ 1 分钟

Other Git学习日志之三-本地库操作

在编辑前首先介绍以下工作流程

本地库与远程库

团队内部协作：

跨团队协作：

添加提交以及查看状态

添加：将工作区的“新建/修改”添加到暂存区

1	git add [file name]

暂存区删除

1	git rm --cached [file name]

查看状态：查看工作区、暂存区状态

1	git status

提交：将暂存区的内容提交到本地库

1	git commit -m "commit message" [file name]

查看历史(日志)

git log：// 最完整的日志形式

// 多屏显示控制方式：空格向下翻页，b向上翻页，q 退出

git log --pretty=oneline：// 简洁的显示

git log --oneline   // 更简洁的显示

git reflog ：// HEAD@{移动到当前版本需要多少‘步数’}

实际操作

基本思路图：步骤如下：

使用 vim 命令新建一个名为 demo1.txt ，并查看状态。提示我们暂存区没有相关的文件，并标红警告

将新建的文件新增到暂存区：

将文件添加到本地库：
- 方式一：
- 方式二：git commit [file name] 不建议使用

当然直接 commit 也可以，不过。。。

版本前进与后退：(基于索引值对文件进行前进与后退操作)

Vim 多屏显示控制方式：

空格向下翻页
b 向上翻页
q 退出

查看操作日志：

1	git reflog ：// HEAD@{移动到当前版本需要多少‘步数’}

实际操作：查看 reflog

首先使用 vim 命令新建了一个名为 hard.txt，并在里面写入项目数据‘aaa、bbb’
使用 git add hard.txt 命令将 hard.txt 添加到暂存区
使用 git commit hard.txt 命令将 hard.txt 添加到本地库
使用命令 git reflog 查看相关的将要操作的参考

给‘项目’版本进行更新：

更新，并将其 commit 到本地库中

基本的已完成了，让我们来试试版本的前进与后退，并查看相对应的内容

git reflog

git reset —hard [索引值] //前进与后退索引命令

注意观察 cat hard.txt 的内容！！！

版本后退：

版本前进

基于符号的版本控制

// 基于^符号：只能进行版本后退
git reset --hard [file name]^ //回退一个版本
git reset --hard [file name]^^ //回退两个版本
// 基于~符号:
git reset --hard [file name]~n //回退n个版本

reset 命令参数对比：

-- soft

仅仅在本地库中移动 head 指针

本地库下/上移动，相对的暂存区与工作区则被提前/回退了

-- mixed

在本地库移动 Head 指针

不仅会移动本地库还会移动暂存区，不对工作区做修改

重置缓存区

-- hard

在本地库移动 head 指针

重置暂存区，重置工作区；

分支：

同时并行推进多个功能开发，提高效率

各个分支在开发过程中，如果某一个分支，开发失败，不会对其他造成影响

分支操作：

//查看所有的分支
git branch -v
// 创建分支
git branch [file name]
//切换分支
git checkout [file name]
// 合并分支
1.切换到接受修改的分支上（被合并，增加新内容）
2.执行merge命令即可

合并分支注意：首先对其他分支进行编辑更新添加新功能，然后需切换到主分支 master 上，执行 merge 命令，完成合并。便可更新增的功能

// 解决冲突（手动），当不能直接使用 merge 合并时，则需要

何时会出现合并错误？又如何去修改？

在不同分支出现出现相对应的更改时，自动合并不知道以何更新为主，合并将产生冲突；

重新 add，commit 注意 commit 不能带文件名

编辑文件，删除特殊符号
把文件修改至满意，保存并退出
git add 【file name】
git commit -m “log message”
- 此处的 commit 不能带 file name

作者 Payne 发表于 2020-05-24 阅读次数：本文字数： 1.6k 阅读时长 ≈ 1 分钟

Other Git学习日志之二-使用前准备——本地库初始化与设置签名

简介：了解过 git 来源的朋友，应该会晓得 git 与 Linux 系统是同一作者，所以在此操作 Linux 的基础命令几乎都能运行，在此便不在过多赘述：列举几个在此常用的命令：

ls -lA:查看所有的目录（包含隐藏文件夹）
ls -l|less 分屏的去查看

安装好了之后如果是默认安装，git 会添加到鼠标右击的快捷栏中（如下所示）：

Git 使用前许初始化本地库，具体操作如下：

本地库初始化:(命令行：Git Bash Here)

命令：git add（使用 git bash here）

进入相对应的目录下，新建一个用于学习 Git 的文件夹

mkdir xxx

初始化本地库：

1 2	cd xxx // 进入到相对应的目录下 git init //初始化本地命令

首先是使用了’ll‘，命令查看当前前目录先文件夹及权限
使用 mkdir anothergit 命令在当前目录下创建了一个名为 anothergit 的文件夹
使用 git init ，初始化本地库

初始化成功效果展示：

ll -lA // 显示该目录下全部的文件夹（注：如果使用’ll‘是不能显示出’.git/‘的）
1

                      
                      
                        2.

                      
                      
                      
                      
 ll .git/ // 查看.git/文件夹下的可显示的文件夹 
                        
                          
                            
                              1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

                            
                            
                              
注：.git 目录中存放的是本地库相关的配置文件，请勿随意删除及修改。（这里凉了就凉凉了，git 的命令也帮不了你）

## 设置签名：

主要用于区分开发者身份，并非会验证验证其邮箱真实性，

-  形式：
  - 用户名：Payne
  - Email 地址：123123@xxx.com
  - 这里设置的前和登录远程库的账号密码无任何关系
- 签名：如果都有的话会以项目级别仓库签名为使用，否则会以系统用户级别为使用

  - 项目级别（仓库级别）：仅在此库有效
  - 命令：

                            
                          
                        
                      
 //主要用的命令 git config // 实际用的 git config user.name Payne_project git config user.eamil 123123@xxx.com 
                        
                          
                            
                              1
2
3

                            
                            
                              
- 实际操作：
- ![](https://cdn.cuiqingcai.com/wp-content/uploads/2020/05/4.项目级别签名设置.png)使用命令,查看项目级别签名设置结果：

                            
                          
                        
                      
 cat ./git/config 
                        
                          
                            
                              1
2
3

                            
                            
                              
- 系统用户级别：登录当前操作系统的用户范围（包含多个项目级别，仓库级别）
- 命令：

                            
                          
                        
                      
 //主要用的命令 git config --global // 实际用的 git config --global user.name Payne_global git config --global user.eamil 123123@xxx.com

实际操作系统用户级别的 config 是在系统目录下，如果不想太麻烦的去找直接 cat ~/.git config 即可

作者 Payne 发表于 2020-05-24 阅读次数：本文字数： 1.1k 阅读时长 ≈ 1 分钟

Other Git学习日志之一-安装Git

这篇文章是我近日学习 git 的笔记，单纯想做个“云备份什么的”，所以的话侧重点就有点偏。

Git 的来源、用处相信大家都或多或少的了解，如果真的想知道的话请自行百度哈~

Git 的安装：

https://git-scm.com/

Git 安装相关简介>)：

https://git-scm.com/download

各系统的安装(并非唯一方式！)

Window Git 下载地址:

https://git-scm.com/download/win

选择相对应的版本下载即可，下载完成后打开相对应的安装执行，有选项的选择的建议点击第一个默认配置，就不在此过多赘述啦。

MacOS：在命令行中输入以下命令即可

brew install git

以上的网页地址为： https://git-scm.com/download/mac

Linux：(sudo:以管理员权限运行相关的命令，中间的‘-y’：默认同意安装)

在这里以 Ubuntu 为例： Ubuntu：

apt-get install git apt-get -y install git sudo apt-get install git sudo apt-get -y install git

更加具体的可自行查阅 Linux 系统安装 Git 相关：

https://git-scm.com/download/linux

Git 和代码托管中心

代码托管中心的任务：维护远程库

局域网环境下：

可搭建 GitLab 服务器

外网环境下：

Github
码云
等等

作者 Payne 发表于 2020-05-24 阅读次数：本文字数： 665 阅读时长 ≈ 1 分钟

Python 嫌多(线程/进程)太慢？嫌Scrapy太麻烦？没事，异步高调走起！——瓜子二手车

本节涉及：多线程、多进程、异步的相关概念，希望对你学有所获，学有所成。

基本概念了解：

并发与并行：(偏向于多线/进程方面的原理)

并发：指在同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干段，使多个进程快速交替的执行
并行：指在同一时刻，有多条指令在多个处理器上同时执行。所以无论从微观还是从宏观来看，二者都是一起执行的

阻塞与非阻塞：（偏向于协程/异步的原理）

阻塞：阻塞状态指程序未得到所需计算资源时被挂起的状态。程序在等待某个操作完成期间，自身无法继续处理其他的事情，则称该程序在该操作上是阻塞的。
非阻塞：程序在等待某操作过程中，自身不被阻塞，可以继续处理其他的事情，则称该程序在该操作上是非阻塞的

同步与异步：

同步：不同程序单元为了完成某个任务，在执行过程中需靠某种通信方式以协调一致，我们称这些程序单元是同步执行的。
异步：为完成某个任务，不同程序单元之间过程中无需通信协调，也能完成任务的方式，不相关的程序单元之间可以是异步的。

说了这么多，咱们列举一些他们相关的特点吧：

多线程（英语：multithreading）：指从软件或者硬件上实现多个线程并发执行的技术。具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程，进而提升整体处理性能。具有这种能力的系统包括对称多处理机、多核心处理器以及芯片级多处理（Chip-level multithreading）或同时多线程（Simultaneous multithreading）处理器。在一个程序中，这些独立运行的程序片段叫作“线程”（Thread），利用它编程的概念就叫作“多线程处理（Multithreading）”
多进程(Multiprocessing):每个正在系统上运行的程序都是一个进程。每个进程包含一到多个线程。进程也可能是整个程序或者是部分程序的动态执行。线程是一组指令的集合，或者是程序的特殊段，它可以在程序里独立执行。也可以把它理解为代码运行的上下文。所以线程基本上是轻量级的进程，它负责在单个程序里执行多任务。通常由操作系统负责多个线程的调度和执行。线程是程序中一个单一的顺序控制流程.在单个程序中同时运行多个线程完成不同的工作,称为多线程.
二者的区别：线程和进程的区别在于,子进程和父进程有不同的代码和数据空间,而多个线程则共享数据空间,每个线程有自己的执行堆栈和程序计数器为其执行上下文.多线程主要是为了节约 CPU 时间,发挥利用,根据具体情况而定. 线程的运行中需要使用计算机的内存资源和 CPU。
协程(Coroutine):又称微线程、纤程，协程是一种用户态的轻量级线程。协程看上去也是子程序，但执行过程中，在子程序内部可中断，然后转而执行别的子程序，在适当的时候再返回来接着执行。

基本的原理都已经了解了，那咱们不整一下，咋行？光说不练假把式，走起！！！本节源码：仓库地址>) 首先先说一下基本的思路：
- 确定 URL
- 发起请求，得到响应
- 解析响应，提取数据、
- 保存数据
确定 URL：

本次请求的 URL(先放地址了！) https://www.guazi.com/cs/buy/o2/#bread

根据以上可知，URL：https://www.guazi.com/{cs}/buy/o{page}/#bread ，更具改变 cs 改变城市，一线城市为前拼音两个字母(例如：长沙/cs 、湘潭/xiangtan)，第一页为 o1,第二个为 o2。以此类推发送请求：

async def scrape(self, url):
       async with self.semaphore:
           async with aiohttp.ClientSession(headers=self.header).get(url) as response:
               await asyncio.sleep(1)
               return await response.text()

注意：再次加入请求头，本网站对 Cookies 有严格的检测。且并不能挂 IP 代理访问解析响应：

async def parse(self, html):
       with open('car.csv', 'a+', encoding='utf-8') as f:
           doc = pq(html)
           for message in doc('body > div.list-wrap.js-post > ul > li > a').items():
               # 汽车简介
               car_name = message('h2.t').text()
               # 汽车详情(年限、里程、服务)
               car_info = message('div.t-i').text()
               year = car_info[:5]
               mileage = car_info[6:-5]
               service = car_info[13:].replace('|', '')
               # 价格
               try:
                   price = message('div.t-price > p').text()
               except AttributeError:
                   price = message('em.line-through').text()
               car_pic = message('img').attr('src')
               data = f'{car_name}, {year},{mileage}, {service}, {price}n'
               logging.info(data)
               f.write(data)

我这里是直接一步到位了，解析响应，以及保存数据。运行之后即可看到类似于这样的东东

如有疑问，咱们评论区见

作者 Payne 发表于 2020-05-08 阅读次数：本文字数： 2.3k 阅读时长 ≈ 2 分钟

JavaScript JS解密入门——有道翻译

JS 解密入门——有道翻译

此篇文章省略了很多基础的，例如 json 格式数据的提取啊。试试手，练练感觉。似乎也没啥用。

一了解加密与解密：

什么是加密，什么是解密？

加密：数据加密的基本过程，将原为明文的文件或数据经过某种算法进行一次或多次处理。得到的结果常称之为密文的东东。
解密：加密的逆过程，找到加密相同的方式，对其逆向处理，得到原本文件或数据的过程

常用的加密方式：

加密算法分 对称加密 和 非对称加密 其中对称加密算法的加密与解密 密钥相同，非对称加密算法的加密密钥与解密 密钥不同，此外，还有一类 不需要密钥 的 散列算法。

本节所涉及的方式：MD5

MD5 用的是 哈希函数，它的典型应用是对一段信息产生 信息摘要，以 防止被篡改。严格来说，MD5 不是一种 加密算法 而是 摘要算法。无论是多长的输入，MD5 都会输出长度为 128bits 的一个串 (通常用 16 进制表示为 32 个字符)。更多相关详情请点击此处>)

二造！点击进入本节源码

这段内容图会比较多,文字叙述会比较少.

确定 URL：

Basic URL ： http://fanyi.youdao.com/ 结论缘由,在不刷新全局页面的情况下,在输入框中输入,翻译动态刷新.可知此链接为 Ajax. 经过一系列测试发现，其实际需操作的 URL 为 http://fanyi.youdao.com/translate_o?smartresult=dict&smartresult=rule 在开发者工具中具体观察以下. 基本网站的分析就分析完毕了注意此处为 POST 请求！！！

观察加密

仔细观察红色方框中，重点观察随着时间改变而改变的参数（图中红色箭头所指之处）

分析加密：

仔细经过上述步骤即可进入本次加密的源码详情页搜索 sign 参数,得知本页面有 15 个 sign,筛选排查过后可得知以下位置为 sign 等参数,赋值加密过程为什么会大概确定是此处呢? 理由一:var 声明赋值理由二:md5() 为什么深信此处呢?

断点一打,debug 一下,啥都出来了.

根据其语法可知,Javascript

e 为输入所翻译的内容
ts 为七位整数的时间戳
salt 为时间戳后加上一位,大于 0 小于 9 的数字
bv 为 User-Agent 的值经过md5 加密的密文
sign 为(“fanyideskweb” + e + salt + “Nw(nmmbP%A-r6U3EUn]Aj”)经过 md5 加密的密文

到这里就基本完成了,那接下来就开始码码吧.

码!!!

看到这里，转而看一下源码。对着上面的注释，仔细看看，相信你一定会有所收获的。

拓展：

可以将此源码打包，并建立用户界面

其实这篇完全就是用来找感觉的,真正的 JS 难度系数成几何倍增长，所以．．．

加油吧，欧里给～如有疑问，那么评论区见

作者 Payne 发表于 2020-05-04 阅读次数：本文字数： 1.1k 阅读时长 ≈ 1 分钟

Python 虚拟环境搭建

前言：

什么是虚拟环境？

由百度百科>)得知：以专利的实时动态程序行为修饰与模拟算法，直接利用本机的 OS，模拟出自带与本机相容 OS 的虚拟机（Vista 下可模拟 Vista、XP，Windows 7 下则可模拟 Windows 7、Vista、XP），也称为“虚拟环境”
功能：每一个环境都相当于一个新的 Python 环境。你可以在这个新的环境里安装库，运行代码等

为什么需要使用虚拟环境？

众所周知 Python 的强大在于其兼容性，其强大的社区等。同时缺也由些许库并不兼容
真实环境与虚拟环境二者相对关联，并非绝对关联，可以在环境里面随便造。

什么时候需要使用虚拟环境？

例如：

需要探究不同版本的 Django 等相互之间的异同
各模块产生冲突时
- 不知为何，我在 python 环境中后续安装 scrapy，由于库的不兼容会报出安装其中的异步框架（Twisted）的错误

虚拟环境原理：

1	各虚拟环境相当于一个抽屉，在这个抽屉中安装的任何包都不会影响其他抽屉，可以指定项目的虚拟环境来配合使用我们的项目

一、搭建 Python virtualenv

搭建前准备:

请确保 Python 已安装至使用的电脑中(最好已经配置好了环境变量）
请确保 pip 命令能够正常使用，且能正常安装库

如何搭建？

使用 Virtualenv 库

安装 Virtualenv：

pip install Virtualenv
1
2
3
4

                          
                          
                            - 造起来吧

  - 创建虚拟环境：
  -

                          
                          
                          
                          
 # 后面参数为Virtual environment name 虚拟环境名（可自行定义，我这里以Test为例） Virtualenv Test（Virtual environment name） 
                            
                              
                                
                                  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

                                
                                
                                  
  ![](DataBoke虚拟环境搭建微信图片_20200422033005.png)          ![](https://cdn.cuiqingcai.com/wp-content/uploads/2020/04/微信图片_20200422033005.png)

  - 命令行解析：首先创建了一个名为 Virtual environment 的文件夹并且进入(至于为何创建，是因为便于多虚拟环境包管理，这个也是一个 **virtualenv** 的一个缺陷。自己思考后想到较为妥善的解决方法，稍后会阐述明白)
    - 1、 使用 Virtualenv Test 命令创建了一个名为 Test 的虚拟环境包
    - 2、 进入 Test 虚拟文件夹中的 Scripts
    - 3、此时已经进入且使用虚拟环境，后又运行了 deactivate.bat 命令退出了虚拟环境
    - 4、 此时为系统环境（或者说没有使用任何虚拟环境）区分是否为虚拟环境以路径开头是否有“（Virtual environment name）”
  - 删除虚拟环境包
    - 直接删除所对应的文件夹即可
  - 注意点：
    - 需进入 Scripts 目录才可运行
    - 需添加名为. bat 后缀才可运行
  - 阐述一下 Virtualenv 缺陷(不是这个库，而是这个方法！！！)，
  - Virtualenv 这个方法是直接在当前目录下创建一个虚拟环境，如果没有单独建立类似于名为 Virtual environment 的文件夹难于管理虚拟环境包，一个两个还好，如果多了的话是十分头疼的。个人建议，如果使用此方法，
    - Virtualenv 这个方法需要进入虚拟环境包中的 Scripts 文件夹才可运行相关的命令，如进入及退出虚拟环境的命令。(当然也可用创建环境变量的方法来解决此缺陷，但如果是单文件还好，那如果是多个虚拟环境包，反倒给自己填麻烦)

## 二、 搭建 Python virtualenvwrapper-win

### 引言：

 经过上述的缺陷分析似乎并没有那么方便，就算创建了相关文件夹来放虚拟环境包，但似乎管理起来，却并没有那么简单。（一两个的还好，但是到了三四个，上十个，百个绝对是一件伤脑筋的事情），那么是否有方法能有弥补相关的缺陷呢？答案肯定是有的。Ta 就是 **virtualenvwrapper-win**

---

## virtualenvwrapper-win:

- 介绍： Virtaulenvwrapper 是基于 virtualenv 的扩展包
- 功能： 更方便管理虚拟环境
- 实现： 它可以将所有虚拟环境整合在一个目录下 ，统一管理（新增，删除，修改，复制，检查），也能够快速在各个虚拟环境间自由切换。

  ###### 提前准备：

  - 请确保 Python 已安装至使用的电脑中(最好已经配置好了环境变量）
  - 请确保 pip 命令能够正常使用，且能正常安装库

  ###### 安装：

                                
                              
                            
                          
 pip install virtualenvwrapper-win

使用：

为了便于使用个人建议，配置系统环境变量，配置如下：找到我的电脑（此电脑），右击属性，点击高级系统设置，后点击环境变量在系统环境变量中添加以下信息，后确认退出

virtualenvwrapper-win 常用命令如下：
- 创建虚拟环境： mkvirtualenv (Virtual environment name)
- 进入虚拟环境：workon (Virtual environment name)
- 退出当前虚拟环境： deactivate
- 删除虚拟环境：rmvirtualenv (Virtual environment name)
- 列出所有虚拟环境列表：workon
  
  演示如下（此时的 Virtual environment name = Test）箭头代表输入的步骤：
1. 使用 mkvirtualenv Test 命令创建一个名为 Test 的虚拟环境包（并且创建完成后自动进入此虚拟环境）
2. 使用 deactivate 命令退出当前虚拟环境
3. 使用 workon 命令列出虚拟环境表
4. 使用 workon Test 命令进入名为 Test 的虚拟环境列表
5. 使用 rmvirtualenv Test 命令删除了名为 Test 的虚拟环境列表
6. 再次使用使用 workon Test 命令进入名为 Test 的虚拟环境列表
  
  Mac \Linux 同理，就不再这里一一赘述了

三、虚拟环境的使用：

命令行下，运行虚拟环境直接 Python （Reptile Engineering.py）即可
- 不使用虚拟环境：
- 使用虚拟环境(因为是一个新的环境，所有的包、库都未安装所以报错<没有 requests 模块错误>：
- 不使用虚拟不使用虚拟环境：直接运行即可。
Pycharm：使用虚拟环境:以下步骤将虚拟环境 Python 解释器加载到 Pycharm 中来，步骤如下：

写在最后：

首先和大家说句 Sorry 啊，此篇文章中有许多内容来自于百度搜索所得，后根据自己理解改进及编写此篇文章。感谢查看与支持，不喜勿喷。谢谢。如果有疑问欢迎在评论区留言，我看到后会在第一时间回复，咱们评论区见，加油，欧里给~ 祝学习进步，升官发财，感谢查看与支持，谢谢。我叫 Payen，某大学在校大二学生，我有 Get 到你么？

声明：

本人 Payen 为本文原著，转载请注明出处，谢谢 ——Payne

作者 Payne 发表于 2020-04-22 阅读次数：本文字数： 2.8k 阅读时长 ≈ 3 分钟

技术杂谈 如何用 JMeter + Kubernetes + Prometheus + Grafana + Alert Manager 实时监控你的服务器

最近我在公司负责的业务已经正式投入上线了，既然是线上环境，那么就需要保证其可用性。我负责的业务其中就包括一个 Web Service，我需要保证 Service 的每个接口都是可用的，如果某个时间流量大了或者服务器挂掉了，那需要第一时间通知到我。这时候可能我有这些需求：

定时测试和监控服务器每个接口是否是可用的，包括返回的数据、状态码是不是正确的。
我可以随时查看到每个接口的响应时间、可用率等信息，最好是有可视化的图表呈现，一目了然。
如果接口的错误率超过某一阈值一段时间，及时通知我，包括电话、短信或邮件。
需要主动去监测接口的可用性，注意这里是主动监测而不是被动监测，不是等用户用的时候报错才提醒我。比如在没有用户用的时候，我也能及时知道每个接口的可用性。

其实，国内的一些服务商已经提供了这些功能，即主动型服务监控，比如「监控宝」，但我并不想用这些服务，一是需要额外花钱，二是数据上并不安全，三是我需要把我的服务集成到公司内部的监控体系下。

有了这些需求，我就结合公司内部现有的一些基础设施先确定一个技术选型，然后实施就好了。目前公司内部使用的一套监控体系是基于 Kubernetes + Prometheus + Grafana + Alert Manager 的，那么基于我的需求来分析下我怎样利用这一套体系来搭建我想要的监控设施。解决方案分析：

首先关于第四个需求比较特殊，现有的监控体系其实已经可以做到服务的被动监测，比如某个 Service 的 API 被调用了，那么相应的调用数据都会被汇总到 Prometheus 上面，Prometheus 里面会计算接口调用的可用率，如果一段时间内如果错误率超过一定阈值，那就报警，追错误的时候去查下 log 就好了。但其实这个不能做到主动监测，比如在凌晨三四点，当没有用户使用的时候，如果这时候服务器出现问题了，我也需要第一时间能知道，所以我需要有一个定时的主动监测程序来实时监测我的所有接口是否是可用的。要做到主动监控，那我一定需要一个接口监测程序定时运行并校验每个接口的结果，这里我选用的就是开源的 JMeter，它大多数情况下是被用来做压测的，但绝对能满足接口调用和检测的需求，只要我定时跑 JMeter 来检测就好了。
关于第一个需求，我需要监测我的每个接口都是可用的，包括返回的数据也需要是想要的结果。这时候我们可能想到直接跑一些 test case 之类的，但这些其实大多数都是在部署或运行时校验的，如果我要实时跑或者 test case 有 update 了，也不太方便。另外为了写接口测试的时候，如果没有现成的工具，我们可能得写一堆代码，每个接口都写一个，包括 GET 请求的 URL 参数、POST 请求的 Body 信息等等，然后校验接口的返回结果是不是对的，也太麻烦了。所以我们需要找到一个可用的工具来帮助我们快速地完成这些功能。所以，我选择的 JMeter 也提供了可视化界面，我只需要配置一些接口和参数即可，另外它还带有定时器、断言、动态参数、多线程等功能，这样我们也可以做到并发测试、随机等待、动态构造请求参数、返回结果判断等功能了。
其次再说第二个和第三个需求，其实用现有的 Prometheus + Grafana 就能解决了，这里最关键的则是我的接口监控结果能发给 Prometheus 才行。既然我选用了 JMeter，那么我怎样把 JMeter 的数据发送给 Prometheus 呢？这里需要借助于 JMeter 的一个插件 jmeter-prometheus-plugin，https://github.com/johrstrom/jmeter-prometheus-plugin，利用它就能将 JMeter 变成一个 Data Exporter，Prometheus 来抓取就好了。

所以，综上所述，我利用的一套服务监控体系就是 JMeter + Kubernetes + Prometheus + Grafana + Alert Manager，那么就开干吧。这里先放一张图，看下最终的监控 Grafana 面板吧：这里一些接口的名称和 URL 我就打码了，这里我可以在 Grafana 中每时每刻都看到每个接口的可用率、响应（包括平均、最快、最慢）时间、状态码等信息，这些信息就是 JMeter 定时检测得到的结果，监控数据转到 Prometheus 里面然后经过 Grafana 可视化出来，并能通过一些指标来实现报警机制。感兴趣的话，可以继续往下看哈。为了达成这些功能，我需要解决如下问题：

如何使用 JMeter 来测试每个接口的使用情况。
JMeter 如何和 Prometheus 对接起来，即如何集成 jmeter-prometheus-plugin 到 JMeter。
JMeter 怎样去部署，部署到哪里。
可视化数据怎样来呈现。
错误状态怎样来快速查看。
出错通知如何实现，比如打电话、发邮件等等。

下面我们就来一个个总结说一下。

由于内容比较多，整个流程我实践下来然后测试通总共花了两天左右的时间，在这里就不完全展开说了，只提关键点了。

JMeter 测试

第一步那就是用 JMeter 来完成接口的测试了，接口的调用形式肯定都有相应的规范的，比如 GET 请求设置啥参数，POST 请求发送什么数据，我们利用 JMeter 都能方便地配置。 JMeter 是有 GUI 的，我们在编写的时候在 GUI 里面设置就好了，界面样例如下所示： JMeter界面（图源：https://www.jianshu.com/p/0349441da3c4）这里提示几点可能用到的东西：

动态参数，JMeter 里面是支持动态参数设置的，比如循环测试 id 从 1 到 100，或者动态 POST 的数据替换，都是可以做到的，这个可以满足你花样测试接口的需求。
定时器，JMeter 里面有很多 Timer，可以设置各种各样的延时操作，比如每 3 分钟测一次，随机等待多少秒测一次都行。
断言，测试了接口之后，我们不仅要知道是否是可用的，同时也要判断其结果是不是正确的，如果返回状态码是正确的但是结果不对，那也白搭，所以可以使用断言来检查返回结果。

关于 JMeter 的功能这里就不再展开讲了，反正几乎你想实现的任何测试功能都可以实现，具体的用法可以参考 JMeter 的官方文档：https://jmeter.apache.org/usermanual/get-started.html。嗯，写好了之后，可以用 JMeter 在本地进行测试，测试好了时候，可以把 JMeter 的这个 Test Plan 存成一个 jmx 文件，留作后面备用。

对接 Prometheus

接下来就是如何把数据对接到 Prometheus 里面了。默认情况下，JMeter 是能导出数据到诸如 InfluxDB 这样的数据库的，借助于它自带的 Listener 即可实现。它并不带导出到 Prometheus 的功能。这里我们就需要借助于 jmeter-prometheus-plugin 这个插件了，其 GitHub 地址是 https://github.com/johrstrom/jmeter-prometheus-plugin，具体的用法可以参考其官方说明。这里提示几点：

jmeter-prometheus-plugin 安装的时候把 jar 文件放到 JMeter 目录下就好了，jar 文件可以直接看这里下载：https://github.com/johrstrom/jmeter-prometheus-plugin#programatically。
安装好这个插件之后，需要增加一个 Listener，然后配置各种导出字段和参数，可以参考这个 jmx 文件的配置：https://github.com/johrstrom/jmeter-prometheus-plugin/blob/master/docs/examples/simple_prometheus_example.jmx，可以把这个 jmx 打开，然后把 Listener 拷贝到你的 Test Plan 即可。
jmeter-prometheus-plugin 这个插件会把 JMeter 变成一个 Data Exporter，而不是通过 Prometheus Push Gateway 来主动推送监控信息，所以它会在本地启动一个端口，默认是 9270。

Listener 的配置示例如图所示： JMeter Listener 这里字段名如 jsr223_rt_as_summary 可以自行修改，比如这里我就统一修改为了 jmeter_test_xxx 这样的字段。配置完成之后，运行 JMeter 之后，我们就能在 http://localhost:9270 上看到 Exporter 的信息，如图所示：这里面就包含了 JMeter 的一些接口测试结果，包括成功次数、失败次数、状态码等等，另外还有 JVM、处理器等各种环境信息。部署之后把对应的 URL 交由 Prometheus 就可以把监控数据收集到 Prometheus 里面了。

部署 JMeter

完成上述两步，我们就能成功测试 Service 的每个接口并能生成测试结果的 Exporter 了。那么 JMeter 写好了，怎么来部署呢？可以用 crontab，放某台服务器上，不过这里最理想的方式当然是部署到 Kubernetes 里面了。这里就需要把 JMeter 打包成一个镜像了，GitHub 找来找去没找到几个合适的，另外也没有把 jmeter-prometheus-plugin 包括进去，那只有自己来了。我基于 https://github.com/justb4/docker-jmeter 进行了二次改写，最后打包了一个镜像，已经开源了，地址为：https://github.com/Germey/JMeterMonitor，镜像名称为 germey/jmeter，这里就不再展开讲细节了，有点复杂。运行所需要的 docker-compose 文件如下：

version: '3'
services:
  jmeter:
    restart: always
    image: 'germey/jmeter'
    volumes:
      - ./jmx:/app
    command:
      - sample.jmx
    ports:
      - "80:80"

这里我把本地的 jmx 文件夹 mount 到了 Docker 的 app 文件夹，所以这里在运行时需要在项目文件夹下新建 jmx 文件夹，用于存放 jmx 文件，把刚才写好的 jmx 文件放过来就好了。另外 command 就是 jmx 文件的名称，这里需要修改成你的 jmx 文件。另外部署到 Kubernetes 的话可以参考这里的 yml 文件：https://github.com/Germey/JMeterMonitor/tree/master/kubernetes。

Prometheus 收集数据

在成功部署 JMeter 之后呢，它肯定会提供一个 Web Service 来暴露 JMeter 的测试数据。如果部署好了 Prometheus 之后，可以把它放在 Prometheus 的 scrape_configs，比如 Service 的 URL 为 jmeter-monitor.com，可以修改 prometheus.yml：

global:
  scrape_interval:     15s # By default, scrape targets every 15 seconds.

  # Attach these labels to any time series or alerts when communicating with
  # external systems (federation, remote storage, Alertmanager).
  external_labels:
    monitor: 'codelab-monitor'

# A scrape configuration containing exactly one endpoint to scrape:
# Here it's Prometheus itself.
scrape_configs:
  # The job name is added as a label `job=<job_name>` to any timeseries scraped from this config.
  - job_name: 'jmeter-monitor'

    # Override the global default and scrape targets from this job every 5 seconds.
    scrape_interval: 5s

    static_configs:
      - targets: ['jmeter-monitor.com']

其具体的配置字段可以参见：https://prometheus.io/docs/prometheus/latest/configuration/configuration/。另外呢，这种方式其实并不怎么好，修改 Prometheus 挺麻烦的，推荐使用 Helm + Prometheus-Operator 来安装 Prometheus，然后修改 values.yml 即可修改配置文件了，比如修改 https://github.com/helm/charts/blob/master/stable/prometheus-operator/values.yaml 里面的 additionalScrapeConfigs 即可。

Grafana 可视化

Prometheus 收集完数据之后，我们可以将其可视化出来了。比如这里有些字段，jmeter_test_can_fail_success 代表成功请求的次数，jmeter_test_can_fail_total 代表总的测试次数。那么就可以用一个表达式来计算 Error Rate 了：

1	1- jmeter_test_can_fail_success{instance="$instance"} / jmeter_test_can_fail_total{instance="$instance"}

效果如下：这里就能实时可视化展示出来错误率了，更多的一些配置可以自行修改这些表达式进行定制。最后我配置成的一些监控面板如下所示：这样我要是什么时候想看 Service 接口的情况，随时上来看就好了。

报警

对于报警来说，可以使用两种方式配置，一个是直接使用 Grafana 自带的报警机制，另外是可以通过 Alert Manager，后者功能更加强大，推荐使用后者。对于 Alert Manager 来说，其监控的规则这里推荐使用 Prometheus-Operator 里面自带的 PrometheusRule 来实现，比如可以定义这么一个 PrometheusRule：

apiVersion: monitoring.coreos.com/v1
kind: PrometheusRule
metadata:
  labels:
    app: monitor
  name: monitor-rules
spec:
  groups:
  - name: monitor
    rules:
    - alert: ServiceErroring
      labels:
        severity: warning
      annotations:
        message: Service 连续5分钟错误率过高。
      expr: |
        avg(1- jmeter_test_can_fail_success{job="service-monitor"} / jmeter_test_can_fail_total{job="service-monitor"}) > 0
      for: 5m

这样配置好一个 PrometheusRule 之后，Prometheus 会自动应用这个 Rule 然后监控。报警方式的话可以通过配置 Alert Manger 的 Receiver 来实现，包括打电话、邮件、短信等等，配置规则可以见：https://prometheus.io/docs/alerting/configuration/。目前我是利用了组内已经提供的报警机制，组内已经对接好了电话、短信、邮件报警，并可以把每个人的信息进行管理和分组，然后应用到某个报警规则里面，这样一旦有问题，就可以实现报警啦。另外对于一些规则的管理，我们可以使用一些开源的 Dashboard 来管理，如 Krama，https://github.com/prymitive/karma，利用它我们可以方便配置、禁用和筛选一些报警规则，界面如下：不过公司内部已经实现了一套了，对接了公司的员工账号，更加方便，所以我就没有再用这个了。

定时重启

这里另外遇到了一个问题，就是 JMeter 导出的监控数据是不断累积的，而监控的数据则是需要监控最近几分钟的数据，这样一旦发生了 Error，那么 Error Rate 由于历史数据的原因，在服务恢复之后永远不会降为 0，这就导致一些问题。另外如果 JMeter 如果一直运行，其占用的内存会越来越大。所以一个最好的方式就是定时将 JMeter 重启，这样可以定时清空历史监控数据，保证在新的一段时间内测试获取到最近的监控数据，而不是混杂历史数据。这里重启就可以利用 Kubernetes 的 Cronjob，比如我们可以每隔 10 分钟让 JMeter 重启一次，类似配置如下：

apiVersion: batch/v1beta1
kind: CronJob
metadata:
  name: jmeter-monitor
spec:
  successfulJobsHistoryLimit: 0
  failedJobsHistoryLimit: 0
  concurrencyPolicy: Replace
  schedule: "*/10 * * * *"
  jobTemplate:
    spec:
      template:
        metadata:
          labels:
            service: jmeter-monitor
        spec:
          containers:
            - args:
                - jmeter-monitor.jmx
              image: germey/jmeter:1
              name: jmeter-monitor
              volumeMounts:
                - mountPath: /app
                  name: jmeter-storage
              ports:
                - containerPort: 80
              imagePullPolicy: IfNotPresent
              resources:
                requests:
                  memory: "4Gi"
                  cpu: "250m"
                limits:
                  memory: "4Gi"
                  cpu: "250m"
          restartPolicy: OnFailure
          volumes:
            - name: jmeter-storage
              persistentVolumeClaim:
                claimName: jmeter

这里有几个地方值得注意：

一个是 concurrencyPolicy，这里配置为 Replace，意思是重启后新建的 Pod 会替换原来的 Pod，保证 JMeter 的 Pod 只有一个。
另外一个是 imagePullPolicy 配置为 IfNotPresent，这样可以每次重启的时候不用重新拉镜像。

这样的话，就能避免发生错误的时候 Error Rate 无法降为 0 的状态了。好了，到此为止呢，我们就介绍完了使用 JMeter + Kubernetes + Prometheus + Grafana + Alert Manager 进行监控的整体思路了，希望对大家有帮助。另外由于内容比较多，这里很多地方没有展开讲解，比如 JMeter 的配置、Grafana 的配置、Prometheus-Operator 的配置、Alert Manager 的配置等等，不知道大家敢不敢兴趣，如果感兴趣的话，后面可以继续深入写一个小系列来讲解哈。

作者崔庆才发表于 2020-04-21 阅读次数：本文字数： 7.9k 阅读时长 ≈ 7 分钟

个人随笔 说说拖延症

刚刚又完成了一项任务。而这个任务明天就要检查上交了，在这之前，我其实有很多很多的时间去做这件事，而我还是把这个拖到了最后。怎么说呢？这个就是拖延症，不到最后一刻不去做，总要拖到 Deadline 才去搞。哎，其实吧反思我自己，一直就有这个毛病，不知道大家是不是也有这个毛病，或许大家都有的吧。不然怎么来的 Deadline 是第一生产力的说法呢。这个毛病体现在太多方面了，比如拿我自己说吧：

快到交稿的时候才去再赶点。
快到明天检查项目的时候才去做点。
快到考前再去复习。
…

其实也不能说拖延症不好吧，比如拿第三项「快到考前再去复习」，我确实到最后的时候效率会比平时高非常多。我大学和研究生几乎都是翘课翘过来的，除了那些重要的或者老师点名的课会去去，其他的一律翘掉，最后考前突击两星期，然后考个八九十分。悄悄炫耀下吧，当时突击得大学平均绩点最后突击了年级前 5%，最后还保研了，这其实让我有点难以相信的。不过研究生成绩就不行了，因为已经铁了心毕业就工作，所以精力都放在了自己的项目和公司工作上面，所以成绩就没上心了，中游水平吧。再说回大学吧，由于我平时对考前复习的 “拖延”，我可以平时把精力放在自己更感兴趣的事情上面。比如大学的时候吧，我加了一个实验室，基本上翘课的时间都是泡在实验室里面，我也忘记是在做什么了，也有在摸鱼，反正就是不想上课，当然也有挺多时候在撸代码，学一些技术什么的。所以相比一些「学霸」，我平时还 GET 到了一些编程技能，最后可能绩点还比他们高，而他们可能所有精力都放在功课上了，这可能他们想起来就有点气了哈哈。但其实吧，我虽然当时有点得意，以为自己占到了便宜，但其实当时对某些基础的理解确实不如平时认真学习的同学理解得透彻，比如当时计算机网络、计算机组成原理，当时就是考试突击，考试得了高分，但其实当时对里面的知识理解并不到位，到了真正用的时候，拾起来就没那么容易了。但当然也分科目，比如我到现在工作真的也没有用到计算机组成原理、电子电路的任何一点知识，以后也可能不会用到。所以，如果正在读本文的你，现在如果还在读大学的话，想清楚哪些科目将来对你可能是有用的，好好去学，好好去听讲，不要学我翘这么多课，没准你将来真的可能会用到，到时候就不要后悔自己当时为什么没好好学。扯远了，这里只是想论证下有些情况拖延症并不一定完全是坏处，也算是给拖延症找了个美丽但似乎不太恰当的借口吧。不过话说回来，拖延症在多数情况下是不好的，例子就不举了，大家肯定也深有体会。我曾经也看过关于拖延症的一些科普或 “诊疗” 方案，怎么说呢？每人都会有惰性，每人都喜欢待在自己的 “舒适区”，毕竟躺在被窝里面玩手机多么舒服啊。还看到一个关于拖延症的解释是说不够热爱，如果你非常热爱你做的事情，你是不会拖延的。我想了想，好像不是这样，比如我热爱 Python、喜欢编程、喜欢去实现某些东西，我想起来为什么有的时候还是不想去做呢？也不是不喜欢不热爱，那就是懒，可能喜欢呆在舒适区就是更合理的解释，因为我也喜欢睡懒觉和躺着玩手机。所以，有什么方法能缓解我的拖延症呢？我之前试过一个方法，还是挺有用的。这里分享给大家吧。比如我现在要写一个过了很久都不维护的项目吧，一想起来要打开它、配置环境、跑起来就各种事，懒得去做。这时候，我通常采取的方法就是强忍着，啥也不管，我就去迎着头皮去做，比如去把项目代码 clone 下来，然后 IDE 打开，然后试着跑起来，出错了稍微调一调，或者试着改几句代码。过这么十几分钟折腾，这时候发现再写，那就能比较顺利地写下去了。比如我现在要写一篇文章，一想起来我要打开文本编辑器、构思、梳理知识点就又懒得去做。这时候我采取的方案就是强制我自己打开文本编辑器，比如现在写的这篇文章就是这样，我本来并不想写，但是脑子里面又想到了一些事情，还是写写比较好，那我就硬着头皮打开吧，本想写个一两百字就行了，结果你看我现在写到这里了，咦你看我又写了十个字呢，你看我又写了十个字呢，是不是有点文思泉涌啊哈哈哈哈哈。诺，你看到现在，从我写这篇稿子到现在，也就过了不到十分钟吧，我这篇稿子就快收尾了，舒服啊。俗话说，万事开头难，做事情就是这样，如果大家也遇到了这个问题，不妨也可以试试这个方法，感觉还挺有效的。但并不是 100% 有效哈，有时候我就是懒到一天啥也不想干也不是没有。最后再说一个点，那就是其实，你看这件事，你在做之前，你可能觉得这件事好麻烦，不想干，或者好难，我干不了。但在可能大多数情况下，一旦你开始干了，你会发现并没有那么难那么麻烦。其实，难的就是开始。好了，我的稿子写完了，你看我在写之前觉得麻烦的一件事，这不就完结了吗。嗯，就是大晚上随便写写，突然想起来，我似乎今天还有几件觉得比较麻烦的事还没干呢，我去开头去啦，拜拜。

作者崔庆才发表于 2020-04-21 阅读次数：本文字数： 1.9k 阅读时长 ≈ 2 分钟

技术杂谈 利用深度学习 PyTorch 识别滑动验证码缺口

在前面写过一篇文章介绍深度学习识别滑动验证码缺口的文章，在这篇文章里，我们使用华为云 ModelArts 轻松完成了滑动验证码缺口的识别。但是那种实现方案依赖于 ModelArts，是华为云提供的深度学习平台所搭建的识别模型，其实其内部是用的深度学习的某种目标检测算法实现的，如果利用平台的话，我们无需去申请 GPU、无需去了解其内部的基本原理究竟是怎么回事，它提供了一系列标注、训练、部署的流程。但用上述方法是有一定的弊端的，比如使用会一直收费，另外不好调优、不好更好地定制自己的一些需求等等。所以这里再发一篇文章来介绍一下直接使用 Python 的深度学习模型来实现滑动验证码缺口识别的方法。

效果

目前可以做到只需要几百张缺口标注图片即可训练出精度高的识别模型，并且可扩展修改为其他任何样式的缺口识别，识别效果样例：只需要给模型输入一张带缺口的验证码图片，模型就能输出缺口的轮廓和边界信息。感兴趣的可以继续向下看具体的实现流程。

基础了解

缺口识别属于目标检测问题，关于什么是目标检测这里就不再赘述了，可以参考之前写的这篇文章。当前做目标检测的算法主要有两种路子，有一阶段式和两阶段式，英文叫做 One stage 和 Two stage，简述如下：

Two Stage：算法首先生成一系列目标所在位置的候选框，然后再对这些框选出来的结果进行样本分类，即先找出来在哪，然后再分出来是啥，俗话说叫「看两眼」，这种算法有 R-CNN、Fast R-CNN、Faster R-CNN 等，这些算法架构相对复杂，但准确率上有优势。
One Stage：不需要产生候选框，直接将目标定位和分类的问题转化为回归问题，俗话说叫「看一眼」，这种算法有 YOLO、SSD，这些算法虽然准确率上不及 Two stage，但架构相对简单，检测速度更快。

所以这次我们选用 One Stage 的有代表性的目标检测算法 YOLO 来实现滑动验证码缺口的识别。 YOLO，英文全称叫做 You Only Look Once，取了它们的首字母就构成了算法名，目前 YOLO 算法最新的版本是 V3 版本，这里算法的具体流程我们就不过多介绍了，感兴趣的可以搜一下相关资料了解下，另外也可以了解下 YOLO V1-V3 版本的不同和改进之处，这里列几个参考链接。

YOLO V3 论文：https://pjreddie.com/media/files/papers/YOLOv3.pdf
YOLO V3 介绍：https://zhuanlan.zhihu.com/p/34997279
YOLO V1-V3 对比介绍：https://www.cnblogs.com/makefile/p/yolov3.html

数据准备

回归我们本节的主题，我们要做的是缺口的位置识别，那么第一步应该做什么呢？我们的目标是要训练深度学习模型，训练模型，那我们总得需要让模型知道要学点什么东西吧，这次我们做缺口识别，那么我们需要让模型学的就是这个缺口在哪里。由于一张验证码图片只有一个缺口，要分类就是一类，所以我们只需要找到缺口位置就行了。好，那模型要学缺口在哪里，那我们就得提供点样本数据让模型来学习才行。数据怎样的呢？那数据就得有带缺口的验证码图片以及我们自己标注的缺口位置。只有把这两部分都告诉模型，模型才能去学习。等模型学好了，等我们再给个新的验证码，那就能检测出缺口在哪里了，这就是一个成功的模型。 OK，那我们就开始准备数据和缺口标注结果吧。数据这里用的是网易盾的验证码，验证码图片可以自行收集，写个脚本批量保存下来就行。标注的工具可以使用 LabelImg，GitHub 链接为：https://github.com/tzutalin/labelImg，利用它我们可以方便地进行检测目标位置的标注和类别的标注，如这里验证码和标注示例如下：标注效果标注完了会生成一系列 xml 文件，你需要解析 xml 文件把位置的坐标和类别等处理一下，转成训练模型需要的数据。在这里我先把我整理的数据集放出来吧，完整 GitHub 链接为：https://github.com/Python3WebSpider/DeepLearningSlideCaptcha，我标注了 200 多张图片，然后处理了 xml 文件，变成训练 YOLO 模型需要的数据格式，验证码图片和标注结果见 data/captcha 文件夹。如果要训练自己的数据，数据格式准备见：https://github.com/eriklindernoren/PyTorch-YOLOv3#train-on-custom-dataset。

初始化

上一步我已经把标注好的数据处理好了，可以直接拿来训练了。由于 YOLO 模型相对比较复杂，所以这个项目我就直接基于开源的 PyTorch-YOLOV3 项目来修改了，模型使用的深度学习框架为 PyTorch，具体的 YOLO V3 模型的实现这里不再阐述了。另外推荐使用 GPU 训练，不然拿 CPU 直接训练速度很慢。我的 GPU 是 P100，几乎十几秒就训练完一轮。下面就直接把代码克隆下来吧。由于本项目我把训练好的模型也放上去了，使用了 Git LFS，所以克隆时间较长，克隆命令如下：

1	git clone https://github.com/Python3WebSpider/DeepLearningSlideCaptcha.git

如果想加速克隆，暂时先跳过大文件模型下载，可以执行命令：

1	GIT_LFS_SKIP_SMUDGE=1 git clone https://github.com/Python3WebSpider/DeepLearningSlideCaptcha.git

环境安装

代码克隆下载之后，我们还需要下载一些预训练模型。 YOLOV3 的训练要加载预训练模型才能有不错的训练效果，预训练模型下载命令如下：

1	bash prepare.sh

执行这个脚本，就能下载 YOLO V3 模型的一些权重文件，包括 yolov3 和 weights 还有 darknet 的 weights，在训练之前我们需要用这些权重文件初始化 YOLO V3 模型。

注意：Windows 下建议使用 Git Bash 来运行上述命令。

另外还需要安装一些必须的库，如 PyTorch、TensorBoard 等，建议使用 Python 虚拟环境，运行命令如下：

1	pip3 install -r requirements.txt

这些库都安装好了之后，就可以开始训练了。

训练

本项目已经提供了标注好的数据集，在 data/captcha，可以直接使用。当前数据训练脚本：

1	bash train.sh

实测 P100 训练时长约 15 秒一个 epoch，大约几分钟即可训练出较好效果。训练差不多了，我们可以使用 TensorBoard 来看看 loss 和 mAP 的变化，运行 TensorBoard：

1	tensorboard --logdir='logs' --port=6006 --host 0.0.0.0

loss_1 变化如下： loss 变化 val_mAP 变化如下：可以看到 loss 从最初的非常高下降到了很低，准确率也逐渐接近 100%。另外训练过程中还能看到如下的输出结果：

\---- [Epoch 99/100, Batch 27/29] ----
+------------+--------------+--------------+--------------+
| Metrics    | YOLO Layer 0 | YOLO Layer 1 | YOLO Layer 2 |
+------------+--------------+--------------+--------------+
| grid_size  | 14           | 28           | 56           |
| loss       | 0.028268     | 0.046053     | 0.043745     |
| x          | 0.002108     | 0.005267     | 0.008111     |
| y          | 0.004561     | 0.002016     | 0.009047     |
| w          | 0.001284     | 0.004618     | 0.000207     |
| h          | 0.000594     | 0.000528     | 0.000946     |
| conf       | 0.019700     | 0.033624     | 0.025432     |
| cls        | 0.000022     | 0.000001     | 0.000002     |
| cls_acc    | 100.00%      | 100.00%      | 100.00%      |
| recall50   | 1.000000     | 1.000000     | 1.000000     |
| recall75   | 1.000000     | 1.000000     | 1.000000     |
| precision  | 1.000000     | 0.800000     | 0.666667     |
| conf_obj   | 0.994271     | 0.999249     | 0.997762     |
| conf_noobj | 0.000126     | 0.000158     | 0.000140     |
+------------+--------------+--------------+--------------+
Total loss 0.11806630343198776

这里显示了训练过程中各个指标的变化情况，如 loss、recall、precision、confidence 等，分别代表训练过程的损失（越小越好）、召回率（能识别出的结果占应该识别出结果的比例，越高越好）、精确率（识别出的结果中正确的比率，越高越好）、置信度（模型有把握识别对的概率，越高越好），可以作为参考。

测试

训练完毕之后会在 checkpoints 文件夹生成 pth 文件，可直接使用模型来预测生成标注结果。如果你没有训练自己的模型的话，这里我已经把训练好的模型放上去了，可以直接使用我训练好的模型来测试。如之前跳过了 Git LFS 文件下载，则可以使用如下命令下载 Git LFS 文件：

1	git lfs pull

此时 checkpoints 文件夹会生成训练好的 pth 文件。测试脚本：

1	sh detect.sh

该脚本会读取 captcha 下的 test 文件夹所有图片，并将处理后的结果输出到 result 文件夹。运行结果样例：

Performing object detection:
        + Batch 0, Inference Time: 0:00:00.044223
        + Batch 1, Inference Time: 0:00:00.028566
        + Batch 2, Inference Time: 0:00:00.029764
        + Batch 3, Inference Time: 0:00:00.032430
        + Batch 4, Inference Time: 0:00:00.033373
        + Batch 5, Inference Time: 0:00:00.027861
        + Batch 6, Inference Time: 0:00:00.031444
        + Batch 7, Inference Time: 0:00:00.032110
        + Batch 8, Inference Time: 0:00:00.029131

Saving images:
(0) Image: 'data/captcha/test/captcha_4497.png'
        + Label: target, Conf: 0.99999
(1) Image: 'data/captcha/test/captcha_4498.png'
        + Label: target, Conf: 0.99999
(2) Image: 'data/captcha/test/captcha_4499.png'
        + Label: target, Conf: 0.99997
(3) Image: 'data/captcha/test/captcha_4500.png'
        + Label: target, Conf: 0.99999
(4) Image: 'data/captcha/test/captcha_4501.png'
        + Label: target, Conf: 0.99997
(5) Image: 'data/captcha/test/captcha_4502.png'
        + Label: target, Conf: 0.99999
(6) Image: 'data/captcha/test/captcha_4503.png'
        + Label: target, Conf: 0.99997
(7) Image: 'data/captcha/test/captcha_4504.png'
        + Label: target, Conf: 0.99998
(8) Image: 'data/captcha/test/captcha_4505.png'
        + Label: target, Conf: 0.99998

拿几个样例结果看下：这里我们可以看到，利用训练好的模型我们就成功识别出缺口的位置了，另外程序还会打印输出这个边框的中心点和宽高信息。有了这个边界信息，我们再利用某些手段拖动滑块即可通过验证了。本节不再展开讲解。

总结

本篇文章我们介绍了使用深度学习识别滑动验证码缺口的方法，包括标注、训练、测试等环节都进行了阐述。 GitHub 代码：https://github.com/Python3WebSpider/DeepLearningSlideCaptcha。欢迎 Star、Folk，如果遇到问题，可以在 GitHub Issue 留言。

作者崔庆才发表于 2020-04-21 阅读次数：本文字数： 5.4k 阅读时长 ≈ 5 分钟

Python LaGou招聘，整一下？

声明：本文由一位知名的不知名 Payne 原创，转载请注明出处！首先说一下这个有啥用?要说有用也没啥用,要说没用吧，既然能拿到这些数据，拿来做数据分析。能有效的得到职位信息，薪资信息等。也能为找工作更加简单吧，且能够比较有选择性的相匹配的职位及公司本章节源码仓库为：https://github.com/Payne-Wu/PythonScrape 一言不合直接上代码！具体教程及思路总代码后！所用解释器为 Python3.7.1，编辑器为 Pycharm 2018.3.5. 本着虚心求学，孜孜不倦，逼逼赖赖来这里虚心求学，孜孜不倦，逼逼赖赖，不喜勿喷，嘴下手下脚下都请留情。本节所涉：Request 基本使用、Request 高级使用-会话维持、Cookies、Ajax、JSON 数据格式 Request 更多详情请参考 Request 官方文档：轻松入门中文版高级使用中文版 Cookie：有时也用其复数形式 Cookies。类型为“小型文本文件”，是某些网站为了辨别用户身份，进行Session跟踪而储存在用户本地终端上的数据（通常经过加密），由用户客户端计算机暂时或永久保存的信息具体 Cookies 详情请参考：https://baike.baidu.com/item/cookie/1119?fr=aladdin

Ajax 即“Asynchronous Javascript And XML”（异步 JavaScript 和 XML），是指一种创建交互式、快速动态网页应用的网页开发技术，无需重新加载整个网页的情况下，能够更新部分网页的技术。

通过在后台与服务器进行少量数据交换，Ajax 可以使网页实现异步更新。这意味着可以在不重新加载整个网页的情况下，对网页的某部分进行更新。

JSON(JavaScript Object Notation)：是一种轻量级的数据交换格式。易于人阅读和编写。同时也易于机器解析和生成。它基于JavaScript Programming Language, Standard ECMA-262 3rd Edition - December 1999的一个子集。 JSON 采用完全独立于语言的文本格式，但是也使用了类似于 C 语言家族的习惯（包括 C, C++, C#, Java, JavaScript, Perl, Python 等）。这些特性使 JSON 成为理想的数据交换语言。

首先介绍一下关于本章代码的基本思路： 四步走（发起请求、得到响应、解析响应得到数据、保存数据） 四步中准确来说是三步，（发起请求，得到响应、解析响应，提取数据、保存数据）

请求网页(在搜索框中输入所查询的岗位<例如：Python>，得到BASE_URL，)
- BASE_URL:https://www.lagou.com/jobs/list_Python?labelWords=&fromSearch=true&suginput=
- 加入请求头(注意加 Cookies)，请求 BASE_URL[gallery columns=”1” size=”full” ids=”9164”]
- 观察响应信息以及本网页源码观察浏览器网页源码，对比发现其中并没有我们所需要的信息：发现 Ajax 的痕迹。
- 经过一系列操作发现Ajax 网页地址(在这里直接请求此链接并不能访问)：
- 多次请求过后，发现错误。错误的缘由是由于 Cookies 限制，并且网页以动态检测，且时间间隔小。
  - 经过前言的学习，已经学会了。会话维持。动态得到 Cookies，这样不就可以把这个“反爬”彻底绕过了呢？答案肯定是滴
  - 哪让我们做一下会话维持，并动态提取 Cookies 吧。
  - 易混淆点：cookies 的维持为什么是维持 BASE_URL 的而不是 Ajax_URL?下面按照个人理解对于本 Ajax 给出以下解释：结合 Ajax 原理可知，Ajax 其基本原理就是在网页中插入异步触发的。说到底他还是在这个页面，并没有转到其他页面。只是需要特定条件触发即可插入本网页
    - ```
    def Get_cookies(header):
```
  """
  Get cookies
  @param header:
  @return: cookies
  """
  with requests.Session() as s:
      s.get(cookies_url, headers=header)
      cookies = s.cookies
  # cookies = requests.get(cookies_url, headers=header).cookies
  return cookies
```

    1
2
3
4
5
6

                  
                  
                        - 万事俱备、只欠东风：请求 Ajax_URL 即可得到以下![](https://cdn.cuiqingcai.com/wp-content/uploads/2020/04/DemoPicture2-Ajax-1.png)
    - 得到响应:经过以上操作已经请求完成了。并能够保障请求稳定性。(当然在此并没有做异常捕获，如果加上，将会更稳)

- ## 解析响应：如果上述步骤没有错的话，到此已经能得到网页数据了（如上图）：

- - 我用的提取代码如下 ：

                  
                  
                  
                  
 def parse(message): industryField = message['industryField'] # company_message positionName = message['positionName'] companyFullName = message['companyFullName'] companySize = message['companySize'] financeStage = message['financeStage'] # companyLabelList = message['companyLabelList'] companyLabelList = '|'.join(message['companyLabelList']) Type = "|".join([message['firstType'], message['secondType'], message['thirdType']]) Address = ''.join([message['city'], message['district'], ]) salary = message['salary'] positionAdvantage = message['positionAdvantage'] # limitation factor workYear = message['workYear'] jobNature = message['jobNature'] education = message['education'] items = f"{positionName}, {companyFullName}, {companySize}, {financeStage}, {companyLabelList}, {industryField}, " \ f"{Type}, {salary}, {jobNature}, {education}" # items = "".join(str( # [positionName, companyFullName, companySize, financeStage, companyLabelList, industryField, Type, salary, # jobNature, education])) if items: # print(items) logging.info(items) # return items.replace('[', '').replace(']', '') return items.replace('(', '').replace(')', '') 
                    
                      
                        
                          1
2
3
4
5

                        
                        
                          
  - 此时只需提取相关数据，即可。得到：![](https://cdn.cuiqingcai.com/wp-content/uploads/2020/04/DemoPicture3-json.png)
- ## 保存数据：

  - ## 常规保存：(保存到本地)

def save_message(item):
with open(‘lg3.csv’, ‘a+’, encoding=’gbk’) as f:
f.write(item + ‘\n’)
thread_lock.release()


- ## 数据入库：（保存到数据库）

## 在这里我选择的为 Mongo，接下来，那咱们操作一下吧。Mongo 的安装便不在此处赘述。与 mongo 相关的文章，在这里比较推荐才哥和东哥的几篇文章(以本文来看，比较建议看看这几篇文章。并没说其他不好啊，不，我没有，我没说哦)，地址如下：

- ### [如何学好 MongoDB](https://cuiqingcai.com/7121.html)
- ### [[Python3 网络爬虫开发实战] 1.4.2-MongoDB 安装](https://cuiqingcai.com/5205.html)
- ### [[Python3 网络爬虫开发实战] 1.5.2-PyMongo 的安装](https://cuiqingcai.com/5230.html)

##   前方高能预警，造！！！：(此时的你已安装了 Mongo，并能正常使用 mongo。剩下的交给我，我教你好了)

1.  ### 安装 pymongo

pip install pymongo
1
2

                  
                  
                    
2.  ### 建立连接：在原有的代码基础上改写，添加类似于如下的代码：

                  
                  
                  
                  
 MONGO_CONNECTION_STRING = 'mongodb://localhost:27017' # MONGO_DB_NAME = 'Jobs' # MONGO_COLLECTION_NAME = 'Jobs' client = pymongo.MongoClient(MONGO_CONNECTION_STRING) db = client['Jobs'] collection = db['Jobs'] 
                    
                      
                        
                          1
2
3
4

                        
                        
                          
    ![](https://cdn.cuiqingcai.com/wp-content/uploads/2020/04/Annotation-2020-04-23-101932.png)

3.  ### 新增存储方法：

                        
                      
                    
                  
 def save_data(self, date): """ save to mongodb :param date: :return: """ collection.update_one({ 'name': date.get('companyShortName') }, { '$set': date }, upsert=True) 
                    
                      
                        
                          1
2
3
4

                        
                        
                          
    ![](https://cdn.cuiqingcai.com/wp-content/uploads/2020/04/微信图片_20200423102245.png)

4.  ### 调用此方法：

                        
                      
                    
                  
 def main(): p = LaGou() for page in range(1, 31): content = p.scrape(page) data = p.parseResponse(content) download = p.save_data(data) ```

注意：由于 mongo 的存储格式为 key ：value 形式，所以咱们提取到的数据返回也必须是 key ：value 形式：

看我看我，怎么搞的，我是这样搞的：

左手叉腰，右手摇，Over！

光看文章的话，就算是我自己写的文章单单仅仅看文章也是会云里雾里，建议与源码一起阅读。祝学习进步，心想事成。加油~

写到最后：既然能读到这儿，那么我相信不是白嫖成为习惯的人，说明也或多或少想自己搞一搞。整一整？下次也出来吹吹牛皮，拉钩晓得不，反爬难吧？我会了（虽然对于大佬来说，都可能算不上反扒，和玩似的，这个确实也是的。不过吧，对于新手来说，已经算很难了。）我也是搞过拉勾的男人。找工作就找我，啊哈哈哈。

单一的案例终究只会让你局限于本次案例，如果拉钩反爬又更新了。那么这个就会失效。虽然授之以渔了，但终究是“这条小溪”，更大的海洋还需要更加刻苦努力的学习。个人比较建议学习一下

感谢阅读与支持，谢谢

作者 Payne 发表于 2020-04-15 阅读次数：本文字数： 5.2k 阅读时长 ≈ 5 分钟

Python meizi图会爬么？不会那我教你好了

meizi图会爬么？不会那我教你好了

声明：本文由一位知名的不知名Payne原创，转载请注明出处！后优化代码为52讲轻松搞定网络爬虫第一次实战课程为本节代码思路为基础，后自作聪明，书写。本章节源码仓库为：https://github.com/Payne-Wu/PythonScrape 写在最前面：本章适用于新手小白，代码规范化思路。一言不合直接上代码！具体教程及思路总代码后！所用解释器为Python3.7.1，编辑器为Pycharm 2018.3.5. 本着虚心求学，孜孜不倦，逼逼赖赖来这里虚心求学，孜孜不倦，逼逼赖赖，不喜勿喷，嘴下手下脚下都留情。

基础源码（我刚自学Python时候写的代码）

要爬就爬全站的，一两张一两个还不如另存为来的更加实际。啊哈哈哈

那咱们先来说说Meizitu的基本思路：

个人总结（四步法）：发送请求，　得到响应，　解析数据，　保存数据（比较宏观的概念）

众所周知啊（其实是个人理解）：爬虫本质为模拟浏览器发送请求，倒推过来思考既然是模拟请求，请求地址(URI)总得晓得吧。那么本次请求的URI为以下（单个图册）：
- MAIN_URL：https://www.mzitu.com/
- Atlas URL：https://www.mzitu.com/226469
- Specific URL： https://www.mzitu.com/226469/1

模拟请求，既然是模拟请求怎么也得，模拟一下吧？被站长大大晓得了那不就被关在门外了。（站长“菇凉”说：“我家是给帅气的小哥哥用户访问的，你个程序来凑一凑不太好吧？”在我脑壳后面敲了敲，后就把我拒之门外，头也不会，扬长而去）经过我苦思冥想，仿佛得到了前所未有的启发，要不我们走走后门，让这个程序做个人？如此甚好。妙哉，妙哉。。。

请求头一带谁都不爱。大叫一声还有谁，于是我就上啊。然而结果确实如此

```
url = ‘https://www.mzitu.com/‘
header =
{
“User-Agent”: “Mozilla/5.0 (Windows NT 10.0; WOW64; rv:66.0) Gecko/20100101 Firefox/66.0”
}

response = requests.get(url, headers=header) # 请求网页
print(response)

        
        reponse<200>
    *   经过我请求，他回应，他回应了爱你你（200），最后咱们握手了。菇凉，咱们还不够了解。需要多了解了解。我还没有成为无敌的男ying，我得多学习学习，争取早日娶你过门。（论一个渣男的锻炼与养成）
    *   好不容易进来了，本着虚心求教，好好学习，天天向上，不谈儿女私情的我，怎么也得有所收获吧。这是？？？渣男的修炼养成计划？这是宝贝啊！！！我得看看，学习学习。
    *   [gallery size="full" columns="1" ids="9144"]
    *   这还上锁啦？，这个可不香了。经过研究，一笑  你有你的的张良计，我有我的万能钥匙，Refer钥匙。配置Refer。走着。还不乖乖的。小意思啦。。。。就这样。
    *   [gallery size="full" columns="1" ids="9145"]

虽然不是用的同一张图片，BUT，有无图片是这Refer防盗链作祟的。 **ok，nice。** 各位看官，到这儿咱们也得进入真正的 说了这么多，让我们进入造的环节把，基础四步走，发起请求，得到响应，解析数据，保存！打完收工。 首先咱们是定义了一个自定义的用户代理，优点稳定、简单易于操作，但缺点是比较繁琐。 为什么不用from fake_useragent import UserAgent 这个主要还是因为这个模块不大稳定，我用的时候经常出错。不晓得是不是我。。。 至少我用的不太爽。而且既然自己阔以造轮子，为何不试着造一造呢？ 说说User-Agent构造思路，首先是定义了一个User-Agent列表,然后从里面随机取一，作为相对本次User—Agent。 优化后的代码是直接定义了一个请求函数，这样如果需要请求是阔以直接调用这个函数，避免代码臃肿。无脑写requests。既不提升效率，也不简洁。还看着懵。有好的自然就要给好的，有时候对自己得好点。 注意请不要忽略异常捕获哦，这样会使咱们的爬虫小伙计更加健壮。爬虫的Strong在于考虑细致，全方面。这样成为一只成年的爬虫，虽然我也不晓得谁说的，我感觉还是蛮有道理的，如果真的没有人说，那就是我吧。。。。 这里是直接定义了一个请求方法，方便需要请求的时候直接调用。即可获得请求的效果

def scrape_page(url):
logging.info(‘scraping %s…’, url)

header = User_Agent(page)

print(header)
try:
response = requests.get(url, headers=header)
return response.text
except TimeoutError as a:
logging.error(f”Error time is Out:{a}”)
except ReadTimeout as b:
logging.error(f”Error ReadTimeout: {b}”)
except HTTPError as c:
logging.error(f”Error HTTPError: {c}”)
except ConnectionError as d:
logging.error(f”Error ConnectionError: {d}”)

1
2

def scrape_index(page):
index_url = f”{BASE_URL}/page/{page}/“
return scrape_page(index_url)

2.1 解析数据（获得图册的URN）

def parseindex(html):
doc = pq(html)
links = doc(‘.postlist #pins > li > span:nth-child(2) > a’)
for link in links.items():
detailurl = link.attr(‘href’)
logging.info(‘Got detailurl %s’, detailurl)
yield detail_url
def scrape_detail(url):
return scrape_page(url)

1
2

做个简单的小结： ```python def main(page): User_Agent(page) index_html = scrape_index(page) detail_urls = parse_index(index_html) # 循环遍历提取出URI for detail_url in detail_urls：这样就可以得到所有的URI了： ... 2020-04-10 10:07:42,396 - INFO: scraping https://www.mzitu.com/206355... 2020-04-10 10:07:42,703 - INFO: Got detail_url https://www.mzitu.com/212891 2020-04-10 10:07:42,703 - INFO: scraping https://www.mzitu.com/212891... 2020-04-10 10:07:42,863 - INFO: Got detail_url https://www.mzitu.com/225494 2020-04-10 10:07:42,863 - INFO: scraping https://www.mzitu.com/225494... 2020-04-10 10:07:42,992 - INFO: Got detail_url https://www.mzitu.com/226142 2020-04-10 10:07:42,992 - INFO: scraping https://www.mzitu.com/226142... 2020-04-10 10:07:43,172 - INFO: Got detail_url https://www.mzitu.com/226078 2020-04-10 10:07:43,173 - INFO: scraping https://www.mzitu.com/226078... 2020-04-10 10:07:43,661 - INFO: Got detail_url https://www.mzitu.com/210338 2020-04-10 10:07:43,661 - INFO: scraping https://www.mzitu.com/210338... 2020-04-10 10:07:43,838 - INFO: Got detail_url https://www.mzitu.com/225958 2020-04-10 10:07:43,839 - INFO: scraping https://www.mzitu.com/225958... 2020-04-10 10:07:44,003 - INFO: Got detail_url https://www.mzitu.com/225784 2020-04-10 10:07:44,004 - INFO: scraping https://www.mzitu.com/225784... 2020-04-10 10:07:44,163 - INFO: Got detail_url https://www.mzitu.com/218827 2020-04-10 10:07:44,163 - INFO: scraping https://www.mzitu.com/218827... 2020-04-10 10:07:44,402 - INFO: Got detail_url https://www.mzitu.com/213225 ... 然后就没有然后了呗经过发现每个图集里面是后面加上page就是第几张图片，并且张数是不一样的，那怎么样解决呢？ [gallery columns="1" size="full" ids="9146"] [gallery columns="1" size="full" ids="9147"] 多观察几个发现它只显示8个，第七个就是最大的页码数了，那咱们把他提取出来，作为图集的page，放入循环不就可以拿到任意图集的所有了嘛！经过验证这是可行的。既然这些又有了，那咱们请求它，存就好啦

if __name == ‘__main‘:
for page in range(1, 2):
main(page)

1 2	最后加入多进程加快速度改写源码如下

import multiprocessing

TOTAL_PAGE 为所爬取页数

if name == ‘main‘:
pool = multiprocessing.Pool()
pages = range(1, TOTAL_PAGE + 1)
pool.map(main, pages)
pool.close()
```

写到最后：能看到这里，我相信你是非常想学的，单单看到这里是不可能学会的了，那么如果要去做，阔以尝试着与本章源码一起阅读。希望你能有所收获。如果想要更好的运用到实际生活中，以爬虫为兴趣，以此为工作。阔以学习崔老师的52讲轻松搞定网络爬虫。祝生活愉快，完事顺心。期待我们下次见面有问题，有疑问，欢迎在评论区留言，我将知无言，言无不尽。评论区期待你的出现 -Payne

作者 Payne 发表于 2020-04-11 阅读次数：本文字数： 4.6k 阅读时长 ≈ 4 分钟

技术杂谈 一行代码让网站变成灰色 CSS filter 的用法

今天是 2020 年 4 月 4 日，星期六，清明节。想必大家对今年发生的疫情有目共睹，很多英雄为了救助他人在病魔前倒下，更有很多烈士英雄保卫人民的安危遇难，今天全国下降半旗，北京时间 10 点全国默哀三分钟，来致敬英雄们。同时今天一切公共娱乐活动也都会停止，包括直播、综艺、影视、游戏等等。我也在这里也向全国抗击新冠肺炎疫情斗争牺牲的烈士和逝世的同胞表达深切的哀悼，向所有在抗战在疫情前线的工作和医护人员致敬。

网站变灰

今天大家可以看到很多很多网站包括主页和内容也都已经变成了灰色，比如百度、B 站、爱奇艺、CSDN 等等。 CSDN 大家可以看到全站的内容都变成灰色了，包括按钮、图片等等。这时候我们可能会好奇这是怎么做到的呢？有人会以为所有的内容都统一换了一个 CSS 样式，图片也全换成灰色的了，按钮等样式也统一换成了灰色样式。但你想想这个成本也太高了，而且万一某个控件忘记加灰色样式了岂不是太突兀了。其实，解决方案很简单，只需要几行代码就能搞定了。

实现

我们选择一个网站，比如 B 站吧，打开浏览器开发者工具。审查一下网页的源代码，我们可以发现在 html 的这个地方多了一个疑似的 class，叫做 gray，gray 中文即灰色。变灰效果其 CSS 内容为：

1
2
3

html.gray {
    -webkit-filter: grayscale(.95);
}

我们将其取消，就能发现网站的颜色就能重新还原回来了。还原效果果然是这个样式在起作用，而且是全局的效果，因为它是作用在了 html 这个节点之上的。另外看看 CSDN，它也是用的这个 CSS 样式，其内容为：

html {
    -webkit-filter: grayscale(100%);
    -moz-filter: grayscale(100%);
    -ms-filter: grayscale(100%);
    -o-filter: grayscale(100%);
    filter: grayscale(100%);
    filter: progid:DXImageTransform.Microsoft.BasicImage(grayscale=1);
}

这个实现看起来兼容性会更好一些。因此我们可以确定，通过一个全局的 CSS 样式就能将整个网站变成灰色效果。

分析

那么这里我们就来详细了解一下这究竟是一个什么样的 CSS 样式。这个样式名叫做 filter，搜下 MDN 的官方介绍，其链接为：https://developer.mozilla.org/zh-CN/docs/Web/CSS/filter。官方介绍内容如下：

filter CSS 属性将模糊或颜色偏移等图形效果应用于元素。滤镜通常用于调整图像，背景和边框的渲染。 CSS 标准里包含了一些已实现预定义效果的函数。你也可以参考一个 SVG 滤镜，通过一个 URL 链接到 SVG 滤镜元素 (SVG filter element)。

其实就是一个滤镜的意思。官方有一个 Demo，可以看下效果，如图所示。 Demo 比如这里通过 filter 样式改变了图片、颜色、模糊、对比度等等信息。其所有用法示例如下：

/* URL to SVG filter */
filter: url("filters.svg#filter-id");

/* <filter-function> values */
filter: blur(5px);
filter: brightness(0.4);
filter: contrast(200%);
filter: drop-shadow(16px 16px 20px blue);
filter: grayscale(50%);
filter: hue-rotate(90deg);
filter: invert(75%);
filter: opacity(25%);
filter: saturate(30%);
filter: sepia(60%);

/* Multiple filters */
filter: contrast(175%) brightness(3%);

/* Global values */
filter: inherit;
filter: initial;
filter: unset;

各个用法介绍大家可以参考官方的文档说明：https://developer.mozilla.org/zh-CN/docs/Web/CSS/filter 比如这里如果我们可以使用 blur 设置高斯模糊，用法如下：

1	filter: blur(radius)

给图像设置高斯模糊。radius 一值设定高斯函数的标准差，或者是屏幕上以多少像素融在一起，所以值越大越模糊；如果没有设定值，则默认是 0；这个参数可设置绝对像素值，但不接受百分比值。可以达成这样的效果：再说回刚才的灰色图像，这里其实就是设置了 grayscale，其用法如下：

1	filter: grayscale(percent)

将图像转换为灰度图像。值定义转换的比例。percent 值为 100% 则完全转为灰度图像，值为 0% 图像无变化。值在 0% 到 100% 之间，则是效果的线性乘子。若未设置，值默认是 0。另外除了传递百分比，还可以传递浮点数，效果是一样的。如：

1 2	filter: grayscale(1) filter: grayscale(100%)

都可以将节点转化为 100% 的灰度模式。所以一切到这里就清楚了，如果我们想要把全站变成灰色，再考虑到各浏览器兼容写法，可以参考下 CSDN 的写法：

.gray {
    -webkit-filter: grayscale(100%);
    -moz-filter: grayscale(100%);
    -ms-filter: grayscale(100%);
    -o-filter: grayscale(100%);
    filter: grayscale(100%);
    filter: progid:DXImageTransform.Microsoft.BasicImage(grayscale=1);
}

这样想要变灰的节点只需要加上 gray 这个 class 就好了，比如加到 html 节点上就可以全站变灰了。最后呢，看一下浏览器对 filter 这个样式的兼容性怎样，如图所示：这里我们看到，这里除了 IE，其他的 PC、手机端的浏览器都支持了，Firefox 的 PC、安卓端还单独对 SVG 图像加了支持，可以放心使用。

总结

本篇文章简单介绍了一下今天观察到的网站变灰的实现，也学习了 filter 的更详细的用法，希望有帮助。

作者崔庆才发表于 2020-04-09 阅读次数：本文字数： 2.7k 阅读时长 ≈ 2 分钟

技术杂谈 Python 中异常处理库 merry 的用法

写程序时，异常处理是在所难免的，但你有没有考虑过怎样让异常处理机制变得扩展性更好，让写法更优雅呢？

实例引入

比如写 Python 的时候，举个最简单的算术运算和文件写入的例子，代码如下：

def process(num1, num2, file):
    result = num1 / num2
    with open(file, 'w', encoding='utf-8') as f:
        f.write(str(result))

这里我们定义了一个 process 方法，接收三个参数，前两个参数是 num1 和 num2，第三个参数是 file。这个方法会首先将 num1 除以 num2，然后把除法的结果写入到 file 文件里面。好，就这么一个简单的操作，但是这个实现真的是漏洞百出：

没有判断 num1、num2 的类型，如果不是数字类型，那会抛出 TypeError。
没有判断 num2 是不是 0，如果是 0，那么会抛出 ZeroDivisionError。
没有判断文件路径是否存在，如果是子文件夹下的路径，文件夹不存在的话，会抛出 FileNotFoundError。

一些异常测试用例如下：

1
2
3

process(1, 2, 'result/result.txt')
process(1, 0, 'result.txt')
process(1, [2], 'result.txt')

这些用例跑起来一定是会报错的。如果面试写出来这个代码，肯定就挂了。当然最好的方式是通过一些判断条件把一些该处理的问题和判定都加上。但这里我们为了说异常处理，如果把这几类的错误都进行异常处理的话，会写成什么样子呢？由于 Python 的语法是有缩进的，所以我们可能会首先将这些代码缩进四个空格，然后外面包上一个 try 和 except，可能写成这个样子：

def process(num1, num2, file):
    try:
        result = num1 / num2
        with open(file, 'w', encoding='utf-8') as f:
            f.write(str(result))
    except ZeroDivisionError:
        print(f'{num2} can not be zero')
    except FileNotFoundError:
        print(f'file {file} not found')
    except Exception as e:
        print(f'exception, {e.args}')

这时候我们观察到了什么问题？

代码一下子臃肿了起来，这里的异常处理都没有实现，仅仅是 print 了一些错误信息，但现在可以看到我们的异常处理代码可能比主逻辑还要多。
主逻辑代码整块被硬生生地缩进进去了，如果主逻辑代码比较多的话，那么会有大片大片的缩进。
如果再有相同的逻辑的代码，难道要再写一次 try except 这一坨代码吗？

可能很多人都在面临这样的困扰，觉得代码很难看但又不知道怎么修改。当然上面的代码写法本身就不好，有几种改善的方案：

本身这个场景不需要这么多异常处理，使用判断条件把一些意外情况处理掉就好。
异常处理本身就不应该这么写，每个功能区域应该和异常处理单独分开，另外各个逻辑模块建议再分方法解耦。
使用 retrying 模块检测异常并进行重试。
使用上下文管理器 raise_api_error 来声明异常处理。

但上面的一些解决方案其实还不能彻底解决代码复用和美观上的问题，比如某一类的异常处理我就统一在一个地方处理，另外我的任何代码都不想因为异常处理产生缩进。那对于这样的问题，有没有解决方案呢？有。下面我们来了解一个库，叫做 Merry。

Merry

Merry，这个库是 Python 的一个第三方库，非常小巧，它实现了几个装饰器。通过使用 Merry 我们可以把异常检查和异常处理的代码分开，并可以通过装饰器来定义异常检查和处理的逻辑。 GitHub 地址：https://github.com/miguelgrinberg/merry，这个库的安装非常简单，使用 pip3 安装即可：

1	pip3 install merry

有了这个库之后，上面的异常检查代码我们就可以这么来实现了，代码如下：

from merry import Merry

merry = Merry()
merry.logger.disabled = True

@merry._try
def process(num1, num2, file):
    result = num1 / num2
    with open(file, 'w', encoding='utf-8') as f:
        f.write(str(result))

@merry._except(ZeroDivisionError)
def process_zero_division_error(e):
    print('zero_division_error', e)

@merry._except(FileNotFoundError)
def process_file_not_found_error(e):
    print('file_not_found_error', e)

@merry._except(Exception)
def process_exception(e):
    print('exception', type(e), e)

if __name__ == '__main__':
    process(1, 2, 'result/result.txt')
    process(1, 0, 'result.txt')
    process(1, 2, 'result.txt')
    process(1, [1], 'result.txt')

这里我们可以看到，我们首先声明了一个 Merry 对象，然后 process 方法加上 merry 对象的 _try 方法的装饰器，这样就实现了异常的监听。有了异常监听之后，怎么来进行异常处理呢？还是通过同一个 merry 对象，使用其 _except 方法作为装饰器即可。比如这里我们将几个异常处理方法分开了，如处理 ZeroDivisionError、FileNotFoundError、Exception 等异常分别都有一个方法的声明，分别加上对应的装饰器即可。这样的话，我们就轻松实现了异常监听和处理了。和上面比有什么不同呢？

主逻辑里面不用额外加异常处理代码了，显得简洁。
主逻辑不用因为 try except 而缩进了。
每个异常处理方法单独分开了，可以实现解耦和重用。

整个实现就舒服多了。运行一下上面的代码，输出结果如下：

1
2
3

file_not_found_error [Errno 2] No such file or directory: 'result/result.txt'
zero_division_error division by zero
exception <class 'TypeError'> unsupported operand type(s) for /: 'int' and 'list'

完全没问题，可以看到每个异常都被正常地捕获到了。舒服，代码变得更优雅了。

类实现

虽然上面的实现相比最初已经好了很多了，但是整个看起来结构比较松散，代码不好复用，能不能把它封装成一个类来实现呢？如果封装好了类之后，我们就可以直接把类拿过来使用，实现的时候继承这个类，就不用再关心各个异常处理是怎么实现的了。在这里一个简单的实现如下：

import requests
from merry import Merry
from requests import ConnectTimeout

merry = Merry()
merry.logger.disabled = True
catch = merry._try

class BaseClass(object):

    @staticmethod
    @merry._except(ZeroDivisionError)
    def process_zero_division_error(e):
        print('zero_division_error', e)

    @staticmethod
    @merry._except(FileNotFoundError)
    def process_file_not_found_error(e):
        print('file_not_found_error', e)

    @staticmethod
    @merry._except(Exception)
    def process_exception(e):
        print('exception', type(e), e)

    @staticmethod
    @merry._except(ConnectTimeout)
    def process_connect_timeout(e):
        print('connect_timeout', e)

class Calculator(BaseClass):

    @catch
    def process(self, num1, num2, file):
        result = num1 / num2
        with open(file, 'w', encoding='utf-8') as f:
            f.write(str(result))

class Fetcher(BaseClass):

    @catch
    def process(self, url):
        response = requests.get(url, timeout=1)
        if response.status_code == 200:
            print(response.text)

if __name__ == '__main__':
    c = Calculator()
    c.process(1, 0, 'result.txt')

    f = Fetcher()
    f.process('http://notfound.com')

这里我们看到，我们先实现了一个 BaseClass，里面通过 merry 定义了好多个异常处理方法和处理流程，异常处理方法定义成 staticmethod。接着我们定义了两个类，一个是 Calculator，一个是 Fetcher，分别完成不同的功能，一个是计算，一个是抓取网页。另外 Merry 的 _try 方法我们给它取了个别名，比如叫做 catch，显得更简洁。在 process 方法中，我们我们想要进行异常处理，那么就加上 @catch 这装饰器就好了，其他的不需要管。这样，我们在实现子类的时候，只需要集成 BaseClass 然后实现对应的方法就好了，如果想加上异常处理就加个装饰器，也无需再关心 Merry 的具体实现，父类都帮我们实现好了，这样就方便多了。运行结果如下：

1
2

zero_division_error division by zero
connect_timeout HTTPConnectionPool(host='notfound.com', port=80): Max retries exceeded with url: / (Caused by ConnectTimeoutError(<urllib3.connection.HTTPConnection object at 0x10d5b9310>, 'Connection to notfound.com timed out. (connect timeout=1)'))

运行之后我们发现也正常输出了对应的错误信息。

数据传递

有人会问了，利用 try except 我们可以直接获取异常代码的变量信息，分了方法之后，一些上下文的变量不就拿不到了吗？这的确是个问题，Merry 是用了一个全局的变量来解决的，它使用了 merry.g 这个对象来存储上下文的变量，在主逻辑方法里面要把想要传递的参数赋值进去，在异常处理的方法里面再用 merry.g 取出来，官方示例写法如下：

@merry._try
def app_logic():
    db = open_database()
    merry.g.database = db  # save it in the error context just in case
    # do database stuff here

@merry._except(Exception)
def catch_all():
    db = getattr(merry.g, 'database', None)
    if db is not None and is_database_open(db):
        close_database(db)
    print('Unexpected error, quitting')
    sys.exit(1)

但我个人觉得这个写法很鸡肋，我个人觉得应该能获取主逻辑方法里面的 context 对象，context 里面包含了主逻辑方法里面的变量状态，然后异常处理的方法的某个参数可以接收到这个 context 对象，就能直接获取变量值了。不过这只是个个人想法，还没有实现，有兴趣的朋友可以试试。

源码剖析

最后，我们来看看它的源码吧，其实源码就这么多：

from functools import wraps
import inspect
import logging

getargspec = None
if getattr(inspect, 'getfullargspec', None):
    getargspec = inspect.getfullargspec
else:
    # this one is deprecated in Python 3, but available in Python 2
    getargspec = inspect.getargspec

class _Namespace:
    pass

class Merry(object):
    def __init__(self, logger_name='merry', debug=False):
        self.logger = logging.getLogger(logger_name)
        self.g = _Namespace()
        self.debug = debug
        self.except_ = {}
        self.force_debug = []
        self.force_handle = []
        self.else_ = None
        self.finally_ = None

    def _try(self, f):
        @wraps(f)
        def wrapper(*args, **kwargs):
            ret = None
            try:
                ret = f(*args, **kwargs)

                # note that if the function returned something, the else clause
                # will be skipped. This is a similar behavior to a normal
                # try/except/else block.
                if ret is not None:
                    return ret
            except Exception as e:
                # find the best handler for this exception
                handler = None
                for c in self.except_.keys():
                    if isinstance(e, c):
                        if handler is None or issubclass(c, handler):
                            handler = c

                # if we don't have any handler, we let the exception bubble up
                if handler is None:
                    raise e

                # log exception
                self.logger.exception('[merry] Exception caught')

                # if in debug mode, then bubble up to let a debugger handle
                debug = self.debug
                if handler in self.force_debug:
                    debug = True
                elif handler in self.force_handle:
                    debug = False
                if debug:
                    raise e

                # invoke handler
                if len(getargspec(self.except_[handler])[0]) == 0:
                    return self.except_[handler]()
                else:
                    return self.except_[handler](e)
            else:
                # if we have an else handler, call it now
                if self.else_ is not None:
                    return self.else_()
            finally:
                # if we have a finally handler, call it now
                if self.finally_ is not None:
                    alt_ret = self.finally_()
                    if alt_ret is not None:
                        ret = alt_ret
                    return ret
        return wrapper

    def _except(self, *args, **kwargs):
        def decorator(f):
            for e in args:
                self.except_[e] = f
            d = kwargs.get('debug', None)
            if d:
                self.force_debug.append(e)
            elif d is not None:
                self.force_handle.append(e)
            return f
        return decorator

    def _else(self, f):
        self.else_ = f
        return f

    def _finally(self, f):
        self.finally_ = f
        return f

这里最主要的逻辑都在 _try 方法里面了，它主要做了什么事呢？其实就是仿照这标准的 try、except、else、finally 方法把流程实现下来了，只不过在对应的逻辑区块里面调用了装饰器修饰的方法。其中有一个地方比较有意思：

handler = None
for c in self.except_.keys():
    if isinstance(e, c):
        if handler is None or issubclass(c, handler):
            handler = c

这里是为异常处理找寻一个最佳的异常处理方法，可以看到这里通过各个 _except 修饰的方法，然后通过 issubclass 方法来找寻最小能处理的子类，最终找到最佳匹配方法，实现有点妙。好了，本节整体介绍了 Merry 这个库的基本使用，利用它我们可以使得 Python 的异常处理变得更优雅可扩展，来试试吧。更多的用法可以看官方的说明 https://github.com/miguelgrinberg/merry 或者源码，谢谢。希望对大家有帮助。

作者崔庆才发表于 2020-04-09 阅读次数：本文字数： 7.7k 阅读时长 ≈ 7 分钟

技术杂谈 利用 PyCharm 实现本地代码和远端的实时同步

我们知道在国内使用 Docker，无论是 Pull、Build 还是 Push 镜像都十分慢，因为毕竟很多源都是国外的源，下载和上传慢是必然的现象。最近我在写的项目都是用 Docker 运行起来的，在测试的时候，我可能需要先 Build 一下然后跑起来测试下逻辑有没有问题。在我自己本地机器上构建就有这么几个问题，一个问题当然就是速度慢，我用的肯定是国内的上网线路，有时候用个新镜像，半天 Pull 不下来，而且有的镜像是一些私有镜像，不好弄加速器，有的公开镜像试了几个加速器效果也不理想。另外一个问题当 Build 镜像的时候，如果涉及到一些编译的过程，就会占用我的本地机器的 CPU 资源，有时候搞得还挺卡。所以，我干嘛不把这些 Build 的过程挪到服务器上来搞呢？如果我有一台国外的服务器，还能解决速度问题，另外还不会占用我本地机器的 CPU 资源。但问题是，我要在自己机器上写代码呀，编译和运行又在远端，那代码怎么同步到远端呢？那么本节就来介绍下一种本地代码实时同步远程服务器的方法吧。其实这个功能我用了好久了，但之前一直用起来感觉略鸡肋，因为免不了的还需要在远端配置一下运行环境才能跑，不过后来切到 Docker 运行的话，就舒服多了。如果大家用 Docker 运行项目的话，推荐大家可以试下。

要求

在这开始之前要求有一台远程 Linux 服务器，安装好 Docker 即可。另外当然还需要能 SSH 远程访问，这是必须的。另外如果是海外的服务器是最好的了，构建镜像速度会更快。另外这里我是用 PyCharm 实现的远程同步功能，如果大家写 Python 多的话当然是推荐 PyCharm。不过其他的 JetBrains IDE 也基本都带着这个功能，所以如果用其他的 JetBrains IDE 也是 OK 的。注意，这里必须要用的是专业版，只有专业版才有这个功能。

配置

好，我们要实现的是本地代码实时同步服务器的功能。利用 PyCharm 自带的组件我们轻松实现这个功能。 PyCharm 有一个 SFTP 部署模块，可以帮助我们把本地的代码实时同步到远端。好，首先 PyCharm 打开任意一个项目，在这里我就以自己的项目为例了。项目预览接着我们点击 PyCharm 的 Tools -> Deployment -> Configuration，这里我们可以配置远程 SFTP 服务器，如图所示：打开之后是这样子，这里选择 SFTP，然后填入服务器的连接信息，如图所示：配置信息在这里可以点「TEST CONNECTION」测试下是否能够连接成功。 OK，配置完了之后，我们已经成功添加好了一台远程服务器了，比如我这里就添加了一台我自己的服务器，Host 为 vm1.cuiqingcai.com。既然要实现本地和服务器文件同步，那么当然必须要指定本地项目文件夹和远程哪个文件夹同步吧。在哪里指定呢？切换到第二个选项卡，Mappings，如图所示：这里我们可以通过选择 LocalPath 和 Deployment Path 分别指定本地和远程的文件夹名称。注意这里后者指的是相对服务器工作目录的路径。好了，就是这样，基本配置就完成了。如果你还想配置某些路径不同步的话，还可以在第三个选项卡 Excluded Paths 里面配置。接着，还有一些可以配置的地方，点击 Tools -> Deployment -> Options 我们可以配置更多细节，如图所示：细节配置比如这里我就配置了下什么时候上传，这里我改成了按 Ctrl + S 保存的时候再上传，这样我可以自由控制上传的时机。另外这里还需要把自动上传勾选上，如图所示：好了，整个都配置好啦。

测试

接下来我们上传下试试吧，可以点菜单里面的 Upload to 选项来上传代码。点击上传之后，PyCharm 会单独开一个 File Transfer 窗口来显示文件上传的结果，如图所示：上传结果这样就上传完毕了。接着我们任意修改一个文件，按保存，即 Ctrl + S，这里就出现了自动上传的日志，提示某个文件被上传成功了。自动上传测试 OK，验证没问题。

远程 SSH

当然 PyCharm 还提供了远程 SSH Termial 的功能，直接点选 Tools -> Start SSH Session 即可，如图所示：点了之后就会提示选择哪个远程服务器，选了之后，下方 Terminal 就弹出来了，和普通的 SSH Shell 一模一样。 SSH Terminal OK，接下来要构建镜像，我只需要运行对应的 docker-compose 命令就好了，速度瞬间就上来了，我再也不用看着龟速的下拉速度而发愁了，而不用担心本地机器的资源消耗了。构建过程 OK，美滋滋。构建完了运行之后，直接远程访问就好了。

注意：这里记得把服务器的安全组限制打开，以免出现远程端口无法访问的问题。

好，以上就是利用 PyCharm 实现代码实时远程同步的方法，大家也来试试吧。

作者崔庆才发表于 2020-04-09 阅读次数：本文字数： 1.9k 阅读时长 ≈ 2 分钟

Python 推荐一些实用的的 Python 库

一门语言好用、方便的程度在很多时候会取决于这门语言相关的库够不够丰富，Python 之所以火爆除了其本身的语法和特性之外，还在一定程度上取决于其有太多太多库的支持，不论是官方维护的还是第三方开发的。就比如说做机器学习为什么很多人都用 Python，一个非常大的因素就是 TensorFlow 和 PyTorch 对 Python 的支持。当然在这里并不是说 Python 的库真的就全的不要不要的，它在某些领域或者项目的生态还是有待完善的。正好昨天刷到知乎一个问题「你见过哪些相见恨晚的 Python 库？」，其意就是想了解下有哪些非常好用的提高生产力的 Python 库。一些回答直接把 awesome-python 贴过来，点赞非常多，当然多归多，但是里面很多都是些过期的或者其实没太有什么价值的库，反而会增加了挑选库的成本。我大体上把一些回答过了一遍，另外结合自己平时了解的内容，稍微对一些基础生产力库做了简单的梳理，在这里分享给大家。所以这里就不再针对于一些特殊的场景推荐了，如一些 Web开发库、网络请求库、数据操作库、数据分析库、机器分析库等等。下面主要罗列一些适用范围和方向较广，对于一些基础设施的建设比较有用，能在多数场景下提高 Python 生产力的库，描述比较简单，主要是提供一个列表，仅供参考哈。

attrs、cattrs

GitHub：https://github.com/python-attrs/attrs、https://github.com/Tinche/cattrs 简化类的定义、序列化反序列化等操作。个人写的简介：https://mp.weixin.qq.com/s/oHK-Y4lOeaQCFtDWgqXxFA

loguru

GitHub：https://github.com/Delgan/loguru 可简化日志记录写法。个人写的简介：https://mp.weixin.qq.com/s/5Ri1WS5cTGCNAQ0I_zYycg

autopep8

GitHub：https://github.com/hhatto/autopep8 把 Python 代码转成符合 PEP8 规范的代码。

psutil

GitHub：https://github.com/giampaolo/psutil Python 实现任务监控的库。

furl

GitHub：https://github.com/gruns/furl 对 url 的处理非常方便，比 urllib 等库好用多。

retrying、tenacity

GitHub：https://github.com/rholder/retrying、https://github.com/jd/tenacity 异常重试库，如出错之后重试多少次，尤其在发起一些 HTTP 请求时非常有用，当然也能用于其他地方。

typing

Docs：https://docs.python.org/zh-cn/3/library/typing.html#module-typing 对 Python 类型的支持，支持多种类型、嵌套类型，也推荐多多使用 Python 的类型注解。

argparse

Docs：https://docs.python.org/zh-cn/3/library/argparse.html 个人曾经使用过几个命令行解析工具，如 docopt，但后来还是转回来了 argparse，功能齐全强大。

absl-py

GitHub：https://github.com/abseil/abseil-py 个人感觉比 argparse 更易用的库，如 TensorFlow 就在使用这个，对于定义一些 Flag 非常方便。

pipenv

GitHub：https://github.com/pypa/pipenv 功能更全的包管理工具，集成虚拟环境、支持 Lock 机制锁定安装包版本和依赖信息。当然也有坑点，可自行搜索。

drf

Docs：https://www.django-rest-framework.org/ 基于 Django 的 REST Framework，快速实现 REST API。

watchdog

GitHub：https://github.com/gorakhargosh/watchdog 方便监视文件系统改动。

glob

Docs：https://docs.python.org/3/library/glob.html 对文件的操作非常方便。

2to3

Docs：https://docs.python.org/2/library/2to3.html 把 Python2 代码转成 Python3 代码。

glom

GitHub：https://github.com/mahmoud/glom 对 JSON 嵌套的处理非常方便。

pathlib

Docs：https://docs.python.org/3/library/pathlib.html 更为方便的 Python 路径操作库。

environs

GitHub：https://github.com/sloria/environs 对于环境变量的获取非常方便，支持多种类型，如 int、bool 等。

pysnooper

GitHub：https://github.com/cool-RR/PySnooper 非常方便简单的 Python 调试器，可以追踪到代码每一处细节的执行状态。

tqdm

GitHub：https://github.com/tqdm/tqdm 进度条控制显示非常方便。

sh

GitHub：https://github.com/amoffat/sh 对 Linux 一些命令的封装，简单好用又高效。

faker

GitHub：https://github.com/joke2k/faker 模拟数据的生成。个人写的简介：https://mp.weixin.qq.com/s/iLjr95uqgTclxYfWWNxrAA

arrow、dateutil、dateparser、pendulum

GitHub：https://github.com/crsmithdev/arrow、https://github.com/dateutil/dateutil、https://github.com/scrapinghub/dateparser、https://github.com/sdispater/pendulum 时间解析和处理库，非常方便。arrow 目前 Star 最多，好评最多。

yagmail

GitHub：https://github.com/kootenpv/yagmail 方便的发邮件库，替代自带的 smtplib。

chardet

GitHub：https://github.com/chardet/chardet 字符串类型编码检测。

pypinyin

GitHub：https://github.com/mozillazg/python-pinyin 汉字转拼音，在一些中文转化处理上很有用。个人写的简介：https://mp.weixin.qq.com/s/NvA3j8Ns1-6CFgWpUcWwQw

sphinx

Docs：https://www.sphinx-doc.org/en/master/ 编写文档使用，大多数 Python 库文档都是这个写的，如 Scrapy、requests。个人 sphinx + markdown 的样例：https://github.com/Gerapy/Docs

jinja2

GitHub：https://github.com/pallets/jinja 一个方便的模板引擎，呈现页面时很方便。

click

GitHub：https://github.com/pallets/click 更方便灵活地实现命令行传递参数。

ray

GitHub：https://github.com/ray-project/ray 分布式多进程管理。

supervisor

GitHub：https://github.com/Supervisor/supervisor 进程管理工具，如实现多任务后台运行，Docker 打包时会经常用到。

apscheduler

GitHub：https://github.com/agronholm/apscheduler Python 定时任务，不过 K8S 也可以实现，个人目前可能更倾向于 K8S。

intelpython

Home：https://software.intel.com/en-us/distribution-for-python 这不是 Python 库，是一个 Intel 开发的基于 Intel 处理器优化的 Python 解释器，对于大规模运算提升很大。先推荐这么多了，后面还会慢慢积累，大家可以了解下，有不少库还是能极大提高生产力的。由于这次主要是推荐一些适用范围和方向较广，个人感觉对于一些基础设施的建设比较有用的库，所以一些 Web、爬虫、数据分析、机器学习等库就没有列在这里了。当然也由于个人水平有限，也有很多库没有列全，如果大家有推荐的，欢迎留言分享哈！

作者崔庆才发表于 2020-03-20 阅读次数：本文字数： 3.7k 阅读时长 ≈ 3 分钟

技术杂谈 爬虫工程师学习养成路径

当今大数据的时代，网络爬虫已经成为了获取数据的一个重要手段。但要学习好爬虫并没有那么简单。首先知识点和方向实在是太多了，它关系到了计算机网络、编程基础、前端开发、后端开发、App 开发与逆向、网络安全、数据库、运维、机器学习、数据分析等各个方向的内容，它像一张大网一样把现在一些主流的技术栈都连接在了一起。正因为涵盖的方向多，因此学习的东西也非常零散和杂乱，很多初学者搞不清楚究竟要学习哪些知识，学习过程中遇到反爬也不知道用什么方法来解决，本篇我们来做一些归纳和总结。

初学爬虫

一些最基本的网站，往往不带任何反爬措施。比如某个博客站点，我们要爬全站的话就顺着列表页爬到文章页，再把文章的时间、作者、正文等信息爬下来就可以了。那代码怎么写呢？用 Python 的 requests 等库就够了，写一个基本的逻辑，顺着把一篇篇文章的源码获取下来，解析的话用 XPath、BeautifulSoup、PyQuery 或者正则表达式，或者粗暴的字符串匹配把想要的内容抠出来，再加个文本写入存下来就完事了。代码很简单，就几个方法调用。逻辑很简单，几个循环加存储。最后就能看到一篇篇文章就被我们存到自己的电脑里面了。当然有的同学可能不太会写代码或者都懒得写，那么利用基本的可视化爬取工具，如某爪鱼、某裔采集器也能通过可视化点选的方式把数据爬下来。如果存储方面稍微扩展一下的话，可以对接上 MySQL、MongoDB、Elasticsearch、Kafka 等等来保存数据，实现持久化存储。以后查询或者操作会更方便。反正，不管效率如何，一个完全没有反爬的网站用最最基本的方式就搞定了。到这里，你就说你会爬虫了吗？不，还差的远呢。

Ajax、动态渲染

随着互联网的发展，前端技术也在不断变化，数据的加载方式也不再是单纯的服务端渲染了。现在你可以看到很多网站的数据可能都是通过接口的形式传输的，或者即使不是接口那也是一些 JSON 的数据，然后经过 JavaScript 渲染得出来的。这时候，你要再用 requests 来爬那就不顶用了，因为 requests 爬下来的源码是服务端渲染得到的，浏览器看到页面的和 requests 获取的结果是不一样的。真正的数据是经过 JavaScript 执行的出来的，数据来源可能是 Ajax，也可能是页面里的某些 Data，也可能是一些 ifame 页面等等，不过大多数情况下可能是 Ajax 接口获取的。所以很多情况下需要分析 Ajax，知道这些接口的调用方式之后再用程序来模拟。但是有些接口带着加密参数，比如 token、sign 等等，又不好模拟，咋整呢？一种方法就是去分析网站的 JavaScript 逻辑，死抠里面的代码，揪出来这些参数是怎么构造的，找出思路来了之后再用爬虫模拟或重写就行了。如果你解出来了，那么直接模拟的方式效率会高非常多，这里面就需要一些 JavaScript 基础了，当然有些网站加密逻辑做的太牛逼了，你可能花一个星期也解不出来，最后放弃了。那这样解不出来或者不想解，那咋办呢？这时候可以有一种简单粗暴的方法就是直接用模拟浏览器的方式来爬取，比如用 Puppeteer、Pyppeteer、Selenium、Splash 等，这样爬取到的源代码就是真正的网页代码，数据自然就好提取了，同时也就绕过分析 Ajax 和一些 JavaScript 逻辑的过程。这种方式就做到了可见即可爬，难度也不大，同时模拟了浏览器，也不太会有一些法律方面的问题。但其实后面的这种方法也会遇到各种反爬的情况，现在很多网站都会去识别 webdriver，看到你是用的 Selenium 等工具，直接干掉或不返回数据，所以你碰到这种网站还得来专门解一下这个问题。

多进程、多线程、协程

上面的情况如果用单线程的爬虫来模拟是比较简单的，但是有个问题就是速度慢啊。爬虫是 IO 密集型的任务，所以可能大多数情况下都在等待网络的响应，如果网络响应速度慢，那就得一直等着。但这个空余的时间其实可以让 CPU 去做更多事情。那怎么办呢？多开点线程吧。所以这时候我们就可以在某些场景下加上多进程、多线程，虽然说多线程有 GIL 锁，但对于爬虫来说其实影响没那么大，所以用上多进程、多线程都可以成倍地提高爬取速度，对应的库就有 threading、multiprocessing 了。异步协程就更牛逼了，用 aiohttp、gevent、tornado 等等的基本上你想搞多少并发就搞多少并发，但是还是悠着点，别把人家网站搞挂了。总之，用上这几个，爬虫速度就提上来了。但速度提上来了不一定是好事，反爬接着肯定就要来了，封你 IP、封你账号、弹验证码、返回假数据，所以有时候龟速爬似乎也是个解决办法？

分布式

多线程、多进程、协程都能加速，但终究还是单机的爬虫。要真正做到规模化，还得来靠分布式爬虫来搞。分布式的核心是什么？资源共享。比如爬取队列共享、去重指纹共享等等。我们可以使用一些基础的队列或组件来实现分布式，比如 RabbitMQ、Celery、Kafka、Redis 等等，但经过很多人的尝试，自己去实现一个分布式爬虫，性能和扩展性总会出现一些问题，当然特别牛逼的除外哈。不少企业内部其实也有自己开发的一套分布式爬虫，和业务更紧密，这种当然是最好了。现在主流的 Python 分布式爬虫还是基于 Scrapy 的，对接 Scrapy-Redis、Scrapy-Redis-BloomFilter 或者用 Scrapy-Cluster 等等，他们都是基于 Redis 来共享爬取队列的，总会多多少少遇到一些内存的问题。所以一些人也考虑对接到了其他的消息队列上面，比如 RabbitMQ、Kafka 等等，解决一些问题，效率也不差。总之，要提高爬取效率，分布式还是必须要掌握的。

验证码

爬虫难免遇到反爬，验证码就是其中之一。要会反爬，那首先就要会解验证码。现在你可以看到很多网站都会有各种各样的验证码了，比如最简单的图形验证码，要是验证码的文字规整的话，OCR 过一遍或者基本的模型库都能识别，不想搞这个的话可以直接去对接个打码平台来搞，准确率还是有的。然而你可能现在都见不到什么图形验证码了，都是一些行为验证码，如某验、某盾等等，国外也有很多，比如 reCaptcha 等等。一些稍微简单一点的，比如滑动的，你可以找点办法识别缺口，比如图像处理比对、深度学习识别都是可以的。轨迹呢自己写个模拟正常人行为的，加点抖动之类的。有了轨迹之后咋模拟呢，如果你牛逼，那么可以直接去分析验证码的 JavaScript 逻辑，把轨迹数据录入，那就能得到里面的一些加密参数，直接拿着这些参数放到表单或接口里面就能直接用了。当然也可以用模拟浏览器的方式来拖动，也能通过一定的方式拿到加密参数，或者直接用模拟浏览器的方式把登录一起做了，拿着 Cookies 来爬也行。当然拖动只是一种验证码，还有文字点选、逻辑推理等，要是真不想搞，可以找打码平台来解出来再模拟，但毕竟花钱的，一些高手就会选择自己训练深度学习相关的模型，收集数据、标注、训练，针对不同的业务训练不同的模型。这样有了核心技术，也不用再去花钱找打码平台了，再研究下验证码的逻辑模拟一下，加密参数就能解出来了。不过有的验证码难得很，有的我也没搞定。当然有些验证码可能是请求过于频繁而弹出来的，这种如果换个 IP 什么的也能解。

封 IP

封 IP 也是个令人头疼的事，行之有效的方法就是换代理了。代理很多种，市面上免费的，收费的太多太多了。首先可以把市面上免费的代理用起来，自己搭建一个代理池，收集现在全网所有的免费代理，然后加一个测试器一直不断测试，测试的网址可以改成你要爬的网址。这样测试通过的一般都能直接拿来爬你的目标网站。我自己也搭建过一个代理池，现在对接了一些免费代理，定时爬、定时测，还写了个 API 来取，放在 GitHub 了：https://github.com/Python3WebSpider/ProxyPool，打好了 Docker 镜像，提供了 Kubernetes 脚本，大家可以直接拿来用。付费代理也是一样，很多商家提供了代理提取接口，请求一下就能获取几十几百个代理，我们可以同样把它们接入到代理池里面。但这个代理也分各种套餐，什么开放代理、独享代理等等的质量和被封的几率也是不一样的。有的商家还利用隧道技术搭了代理，这样代理的地址和端口我们是不知道的，代理池是由他们来维护的，比如某布云，这样用起来更省心一些，但是可控性就差一些。还有更稳定的代理，比如拨号代理、蜂窝代理等等，接入成本会高一些，但是一定程度上也能解决一些封 IP 的问题。不过这些背后也不简单，为啥一个好好的高匿代理就是莫名其妙爬不了，背后的一些事就不多讲了。

封账号

有些信息需要模拟登录才能爬嘛，如果爬的过快，人家网站直接把你的账号封禁了，就啥都没得说了。比如爬公众号的，人家把你 WX 号封了，那就全完了。一种解决方法当然就是放慢频率，控制下节奏。还有种方法就是看看别的终端，比如手机页、App 页、wap 页，看看有没有能绕过登录的法子。另外比较好的方法，那就是分流。如果你号足够多，建一个池子，比如 Cookies 池、Token 池、Sign 池反正不管什么池吧，多个账号跑出来的 Cookies、Token 都放到这个池子里面，用的时候随机从里面拿一个。如果你想保证爬取效率不变，那么 100 个账号相比 20 个账号，对于每个账号对应的 Cookies、Token 的取用频率就变成原来的了 1/5，那么被封的概率也就随之降低了。

奇葩的反爬

上面说的是几种比较主流的反爬，当然还有非常多奇葩的反爬。比如返回假数据、返回图片化数据、返回乱序数据、返回骂人的数据、返回求饶的数据，那都具体情况看着办吧。这些反爬也得小心点，之前见过一个反爬直接返回 rm -rf / 的也不是没有，你要是正好有个脚本模拟执行返回结果，后果自己想象哈。

JavaScript 逆向

说到重头了。随着前端技术的进步和网站反爬意识的增强，很多网站选择在前端上下功夫，那就是在前端对一些逻辑或代码进行加密或混淆。当然这不仅仅是为了保护前端的代码不被轻易盗取，更重要的是反爬。比如很多 Ajax 接口都会带着一些参数，比如 sign、token 等等，这些前文也讲过了。这种数据我们可以用前文所说的 Selenium 等方式来爬，但总归来说效率太低了，毕竟它模拟的是网页渲染的整个过程，而真实的数据可能仅仅就藏在一个小接口里。如果我们能够把一些接口的参数真正找出其中的逻辑，用代码来模拟执行，那效率就会有成倍的提升，而且还能在一定程度上规避上述的反爬现象。但问题是什么？难啊。 Webpack 是一方面，前端代码都被压缩和转码成一些 bundle 文件，一些变量的含义已经丢失，不好还原。然后一些网站再加上一些 obfuscator 的机制，把前端代码变成你完全看不懂的东西，比如字符串拆散打乱、变量十六进制化、控制流扁平化、无限 debug、控制台禁用等等，前端的代码和逻辑已经面目全非。有的用 WebAssembly 等技术把前端核心逻辑直接编译，那就只能慢慢抠了，虽然说有些有一定的技巧，但是总归来说还是会花费很多时间。但一旦解出来了，那就万事大吉了。怎么说？就像奥赛题一样，解出来升天，解不出来 GG。很多公司招聘爬虫工程师都会问有没有 JavaScript 逆向基础，破解过哪些网站，比如某宝、某多、某条等等，解出来某个他们需要的可能就直接录用你。每家网站的逻辑都不一样，难度也不一样。

App

当然爬虫不仅仅是网页爬虫了，随着互联网时代的发展，现在越来越多的公司都选择将数据放到 App 上面，甚至有些公司只有 App 没有网站。所以数据只能通过 App 来爬。咋爬呢？基本的就是抓包工具了，Charles、Fiddler 一把梭，抓到接口之后，直接拿来模拟就行了。如果接口有加密参数怎么办呢？一种方法你可以边爬边处理，比如 mitmproxy 直接监听接口数据。另一方面你可以走 Hook，比如上 Xposed 也可以拿到。那爬的时候又怎么实现自动化呢？总不能拿手来戳吧。其实工具也多，安卓原生的 adb 工具也行，Appium 现在已经是比较主流的方案了，当然还有其他的某精灵都是可以实现的。最后，有的时候可能真的就不想走自动化的流程，我就想把里面的一些接口逻辑抠出来，那就得搞逆向了，IDA Pro、jdax、FRIDA 等工具就派上用场了，当然这个过程和 JavaScript 逆向一样很痛苦，甚至可能得读汇编指令。搞一个案例掉一把头发也不是不可能的。

智能化

上面的这一通，都搞熟了，恭喜你已经超过了百分之八九十的爬虫玩家了，当然专门搞 JavaScript 逆向、App 逆向的都是站在食物链顶端的男人，这种严格来说已经不算爬虫范畴了，这种神我们就不算在里面了，反正我不是。除了上面的一些技能，在一些场合下，我们可能也需要结合一些机器学习的技术，让我们的爬虫变得更智能起来。比如现在很多博客、新闻文章，其页面结构相似度比较高，要提取的信息也比较类似。比如如何区分一个页面是索引页还是详情页？如何提取详情页的文章链接？如何解析文章页的页面内容？这些其实都是可以通过一些算法来计算出来的。所以，一些智能解析技术也营运而生，比如提取详情页，一位朋友写的 GeneralNewsExtractor 表现就非常好。假如说我来了一个需求，我要爬取一万个新闻网站数据，要一个个写 XPath 吗？写死我吧。如果有了智能化解析技术，在容忍一定错误的条件下，完成这个就是分分钟的事情。总之，如果我们能把这一块也学会了，我们的爬虫技术就会如虎添翼。

运维

这块也是一个重头戏。爬虫和运维也是息息相关。比如写完一个爬虫，怎样去快速部署到 100 台主机上跑起来。比如怎么灵活地监控每个爬虫的运行状态。比如爬虫有处代码改动，如何去快速更新。比如怎样监控一些爬虫的占用内存、消耗的 CPU 状况。比如怎样科学地控制爬虫的定时运行、比如爬虫出现了问题，怎样能及时收到通知，怎样设置科学的报警机制。这里面，部署大家各有各的方法，比如用 Ansible 当然可以。如果用 Scrapy 的话有 Scrapyd，然后配合上一些管理工具也能完成一些监控和定时任务。不过我现在用的更多是还是 Docker + Kubernetes，再加上 DevOps 一套，比如 GitHub Actions、Azure Pipelines、Jenkins 等等，快速实现分发和部署。定时任务大家有的用 crontab，有的用 apscheduler，有的用管理工具，有的用 Kubernetes，我的话用 Kubernetes 就多一些了，定时任务也是很好实现。至于监控的话，也有很多，专门的一些爬虫管理工具自带了一些监控和报警功能。一些云服务也带了一些监控的功能。我用的是 Kubernetes + Prometheus + Grafana，什么 CPU、内存、运行状态，一目了然，报警机制在 Grafana 里面配一下也很方便，支持 Webhook、邮件甚至某钉。数据的存储和监控，用 Kafka、Elasticsearch 个人感觉也挺方便的，我主要用的是后者，然后再和 Grafana 配合起来，数据爬取量、爬取速度等等监控也都一目了然。

结语

至此，爬虫的一些涵盖的知识点也就差不多了，怎么样，梳理一下，是不是计算机网络、编程基础、前端开发、后端开发、App 开发与逆向、网络安全、数据库、运维、机器学习都涵盖到了？上面总结的可以算是从爬虫小白到爬虫高手的路径了，里面每个方向其实可研究的点非常多，每个点做精了，都会非常了不起。爬虫往往学着学着，就成为了一名全栈工程师或者全干工程师，因为你可能真的啥都会了。但是没办法啊，都是被爬虫逼的啊，如果不是生活所困，谁愿意一身才华呢？然而有了才华之后呢？摸摸头顶，卧槽，我的头发呢？嗯，大家都懂的。最后最重要的，珍爱生命、珍爱每一根头发。

作者崔庆才发表于 2020-03-20 阅读次数：本文字数： 6.4k 阅读时长 ≈ 6 分钟

技术杂谈 Python 使用 environs 库来更好地定义环境变量

在运行一个项目的时候，我们经常会遇到设置不同环境的需求，如设置是开发环境、测试环境还是生产环境，或者在某些设置里面可能还需要设置一些变量开关，如设置调试开关、日志开关、功能开关等等。这些变量其实就是在项目运行时我们给项目设置的一些参数。这些参数一般情况来说，可以有两种设置方法，一种是通过命令行参数，一种是通过环境变量。二者的适用范围不同，在不同的场景下我们可以选用更方便的方式来实现参数的设置。本节我们以 Python 项目为例，说说环境变量的设置。

设置和获取环境变量

首先，我们先来了解一下在 Python 项目里面怎样设置和获取变量。首先让我们定义一个最简单的 Python 文件，命名为 main.py，内容如下：

1 2	import os print(os.environ['VAR1'])

在这里我们导入了 os 模块，它的 environ 对象里面就包含了当前运行状态下的所有环境变量，它其实是一个 os._Environ 对象，我们可以通过类似字典取值的方式从中获取里面包含的环境变量的值，如代码所示。好，接下来我们什么也不设置，直接运行，看下结果：

1	python3 main.py

结果如下：

1 2	raise KeyError(key) from None KeyError: 'VAR1'

直接抛出来了一个错误，这很正常，我们此时并没有设置 VAR1 这个环境变量，当然会抛出键值异常的错误了。接下来我们在命令行下进行设置，运行如下命令：

1	VAR1=germey python3 main.py

运行结果如下：

germey

可以看到我们在运行之前，在命令行之前通过键值对的形式对环境变量进行设置，程序就可以获取到 VAR1 这个值了，成功打印出来了 germey。但这个环境变量是永久的吗？我们这次再运行一遍原来的命令：

1	python3 main.py

结果如下：

1 2	raise KeyError(key) from None KeyError: 'VAR1'

嗯，又抛错了。这说明了什么，在命令行的前面加上的这个环境变量声明只能对当前执行的命令生效。好，那既然如此，我难道每次运行都要在命令行前面加上这些声明吗？那岂不麻烦死了。当然有解决方法，我们使用 export 就可以了。比如这里，我们执行如下命令：

1	export VAR1=germey

执行完这个命令之后，当前运行环境下 VAR1 就被设置成功了，下面我们运行的命令都能获取到 VAR1 这个环境变量了。下面来试试，还是执行原来的命令：

1	python3 main.py

结果如下：

germey

可以，成功获取到了 VAR1 这个变量，后面我们运行的每一个命令就都会生效了。但等一下，这个用了 export 就是永久生效了吗？其实并不是，其实这个 export 只对当前的命令行运行环境生效，我们只要把命令行关掉再重新打开，之前用 export 设置的环境变量就都没有了。可以试试，重新打开命令行，再次执行原来的命令，就会又抛出键值异常的错误了。那又有同学会问了，我要在每次命令行运行时都想自动设置好环境变量怎么办呢？这个就更好办了，只需要把 export 的这些命令加入到 ~/.bashrc 文件里面就好了，每次打开命令行的时候，系统都会自动先执行以下这个脚本里面的命令，这样环境变量就设置成功了。当然这里面还有很多不同的文件，如 ~/.bash_profile 、~/.zshrc 、~/.profile、/etc/profile 等等，其加载是有先后顺序的，大家感兴趣可以去了解下。好了，扯远了，我们现在已经了解了如何设置环境变量和基本的环境变量获取方法了。

更安全的获取方式

但是上面的这种获取变量的方式实际上是非常不友好的，万一这个环境变量没设置好，那岂不是就报错了，这是很不安全的。所以，下面再介绍几种比较友好的获取环境变量的方式，即使没有设置过，也不会报错。我们可以把中括号取值的方式改成 get 方法，如下所示：

1 2	import os print(os.environ.get('VAR1'))

这样就不会报错了，如果 VAR1 没设置，会直接返回 None，而不是直接报错。另外我们也可以给 get 方法传入第二个参数，表示默认值，如下所示：

1 2	import os print(os.environ.get('VAR1', 'germey'))

这样即使我们如果设置过 VAR1，他就会用 germey 这个字符串代替，这就完成了默认环境变量的设置。下面还有几种获取环境变量的方式，总结如下：

1 2	import os print(os.getenv('VAR1', 'germey'))

这个方式比上面的写法更简单，功能完全一致。

弊端

但其实上面的方法有一个不方便的地方，如果我们想要设置非字符串类型的环境变量怎么办呢？比如设置 int 类型、float 类型、list 类型，可能我们的写法就会变成这个样子：

import os
import json

VAR1 = int(os.getenv('VAR1', 1))
VAR2 = float(os.getenv('VAR2', 5.5))
VAR3 = json.loads(os.getenv('VAR3'))

然后设置环境变量的时候就变成这样子：

1
2
3

export VAR1=1
export VAR2=2.3
export VAR3='["1", "2"]'

这样才能成功获取到结果，打印出来结果如下：

1
2
3

1
2.3
['1', '2']

不过看下这个，写法也太奇葩了吧，又是类型转换，又是 json 解析什么的，有没有更好的方法来设置。

environs

当然有的，下面推荐一个 environs 库，利用它我们可以轻松地设置各种类型的环境变量。这是一个第三方库，可以通过 pip 来安装：

1	pip3 install environs

好，安装之后，我们再来体验一下使用 environs 来设置环境变量的方式。

from environs import Env

env = Env()
VAR1 = env.int('VAR1', 1)
VAR2 = env.float('VAR2', 5.5)
VAR3 = env.list('VAR3')

这里 environs 直接提供了 int、float、list 等方法，我们就不用再去进行类型转换了。与此同时，设置环境变量的方式也有所变化：

1
2
3

export VAR1=1
export VAR2=2.3
export VAR3=1,2

这里 VAR3 是列表，我们可以直接用逗号分隔开来。打印结果如下：

1
2
3

1
2.3
['1', '2']

官方示例

下面我们再看一个官方示例，这里示例了一些常见的用法。首先我们来定义一些环境变量，如下：

export GITHUB_USER=sloria
export MAX_CONNECTIONS=100
export SHIP_DATE='1984-06-25'
export TTL=42
export ENABLE_LOGIN=true
export GITHUB_REPOS=webargs,konch,ped
export COORDINATES=23.3,50.0
export LOG_LEVEL=DEBUG

这里有字符串、有日期、有日志级别、有字符串列表、有浮点数列表、有布尔。我们来看下怎么获取，写法如下：

from environs import Env

env = Env()
env.read_env()  # read .env file, if it exists
# required variables
gh_user = env("GITHUB_USER")  # => 'sloria'
secret = env("SECRET")  # => raises error if not set

# casting
max_connections = env.int("MAX_CONNECTIONS")  # => 100
ship_date = env.date("SHIP_DATE")  # => datetime.date(1984, 6, 25)
ttl = env.timedelta("TTL")  # => datetime.timedelta(0, 42)
log_level = env.log_level("LOG_LEVEL")  # => logging.DEBUG

# providing a default value
enable_login = env.bool("ENABLE_LOGIN", False)  # => True
enable_feature_x = env.bool("ENABLE_FEATURE_X", False)  # => False

# parsing lists
gh_repos = env.list("GITHUB_REPOS")  # => ['webargs', 'konch', 'ped']
coords = env.list("COORDINATES", subcast=float)  # => [23.3, 50.0]

通过观察代码可以发现它提供了这些功能：

通过 env 可以设置必需定义的变量，如果没有定义，则会报错。
通过 date、timedelta 方法可以对日期或时间进行转化，转成 datetime.date 或 timedelta 类型。
通过 log_level 方法可以对日志级别进行转化，转成 logging 里的日志级别定义。
通过 bool 方法可以对布尔类型变量进行转化。
通过 list 方法可以对逗号分隔的内容进行 list 转化，并可以通过 subcast 方法对 list 的每个元素进行类型转化。

可以说有了这些方法，定义各种类型的变量都不再是问题了。

支持类型

总的来说，environs 支持的转化类型有这么多：

env.str
env.bool
env.int
env.float
env.decimal
env.list (accepts optional subcast keyword argument)
env.dict (accepts optional subcast keyword argument)
env.json
env.datetime
env.date
env.timedelta (assumes value is an integer in seconds)
env.url
env.uuid
env.log_level
env.path (casts to a pathlib.Path)

这里 list、dict、json、date、url、uuid、path 个人认为都还是比较有用的，另外 list、dict 方法还有一个 subcast 方法可以对元素内容进行转化。对于 dict、url、date、uuid、path 这里我们来补充说明一下。下面我们定义这些类型的环境变量：

export VAR_DICT=name=germey,age=25
export VAR_JSON='{"name": "germey", "age": 25}'
export VAR_URL=https://cuiqingcai.com
export VAR_UUID=762c8d53-5860-4d5d-81bc-210bf2663d0e
export VAR_PATH=/var/py/env

需要注意的是，DICT 的解析，需要传入的是逗号分隔的键值对，JSON 的解析是需要传入序列化的字符串。解析写法如下：

from environs import Env

env = Env()
VAR_DICT = env.dict('VAR_DICT')
print(type(VAR_DICT), VAR_DICT)

VAR_JSON = env.json('VAR_JSON')
print(type(VAR_JSON), VAR_JSON)

VAR_URL = env.url('VAR_URL')
print(type(VAR_URL), VAR_URL)

VAR_UUID = env.uuid('VAR_UUID')
print(type(VAR_UUID), VAR_UUID)

VAR_PATH = env.path('VAR_PATH')
print(type(VAR_PATH), VAR_PATH)

运行结果如下：

<class 'dict'> {'name': 'germey', 'age': '25'}
<class 'dict'> {'name': 'germey', 'age': 25}
<class 'urllib.parse.ParseResult'> ParseResult(scheme='https', netloc='cuiqingcai.com', path='', params='', query='', fragment='')
<class 'uuid.UUID'> 762c8d53-5860-4d5d-81bc-210bf2663d0e
<class 'pathlib.PosixPath'> /var/py/env

可以看到，它分别给我们转化成了 dict、dict、ParseResult、UUID、PosixPath 类型了。在代码中直接使用即可。

文件读取

如果我们的一些环境变量是定义在文件中的，environs 还可以进行读取和加载，默认会读取本地当前运行目录下的 .env 文件。示例如下：

from environs import Env

env = Env()
env.read_env()
APP_DEBUG = env.bool('APP_DEBUG')
APP_ENV = env.str('APP_ENV')
print(APP_DEBUG)
print(APP_ENV)

下面我们在 .env 文件中写入如下内容：

1 2	APP_DEBUG=false APP_ENV=prod

运行结果如下：

1 2	False prod

没问题，成功读取。当然我们也可以自定义读取的文件，如 .env.test 文件，内容如下：

1 2	APP_DEBUG=false APP_ENV=test

代码则可以这么定义：

from environs import Env

env = Env()
env.read_env(path='.env.test')
APP_DEBUG = env.bool('APP_DEBUG')
APP_ENV = env.str('APP_ENV')

这里就通过 path 传入了定义环境变量的文件路径即可。

前缀处理

environs 还支持前缀处理，一般来说我们定义一些环境变量，如数据库的连接，可能有 host、port、password 等，但在定义环境变量的时候往往会加上对应的前缀，如 MYSQL_HOST、MYSQL_PORT、MYSQL_PASSWORD 等，但在解析时，我们可以根据前缀进行分组处理，见下面的示例：

# export MYAPP_HOST=lolcathost
# export MYAPP_PORT=3000

with env.prefixed("MYAPP_"):
    host = env("HOST", "localhost")  # => 'lolcathost'
    port = env.int("PORT", 5000)  # => 3000

# nested prefixes are also supported:

# export MYAPP_DB_HOST=lolcathost
# export MYAPP_DB_PORT=10101

with env.prefixed("MYAPP_"):
    with env.prefixed("DB_"):
        db_host = env("HOST", "lolcathost")
        db_port = env.int("PORT", 10101)

可以看到这里通过 with 和 priefixed 方法组合使用即可实现分区处理，这样在每个分组下再赋值到一个字典里面即可。

合法性验证

有些环境变量的传入是不可预知的，如果传入一些非法的环境变量很可能导致一些难以预料的问题。比如说一些可执行的命令，通过环境变量传进来，如果是危险命令，那么会非常危险。所以在某些情况下我们需要验证传入的环境变量的有效性，看下面的例子：

# export TTL=-2
# export NODE_ENV='invalid'
# export EMAIL='^_^'

from environs import Env
from marshmallow.validate import OneOf, Length, Email

env = Env()

# simple validator
env.int("TTL", validate=lambda n: n > 0)
# => Environment variable "TTL" invalid: ['Invalid value.']

# using marshmallow validators
env.str(
    "NODE_ENV",
    validate=OneOf(
        ["production", "development"], error="NODE_ENV must be one of: {choices}"
    ),
)
# => Environment variable "NODE_ENV" invalid: ['NODE_ENV must be one of: production, development']

# multiple validators
env.str("EMAIL", validate=[Length(min=4), Email()])
# => Environment variable "EMAIL" invalid: ['Shorter than minimum length 4.', 'Not a valid email address.']

在这里，我们通过 validate 方法，并传入一些判断条件。如 NODE_ENV 只允许传入 production 和 develpment 其中之一；EMAIL 必须符合 email 的格式。这里依赖于 marshmallow 这个库，里面有很多验证条件，大家可以了解下。如果不符合条件的，会直接抛错，例如：

1	marshmallow.exceptions.ValidationError: ['Invalid value.']

关于 marshmallow 库的用法，大家可以参考：https://marshmallow.readthedocs.io/en/stable/，后面我也抽空写一下介绍下。最后再附一点我平时定义环境变量的一些常见写法，如：

import platform
from os.path import dirname, abspath, join
from environs import Env
from loguru import logger

env = Env()
env.read_env()

# definition of flags
IS_WINDOWS = platform.system().lower() == 'windows'

# definition of dirs
ROOT_DIR = dirname(dirname(abspath(__file__)))
LOG_DIR = join(ROOT_DIR, env.str('LOG_DIR', 'logs'))

# definition of environments
DEV_MODE, TEST_MODE, PROD_MODE = 'dev', 'test', 'prod'
APP_ENV = env.str('APP_ENV', DEV_MODE).lower()
APP_DEBUG = env.bool('APP_DEBUG', True if APP_ENV == DEV_MODE else False)
APP_DEV = IS_DEV = APP_ENV == DEV_MODE
APP_PROD = IS_PROD = APP_DEV == PROD_MODE
APP_TEST = IS_TEST = APP_ENV = TEST_MODE

# redis host
REDIS_HOST = env.str('REDIS_HOST', '127.0.0.1')
# redis port
REDIS_PORT = env.int('REDIS_PORT', 6379)
# redis password, if no password, set it to None
REDIS_PASSWORD = env.str('REDIS_PASSWORD', None)
# redis connection string, like redis://[password]@host:port or rediss://[password]@host:port
REDIS_CONNECTION_STRING = env.str('REDIS_CONNECTION_STRING', None)

# definition of api
API_HOST = env.str('API_HOST', '0.0.0.0')
API_PORT = env.int('API_PORT', 5555)
API_THREADED = env.bool('API_THREADED', True)

# definition of flags
ENABLE_TESTER = env.bool('ENABLE_TESTER', True)
ENABLE_GETTER = env.bool('ENABLE_GETTER', True)
ENABLE_SERVER = env.bool('ENABLE_SERVER', True)

# logger
logger.add(env.str('LOG_RUNTIME_FILE', 'runtime.log'), level='DEBUG', rotation='1 week', retention='20 days')
logger.add(env.str('LOG_ERROR_FILE', 'error.log'), level='ERROR', rotation='1 week')

这里定义了一些开发环境、日志路径、数据库连接、API 设置、开关设置等等，是从我之前写的一个代理池项目拿来的，大家可以参考：https://github.com/Python3WebSpider/ProxyPool。好了，以上就是一些环境变量的定义方法，谢谢大家。

作者崔庆才发表于 2020-02-25 阅读次数：本文字数： 9.1k 阅读时长 ≈ 8 分钟

Python Python 序列化和反序列化库 MarshMallow 的用法

在很多情况下，我们会有把 Python 对象进行序列化或反序列化的需求，比如开发 REST API，比如一些面向对象化的数据加载和保存，都会应用到这个功能。比如这里看一个最基本的例子，这里给到一个 User 的 Class 定义，再给到一个 data 数据，像这样：

class User(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

data = [{
    'name': 'Germey',
    'age': 23
}, {
    'name': 'Mike',
    'age': 20
}]

现在我要把这个 data 快速转成 User 组成的数组，变成这样：

1	[User(name='Germey', age=23), User(name='Mike', age=20)]

你会怎么来实现？或者我有了上面的列表内容，想要转成一个 JSON 字符串，变成这样：

1	[{"name": "Germey", "age": 23}, {"name": "Mike", "age": 20}]

你又会怎么操作呢？另外如果 JSON 数据里面有各种各样的脏数据，你需要在初始化时验证这些字段是否合法，另外 User 这个对象里面 name、age 的数据类型不同，如何针对不同的数据类型进行针对性的类型转换，这个你有更好的实现方案吗？

初步思路

之前我写过一篇文章介绍过 attrs 和 cattrs 这两个库，它们二者的组合可以非常方便地实现对象的序列化和反序列化。譬如这样：

from attr import attrs, attrib
from cattr import structure, unstructure

@attrs
class User(object):
    name = attrib()
    age = attrib()

data = {
    'name': 'Germey',
    'age': 23
}
user = structure(data, User)
print('user', user)
json = unstructure(user)
print('json', json)

运行结果：

1 2	user User(name='Germey', age=23) json {'name': 'Germey', 'age': 23}

好，这里我们通过 attrs 和 cattrs 这两个库来实现了单个对象的转换。首先我们要肯定一下 attrs 这个库，它可以极大地简化 Python 类的定义，同时每个字段可以定义多种数据类型。但 cattrs 这个库就相对弱一些了，如果把 data 换成数组，用 cattrs 还是不怎么好转换的，另外它的 structure 和 unstructure 在某些情景下容错能力较差，所以对于上面的需求，用这两个库搭配起来并不是一个最优的解决方案。另外数据的校验也是一个问题，attrs 虽然提供了 validator 的参数，但对于多种类型的数据处理的支持并没有那么强大。所以，我们想要寻求一个更优的解决方案。

更优雅的方案

这里推荐一个库，叫做 marshmallow，它是专门用来支持 Python 对象和原生数据相互转换的库，如实现 object -> dict，objects -> list, string -> dict, string -> list 等的转换功能，另外它还提供了非常丰富的数据类型转换和校验 API，帮助我们快速实现数据的转换。要使用 marshmallow 这个库，需要先安装下：

1	pip3 install marshmallow

好了之后，我们在之前的基础上定义一个 Schema，如下：

class UserSchema(Schema):
    name = fields.Str()
    age = fields.Integer()

    @post_load
    def make(self, data, **kwargs):
        return User(**data)

还是之前的数据：

data = [{
    'name': 'Germey',
    'age': 23
}, {
    'name': 'Mike',
    'age': 20
}]

这时候我们只需要调用 Schema 的 load 事件就好了：

1
2
3

schema = UserSchema()
users = schema.load(data, many=True)
print(users)

输出结果如下：

1	[User(name='Germey', age=23), User(name='Mike', age=20)]

这样，我们非常轻松地完成了 JSON 到 User List 的转换。有人说，如果是单个数据怎么办呢，只需要把 load 方法的 many 参数去掉即可：

data = {
    'name': 'Germey',
    'age': 23
}

schema = UserSchema()
user = schema.load(data)
print(user)

输出结果：

1	User(name='Germey', age=23)

当然，这仅仅是一个反序列化操作，我们还可以正向进行序列化，以及使用各种各样的验证条件。下面我们再来看看吧。

更方便的序列化

上面的例子我们实现了序列化操作，输出了 users 为：

1	[User(name='Germey', age=23), User(name='Mike', age=20)]

有了这个数据，我们也能轻松实现序列化操作。序列化操作，使用 dump 方法即可

1 2	result = schema.dump(users, many=True) print('result', result)

运行结果如下：

1	result [{'age': 23, 'name': 'Germey'}, {'age': 20, 'name': 'Mike'}]

由于是 List，所以 dump 方法需要加一个参数 many 为 True。当然对于单个对象，直接使用 dump 同样是可以的：

1 2	result = schema.dump(user) print('result', result)

运行结果如下：

1	result {'name': 'Germey', 'age': 23}

这样的话，单个、多个对象的序列化也不再是难事。经过上面的操作，我们完成了 object 到 dict 或 list 的转换，即：

1 2	object <-> dict objects <-> list

验证

当然，上面的功能其实并不足以让你觉得 marshmallow 有多么了不起，其实就是一个对象到基本数据的转换嘛。但肯定不止这些，marshmallow 还提供了更加强大啊功能，比如说验证，Validation。比如这里我们将 age 这个字段设置为 hello，它无法被转换成数值类型，所以肯定会报错，样例如下：

data = {
    'name': 'Germey',
    'age': 'hello'
}

from marshmallow import ValidationError
try:
    schema = UserSchema()
    user, errors = schema.load(data)
    print(user, errors)
except ValidationError as e:
    print('e.message', e.messages)
    print('e.valid_data', e.valid_data)

这里如果加载报错，我们可以直接拿到 Error 的 messages 和 valid_data 对象，它包含了错误的信息和正确的字段结果，运行结果如下：

1 2	e.message {'age': ['Not a valid integer.']} e.valid_data {'name': 'Germey'}

因此，比如我们想要开发一个功能，比如用户注册，表单信息就是提交过来的 data，我们只需要过一遍 Validation，就可以轻松得知哪些数据符合要求，哪些不符合要求，接着再进一步进行处理。当然验证功能肯定不止这一些，我们再来感受一下另一个示例：

from pprint import pprint
from marshmallow import Schema, fields, validate, ValidationError

class UserSchema(Schema):
    name = fields.Str(validate=validate.Length(min=1))
    permission = fields.Str(validate=validate.OneOf(['read', 'write', 'admin']))
    age = fields.Int(validate=validate.Range(min=18, max=40))

in_data = {'name': '', 'permission': 'invalid', 'age': 71}
try:
    UserSchema().load(in_data)
except ValidationError as err:
    pprint(err.messages)

比如这里的 validate 字段，我们分别校验了 name、permission、age 三个字段，校验方式各不相同。如 name 我们要判断其最小值为 1，则使用了 Length 对象。permission 必须要是几个字符串之一，这里又使用了 OneOf 对象，age 又必须是介于某个范围之间，这里就使用了 Range 对象。下面我们故意传入一些错误的数据，看下运行结果：

1
2
3

{'age': ['Must be greater than or equal to 18 and less than or equal to 40.'],
 'name': ['Shorter than minimum length 1.'],
 'permission': ['Must be one of: read, write, admin.']}

可以看到，这里也返回了数据验证的结果，对于不符合条件的字段，一一进行说明。另外我们也可以自定义验证方法：

from marshmallow import Schema, fields, ValidationError

def validate_quantity(n):
    if n < 0:
        raise ValidationError('Quantity must be greater than 0.')
    if n > 30:
        raise ValidationError('Quantity must not be greater than 30.')

class ItemSchema(Schema):
    quantity = fields.Integer(validate=validate_quantity)

in_data = {'quantity': 31}
try:
    result = ItemSchema().load(in_data)
except ValidationError as err:
    print(err.messages)

通过自定义方法，同样可以实现更灵活的验证，运行结果：

1	{'quantity': ['Quantity must not be greater than 30.']}

对于上面的例子，还有更优雅的写法：

from marshmallow import fields, Schema, validates, ValidationError

class ItemSchema(Schema):
    quantity = fields.Integer()

    @validates('quantity')
    def validate_quantity(self, value):
        if value < 0:
            raise ValidationError('Quantity must be greater than 0.')
        if value > 30:
            raise ValidationError('Quantity must not be greater than 30.')

通过定义方法并用 validates 修饰符，使得代码的书写更加简洁。

必填字段

如果要想定义必填字段，只需要在 fields 里面加入 required 参数并设置为 True 即可，另外我们还可以自定义错误信息，使用 error_messages 即可，例如：

from pprint import pprint
from marshmallow import Schema, fields, ValidationError

class UserSchema(Schema):
    name = fields.String(required=True)
    age = fields.Integer(required=True, error_messages={'required': 'Age is required.'})
    city = fields.String(
        required=True,
        error_messages={'required': {'message': 'City required', 'code': 400}},
    )
    email = fields.Email()

try:
    result = UserSchema().load({'email': 'foo@bar.com'})
except ValidationError as err:
    pprint(err.messages)

默认字段

对于序列化和反序列化字段，marshmallow 还提供了默认值，而且区分得非常清楚！如 missing 则是在反序列化时自动填充的数据，default 则是在序列化时自动填充的数据。例如：

from marshmallow import Schema, fields
import datetime as dt
import uuid

class UserSchema(Schema):
    id = fields.UUID(missing=uuid.uuid1)
    birthdate = fields.DateTime(default=dt.datetime(2017, 9, 29))

print(UserSchema().load({}))
print(UserSchema().dump({}))

这里我们都是定义的空数据，分别进行序列化和反序列化，运行结果如下：

1 2	{'id': UUID('06aa384a-570c-11ea-9869-a0999b0d6843')} {'birthdate': '2017-09-29T00:00:00'}

可以看到，在没有真实值的情况下，序列化和反序列化都是用了默认值。这个真的是解决了我之前在 cattrs 序列化和反序列化时候的痛点啊！

指定属性名

在序列化时，Schema 对象会默认使用和自身定义相同的 fields 属性名，当然也可以自定义，如：

class UserSchema(Schema):
    name = fields.String()
    email_addr = fields.String(attribute='email')
    date_created = fields.DateTime(attribute='created_at')

user = User('Keith', email='keith@stones.com')
ser = UserSchema()
result, errors = ser.dump(user)
pprint(result)

运行结果如下：

1
2
3

{'name': 'Keith',
 'email_addr': 'keith@stones.com',
 'date_created': '2014-08-17T14:58:57.600623+00:00'}

反序列化也是一样，例如：

class UserSchema(Schema):
    name = fields.String()
    email = fields.Email(load_from='emailAddress')

data = {
    'name': 'Mike',
    'emailAddress': 'foo@bar.com'
}
s = UserSchema()
result, errors = s.load(data)

运行结果如下：

1 2	{'name': u'Mike', 'email': 'foo@bar.com'}

嵌套属性

对于嵌套属性，marshmallow 当然也不在话下，这也是让我觉得 marshmallow 非常好用的地方，例如：

from datetime import date
from marshmallow import Schema, fields, pprint

class ArtistSchema(Schema):
    name = fields.Str()

class AlbumSchema(Schema):
    title = fields.Str()
    release_date = fields.Date()
    artist = fields.Nested(ArtistSchema())

bowie = dict(name='David Bowie')
album = dict(artist=bowie, title='Hunky Dory', release_date=date(1971, 12, 17))

schema = AlbumSchema()
result = schema.dump(album)
pprint(result, indent=2)

这样我们就能充分利用好对象关联外键来方便地实现很多关联功能。以上介绍的内容基本算在日常的使用中是够用了，当然以上都是一些基本的示例，对于更多功能，可以参考 marchmallow 的官方文档：https://marshmallow.readthedocs.io/en/stable/，强烈推荐大家用起来。

作者崔庆才发表于 2020-02-25 阅读次数：本文字数： 7.5k 阅读时长 ≈ 7 分钟

福利专区 东鸽送3台｜做开发没有云服务器怎么行？

随着云计算和虚拟技术的发展，主机业务从虚拟主机逐步发展到独享云服务器。我们 IT 人对服务器的需求是很强烈的，无论你是后端研发、前端开发、云计算、大数据、架构、数据存储、运维还是产品经理，每个人手上多多少少都会有几台云服务器。这些云服务器被用做测试用机、学习用机或者正式生产用机，有些朋友会在上面搭建博客，有些朋友在上面搭建 API。东鸽自己也手握几台服务器：其中有 3 台用作实际的生产，新书《Python3 反爬虫原理与绕过实战》的在线练习平台、夜幕爬虫安全论坛和我的个人博客。另外几台用来做测试、数据合作和练习。练习的话，像平时学习 MongoDB 数据库、Redis 数据库和 Mysql 数据库的时候，我会在服务器上安装对应的应用，启动服务后在自己的电脑上连接，这样能得到与生产环境一样的体验。学习 Linux 和 Shell 脚本的时候也会用云服务器进行练习，这样既能够确保练习效果，又避免了对本机电脑的干扰。 你总不能在自己的电脑上折腾来折腾去吧，万一搞坏了，工作咋办？ 数据合作，那是个人业务上的事了。数据用云端数据库的方式交付给客户，不需要其他传输媒介，轻便快捷，没有延时风险。我这边把数据存储到服务器，客户从服务器上拉取数据。 一个普通的生产者消费者模式就诞生了。如果数据业务体量比较大，或者说数据业务的出口比较多，那我可能会借用消息中间件来进行调节。为了保证数据的完整性和可用性，我可能会对服务器进行镜像，那么我就需要 2～3 台服务器。假设每台服务器的成本是 300元/年，数据合作业务的收入是 3W/年，那真是四两拨千斤了。要合理利用资源，让资源为我们生小钱钱！服务器配置跟具体业务需求有关，用于测试的服务器通常是 1 核 2G 1M；博客和论坛的服务器带宽稍大一些，带宽通常是 3M ；用于数据合作的服务器内存较大，一般需要为 4G～8G；除了服务器之外，华为云还有很多神奇的业务。我觉得黑科技真的是太多了。上次我用华为云的深度学习一体化服务 ModelArts 在线实现了图像深度学习中的图片标注、图片分类预测和模型部署+生成 API，感觉很流畅。鼠标点点点，配置一丢丢参数，也不用自己写代码，也不用弄 Web 框架，唰唰唰地几下，就可以调用了。崔庆才崔哥用 ModelArts 实现了爬虫工程师常用到的拼图验证码缺口识别 API。样本准备了小小几十个，训练完成后的识别准确率很高，这样我们就不用担心缺口位置定位的问题了。服务器数量多，开销自然就大。如无必要，通常我是不会购买服务器的，但每当云服务器厂商有活动时我都会做一些购买计划。例如我今年打算增加数据业务，并且学习架构方面的知识，那我至少得再买 5 台服务器。趁着华为开年采购季活动，购买一台服务器的成本最低 79元/年。除此之外，华为云还有数据库专场活动、域名建站专场活动、云安全专场活动在等着我们，买买买！大家相识已久，东鸽感谢大家关注和支持，这次华为云开年采购季活动我自掏腰包购买 3 台 1 核 2G 1M 的服务器（1年期）送给各位粉丝。大家扫码即可参与抽奖，到期自动开奖。 参与要求：参与活动时必须转发上方华为云开年采购季海报，领奖时小编会检查的哦。

作者韦世东学算法和反爬虫发表于 2020-02-24 阅读次数：本文字数： 1.3k 阅读时长 ≈ 1 分钟

技术杂谈 推荐个好用的书签工具

今天刚发现了一个我觉得不错的工具，介绍给大家，不是打广告哈，是真心推荐。在推荐之前，问大家一个问题：

大家平常遇到不错的网站或文章，会用什么方式收藏？Chrome 书签？
现在你们 Chrome 书签里面啥样子？乱不乱？
如果我让你们快速从书签里面找出一个曾经收藏过网站，你要花多久？
如果你在手机上用其他的浏览器，比如 Safari、微博上看到了一个不错的网站，怎么存？
存到了 Safari 上面，又怎么和电脑上的 Chrome 书签合并？之后还能找到吗？

在这个终身学习的时代，我们需要保存和收藏的东西太多太多了。好的网站，好的博文，好的软件，都需要存下来。那么怎么存？这是个问题。我最早也用过 Chrome 书签，但是这有个毛病，怎么全平台同步？我想在手机（iPhone）上看我的书签内容，难道我还要专门下个 Chrome？另外书签的整理和搜索也是个问题，实在是让我喜欢不起来。我在选择软件都会追求全平台云同步。比如时间规划软件，我会用「滴答清单」；SSH 软件，我会用「Termius」；翅膀软件我会用「Surge」，为的都是解决一些跨终端问题，它们都是 iPhone、iPad、Mac、Windows、Web 全部平台同步的，有的甚至还支持浏览器插件或者 Apple Watch 等等，这样我们不论切换到哪个终端，都会非常方便地同步数据。

Pocket

所以，对于上面说的这个问题，怎么来收藏链接，有什么好用的 App 呢？这个最初是选择了「Pocket」。「Pocket」这个软件有一个不错的特性，那就是跨平台，我可以在浏览器、Mac、iPhone、iPad 上使用，看到不错的网站，调出插件或者点击「分享到 Pocket」就可以存进去了，这样就解决了多平台同步问题，另外「Pocket」还能设置一些标签等等，然后每周或定期我再翻出来整理整理。说实话，我用「Pocket」好几年了，但总觉得一直达不到我心中完美的标准，怎么说呢？下面总结一下：

跨平台

跨平台的支持确实挺好的，这也是我选择「Pocket」的重要原因，支持 Web、Mac、Windows、iPhone、iPad 、Android 各大平台，另外还提供了多款浏览器插件，全平台同步。光这一点就干倒了很多竞争者了。然而，不好的也有很多。

界面

首先，Mac 的界面太丑了，多少年了，我一直盼着能改好看点，结果界面一直没有大的改观。这谁受得住啊？截图看看：哎，一眼难尽啊，左边浓浓的拟物化风格，右边自作聪明出了个阅读模式，也就是自动提取正文内容，结果把文章格式整的这么乱。

功能

怎么说呢？其实不能追求太多，我最初也只是想找一个存书签的软件。但它的一些分类和标签做的体验并不友好。另外如果我想存文件、存图片，那几乎是不可能的了。另外这个页面布局吧，实在是让我难以恭维。我不能一目了然地看到我的所有分类和分类层级、标签等等内容。另外「Pocket」里面还增加了「发现」、「活动」、「资料」三个选项卡，总体来说有点社交性质，它让我去关注点别人，然后看到别人的收藏动态，其中两个选项卡几乎都是常年没啥有效内容的，觉得这些功能有点鸡肋，不足以上升到能和我的收藏列表一个级别。所以我基本上就只开第一个选项卡「我的列表」，只有这里才是我真正想要的收藏列表。看下图吧，只有第一个选项卡才是收藏列表，第二个就是「发现」，第三个「活动」，最后一个「资料」，后三个基本上没啥卵用，没关注几个人，第三个基本上是常年空着的状态。所以说，这软件的界面、操作和功能，只能说我不喜欢。不喜欢就不要将就，我将就了这么久，最后还是要放弃它。

Raindrop.io

所以近期我就一直在找一款能替换掉「Pocket」的纯粹的内容收集软件，这么几个原则吧：

跨平台，必须支持所有终端，包括 Windows、Mac、iPhone、iPad、Android、Web 并提供各个浏览器插件。
功能明确，能方便地管理分类、标签、收藏等内容，且不要有一些其他鸡肋的功能。
好看，好看，好看！我还是很注重界面和美观的，不论是图标还是内页，不优雅的界面会让我觉得很不爽。（之前找软件的时候因为某些软件的图标设计得不好看而被我 Pass 了）。

好了，搜啊搜，找到这么一款软件—— Raindrop.io，感觉不错，看到首页的介绍，被吸引到了！大家可以看视频来感受一下：https://up.raindrop.io/web/marketing/intro.mp4 可以说首先界面真的吸引到我了，而且左侧的导航分类、收藏夹的管理非常清晰，页面布局也很清晰，甚至支持文件、图片等格式的收藏！另外它同样也支持全平台，完全符合我的需求。然后我就下载下来了各个平台都试了试，首先试了试它的一些基础功能，比如收藏夹的管理，然后添加上一些不错的内容。初步整理成下图这么个样子：另外内容还支持各种其他的布局，如列表式：瀑布流式：舒服了。说回功能，这里我先分了几个分组，为「网站」、「代码」、「图片」，我估计我用到的最多的肯定是「网站」这个分组，用来存各种链接的，「代码」和「图片」是为了测试它的上传文件和图片功能而加的，可以用来存代码文件和图片。分组建好之后，我们可以在分组里面添加收藏夹，看图里面每行前面有个小图标的就是一个收藏夹。没错，每个收藏夹都可以自定义它的小图标，这个功能真的是增色不少！它提供了非常多的小图标，看：这个功能，我觉得简直不能更赞！另外这些小图标还可以自己上传，所以你看图里面的 GitHub 图标、Python 图标，都是我从 icons8 上面找到并上传的，毫无违和感！另外每一个收藏它都会自动生成一张封面图，会自动截取网站当前页面的内容，或者也可以自定义上传图片或者自定义截屏，最后每个收藏项都会变成一张张卡片。当然添加标签页不在话下。另外浏览器的插件也做的很精致，提供了 Mini Application 和极简模式，收藏一个页面只需要点一下这个图标就收藏好了。如果是高级版的账号，还支持自动分类。手机和 iPad 上面的软件我也试了，功能基本类似。怎么保存呢？比如我的 iPhone 上可以把这个软件放到分享的 App 列表里面，这样在浏览器里面点击「分享」，然后选「Raindrop.io」就好了，它会自动弹出一个窗口，让我们选择分类或加标签，体验很不错。嗯，总之整体体验下来，非常好用。另外它还支持自动导入书签或从其他的收藏软件里面迁移，大家如果一些网站保存在书签里面的话，如果用了这个，可以快速导入进来，非常方便！另外还有一些高级的功能大家再探索吧。怎么感觉越写越像个广告文了，但确实这不是广告文，它确实很好用，在这强推给大家！希望它能帮助大家方便管理各种资源，什么博客、公众号、干货、微博、图片、文件统统可以保存到这里并明确清晰地归类啦！

作者崔庆才发表于 2020-02-10 阅读次数：本文字数： 2.7k 阅读时长 ≈ 2 分钟

个人随笔 关于开会的一些思考

今天一个偶然的机会，在群里看到了一个推送，是来自一个软件「飞书」的公开课，它讲如何使用飞书，以及如何提高团队的协作效率，我就去听了一下。头条是飞书开发的，整个 Talk 其实讲了挺多的关于飞书的使用，其实和很多软件的功能大体上是相同的，如文件共享、文档协作、任务分配、聊天沟通等等，像行业内挺多软件，如 Worktile、TAPD、Teambition 等等也都比较完善了，所以一些类似的功能我就不展开说了。不过其中有一个点，让我听了之后深受启发，那就是如何提高开会效率。我也参加过很多会议了，包括研究生期间跟着导师出去汇报、开实验室小组会或者公司内部开大会。其中有的内容是讨论具体的实施方案，有的一些时候是单纯的分享或者 sync 进度。对于后者的话，其实没什么问题，就是一个人分享或者快速跟其他人沟通，我想大部分情况下大家都是类似的。但是对于前者，我就觉得一些会议效率太低了，甚至说价值并不高，那么这里就主要说说这种会议。比如有些会议，尤其是大会，比如十几二十人围在一起开会讨论方案，参与的人很多很杂，有的人甚至还是和会议相关度不高的人或者本身对会议主题完全不了解的人。这时候可能有一个人主持会先说说这个会是干嘛的，开这个会要讨论点什么，说了十分钟之后，一些人才大体上明白这个会在做什么。然后后面就是后面开始讨论方案了，大家也没有整个的时间把控，不知道一共可能讨论多久，大家你一句我一句，有时候扯着扯着扯远了，最后一个会能开上一个半甚至两个多小时，然后会议结束了之后，大家又接着去干活去了。过了一阵子或者几天，想回想一下当时会上到底是怎么说的或者讨论了什么方案，很可能就忘了。如果当时会上有专门做会议纪要的人，那还 OK，如果没有，那这么多人过了一段时间，具体会上说了那些有用的东西或者最后采取了什么方案具体怎么实施呢？很可能就是两个字：忘了。另外，有些人可能整个会上一句话也没说，完全感觉不到任何参与感，所以他也就越来越觉得这个会议没有什么意义，甚至可能就在会上就睡着了。我想工作的各位难免会遇到这样的问题，或者甚至大家的会议现状就是这样子的。我之前也一直觉得，这种会议模式其实挺病态的，在时间这么宝贵的今天，到底有没有一个比较好的开会方式呢？今天听了这个分享之后，我确实被其中所讲的一个会议模式吸引到了。怎么个方式呢？这里我就根据自己的理解大体概括一下。

提前准备

会议的组织者，在开会之前，根据会议的适用场景，列好这个会议想要讨论的内容，以文档的形式写下来。比如要开发一个软件，那么可能就列出来其中的交互或实现方案。如果是要讨论一个解决方案，那就把已经想到的解决方案写下来。然后呢，很重要的，在开会之前，把文档都发给大家，比如附在邮件链接里面，大家都可以下载或者在线查看。这样可以让大家提前对会议的内容有所了解，如果是对会议毫不了解的人，也能对会议的主题有个整体的把握。这样就不会出现这样的情况了：咦，来了一个会啊，咋叫上我了？这个会到底干嘛的？写的这个主题到底啥意思？我去了能干啥？这就是其一，提前准备，让所有人都有所了解。另外，每个人知道主题和讨论内容了，也就知道自己需要准备什么东西，哪些需要演示，哪些需要重点讲解。

阅读及评论

这个环节也很新颖和高效。在会议开始的时候，前 15 分钟（时间视情况而定），没有任何人讲话！注意是没有任何人讲话！那么大家做什么？看文档！大家会在这前 15 分钟里面仔细阅读文档和思考。由于文档是共享的，可以在线协作编辑的，每个人都可以在上面写 Comments，比如提意见或者提想法。由于大家都登录了自己的账户，所以谁提的 Comments，所有人都一清二楚，而且可以实时看到。就类似下图的这种感觉，见图右侧的 Comments。然后 15 分钟过后，大家会针对大家疑虑的点进行讨论。注意，由于有了 Comments，大家就知道一共有多少需要讨论的点，这个会还剩余多久，每个 Comment 可以讨论多长时间，这样又避免了开会时间无节制的问题。然后还有一个重要的点，就是每讨论完一个 Comment，就在对应的地方写上解决方案或者附上 Todo List，即具体的实施措施，做到当场讨论问题、当场提出解决方案、当场分配任务计划。 OK，然后整个会就很有目标地开完了，很有侧重点，而且大家都清除的就不需要讨论了。另外还有一个优点就是，每个人都可以提 Comments，这样每个人都会感到极强的参与感，再也不会出现会上一言不发事不关己高高挂起的状态了。

会后

由于采取了前面的两步措施，所以会后也就更方便了。整个会议的纪要在哪里？就是之前的文档里。整个会议关键的点在哪里？都在 Comments 和对应的回复里。整个会议讨论出了什么计划？当场也已经分配好了，大家会后直接根据会上分配的 Todo 去做就好了，分配的任务会自动加到每个人的 Todo List 里面。过了几天，我想复盘整个会议或者回想下这个会议说了些啥，怎么办？直接打开会议文档就好了。还需要专门写会议纪要的吗？会上大家共同协作会议文档，已经都写好了。嗯，这就是整个会议的模式。节省了多少时间或者避免了什么问题呢？我们数数吧。

每个人在会前都可以对会议提前了解和准备，每个人的了解和准备都会更充分。
开会前半段每个人都会有单独的时间去理解和思考并做评论。
每个人都会有极强的参与感。
根据大家评论的数量来把握整个开会的节奏，减少了拖延的概率。
会上当场确定好解决方案和人员，自动同步到每个人的 Todo 列表。
会后随时查看，随时复盘。
文档记录，永不丢失遗忘。

真的可以说，这个模式我觉得非常好，大幅提高了开会的效率，节省了时间。这个模式我听 Talk 里面说已经在诸如头条的公司里面用了很久了，很多人都反馈很不错。飞书在这方面的支持已经做得挺好了，但可能很多公司不用飞书，不过现在还有很不错的在线协作文档，比如石墨文档、Pages、Worktile、OneNote 等等也都可以成为候选方案，这个模式还是完全可以借鉴的。以上仅是我的一点总结和思考，希望对大家有所启发，谢谢！

作者崔庆才发表于 2020-02-10 阅读次数：本文字数： 2.4k 阅读时长 ≈ 2 分钟

个人随笔 2020 才过去了一个多月，世界都发生了些什么

有人说：2019 年可能是过去十年里最坏的一年，但可能是未来十年里最好的一年。的确 2019 整个大环境确实比较差，很多人可能在 2020，这个新的一个十年的开端，许愿接下来的日子能慢慢好起来。但目前的状况，大家可能都看到了，新型冠状病毒的肆虐，让全国都变成了什么样子。在国内，新型冠状病毒相关的态势一直最近的头条，但可能大家并没有注意到，其实世界各地都似乎不怎么太平，如。而看看时间，2020 才过去了一个多月而已。

中国

不知道大家是不是和我一样，起床醒来的第一件事就是去查一查现在国内新型冠状病毒的确诊人数。截止今天（2 月 9 日）晚上 9 点，全国确诊病例达到 37289 例，疑似病例 28942 例，每天还以好几千的数量增加，估计明天早上能突破 4 万。全国 31 个省区均早已经启动了一级响应，这在过去是从未有过的，随着病毒的传播蔓延，事态的严重性远远超出人们最大胆的想象。现在国家正在举全国之力支援灾区，前线的医疗人员一直在全力以赴救治患者。全国各个地区也在采取可以说是历史上最严格的防疫措施，全国范围内的商场、餐厅、娱乐场所几乎都被关停，各家各户的居民也都在家隔离，企业也延迟复工或者到现在还有很多企业都没有正式复工，口罩物资都已经全网脱销，一罩难求。但没有办法，在这个非常时刻，只要我们每个人都尽上自己的所能，相信疫情肯定会慢慢控制下来，请相信我们的国家。观察了几天，从数据上来看，可能有这么两个好消息：

一个是现在总的治愈人数已经超过死亡人数接近三倍，而且治愈人数的每日增长速度已经远超过死亡人数，比如今天的治愈人数就已经是死亡人数的大约 10 倍（891：90）。而且现在疫苗已经投入临床试验，相信接下来的治愈数据的增长液会越来越快。
新增的确诊和疑似人数出现缓和和下降迹象，至少从最近四天的数据上来看，能看出新增数量整体呈现下降的态势，今天刚刚也有新闻报道说全国除湖北外其他省份每日报告的确诊病例数从 2 月 3 日 890 例下降到 2 月 8 日的 509 例，下降幅度达到 42.8%，这表明各地联防联控机制以及严格管理等防控措施正在发挥作用。希望前几天数据最高的点，就是那个拐点吧。

加油武汉，加油中国！💪

美国

可能我们大多数人关注更多的是国内的新型冠状病毒。但现在，美国其实也不太平。美国正在遭受近 10 年来最严重的流感疫情。看图，这是美国疾病控制与预防中心网站上的流感活动地图，现在是 2 月 9 日周日，数据的统计是每周一次更新，当前更新到 2 月 1 日，数据来源链接见文末。 CDC 称，在其流感活动地图上，美国大部分地区为深红色，表明「流感样疾病」活动水平达到最高级。由于美国的流感季还要持续一段时间，因此这一数据可能会继续上升。从地区上看，目前全美 50 个州里，有 48 个州出现流感疫情，其中 32 个州流感活动水平维持高位，人口稠密的纽约、华盛顿和加州无一幸免，纷纷中招。此次流感季将是 10 年来美国最严重的流感季之一，2019 - 2020 流感季中，美国 1900 万人感染流感，至少 1 万人死亡，包括 68 名儿童。预计流感季将持续至 5 月，而 2 月是高峰期。我有几个亲戚朋友现在就住在美国，因为流感的问题，每天他们也是和我们一样，待在家里不敢出门，同样体会出来了 ”隔离“ 的滋味。

澳洲

澳洲最近同样也不太平。之前大家可能有听说澳洲大火的消息，其实关于澳洲大火的报道，去年 10 月份开始就有了，本来大家以为只是一场普通的森林火灾，扑灭就完事了。我看最近有报道澳洲大火的消息的时候，很多人在底下评论，大火一直在烧啊？没错，这大火一直烧，四个月了，烧的时候澳洲的卫星地图状况就是这个样子：这场火，不仅造成人命伤亡及经济损失，也对自然生态带来毁灭性破坏，使数亿动物遭遇灭顶之灾。已有近 5 亿只动物死于澳洲山火，并据相关报道显示考拉或将功能性灭绝。悉尼大学发布报告，全国约有 10 亿动物被大火波及，其中仅在澳大利亚袋鼠岛的大火中就有超 2 万只考拉死亡，考拉将被列为濒危动物。澳大利亚全境被烧毁的森林面积约 1120 万公顷，而去年震惊世界的亚马孙雨林大火烧毁森林面积才约 180 万公顷。此外，有 1400 多公里的海岸线都在燃烧，相当从东北烧到了江浙沪。慢慢地，前几天，山火逐渐逼近了堪培拉。1 月 31 日，因为山火的步步紧逼，澳大利亚政府宣布堪培拉进入紧急状态，这是自 2003 年山火危机之后 17 年以来，堪培拉首次进入紧急状态。2 月 2 日整天，堪培拉均处于高度戒备状态。堪培拉和周边地区的气温一度超过 42 摄氏度。当时堪培拉就是这么一个状态：其他的地区山火基本是这么一个状态：以及那些被烧死的无辜的动物们：澳大利亚的这场大火也对全球造成了影响。欧洲哥白尼大气监测服务发表数据：澳大利亚已经向大气排放约 4 亿吨二氧化碳，这个数据比全球 116 个二氧化碳排放量最低国家年排放量总和还要高。不过，就在最近几天，现在澳洲的山火由于一场暴雨的到来，很多地区的火已经灭了。但，这还没完，由于雨过大，洪水又来了。据《每日邮报》2 月 9 日报道，近日，澳大利亚遭遇了十年来最大降雨，东海岸被大规模破坏，悉尼正在全力应对洪水爆发，火车站都变成了游泳池。澳大利亚气象局预计，在新南威尔士州北部的一些气象站在 48 小时内录得超过 300 毫米的降雨后，降雨将持续到周日。据报道，周六，在新南威尔士州北部，67 岁的吉尔·萨瑟兰和她 30 岁的侄女汉娜驱车前往位于新南威尔士州北部河流地区的宁宾，途中他们穿过了一条被洪水淹没的道路。然而，他们很快就失去了对汽车的控制，车子灌满了水，沉了下去，完全从视线中消失了。但好在，大火已经基本停了，但愿这次洪水也能尽快过去，祝好！

巴西

当地时间 1 月 26 日，巴西东南部因受强风暴雨影响，正在遭遇百年不遇的泥石流灾害。暴雨接连两日肆虐米纳斯吉拉斯州，导致多处房屋倒塌，道路摧毁，很多生命瞬间流逝。到目前为主，此次灾情至少已造成 46 人死亡，超过 25000 人流离失所。巴西国家气象研究所表示，这是自 110 年前开始有纪录以来，本地区降下的最猛烈暴雨。军队现已对山区的村镇与交通设施展开全力救助，巴西政府也声称将努力建立一个全国性的灾害预防和早期预警系统。

波兰、丹麦

1 月 23 日，波兰海关总署发布消息。1 月 7 日，波兰官方向世界动物卫生组织通报，2019 年 12 月 31 日至 2020 年 1 月 4 日，该国卢布林省和大波兰省发生 8 起 H5N8 亚型高致病性禽流感。波兰是欧洲最大的家禽生产国，自 2017 年以来从未爆发过禽流感。 1 月 30 日，丹麦环境和食品部向 OIE 紧急报告称，丹麦发生一起 H5N1 型低致病性禽流感疫情。本次疫情于 1 月 29 日得到确认，此次疫情可能导致多达 4 万只禽类被宰杀，方圆 3 公里多达 35 万只家禽受到威胁。

法国、西班牙

1 月 21 日，西班牙东北部地区遭强暴风和大雪袭击，供电中断，几十万人无电可用，暴风和大雪至少已造成 4 人死亡。阿联酋《宣言报》22 日报道称，由于暴风和降大雪，能见度很低，气温急速下降，达到结冰的程度，地中海沿岸海浪急剧上升。西班牙紧急部门的报告表示，虽然与法国之间的供给线得到了修复，但因为积雪覆盖了 2600 多公里的道路，交通受阻，供电难以解决，位于东北部的吉罗纳省 22 万居民仍然没有电可用。

土耳其

土耳其内政部 1 月 25 日消息称，24 日晚发生在该国东部埃拉泽省的 6.8 级地震已经造成 22 人死亡，超过 1000 人受伤。据土耳其阿纳多卢通讯社报道，土耳其内政部部长索伊卢 25 日在新闻发布会上表示，埃拉泽省在地震中的死亡人数为 18 人，其邻省马拉提亚省死亡人数为 4 人。政府派出的救援队已从倒塌的房屋和建筑物的废墟中救出 39 人。

利比亚

根据俄罗斯卫星通讯社开罗 1 月 14 日的报道，利比亚冲突各方停火问题谈判 13 日在莫斯科举行，俄土两国代表参加了谈判。然而利比亚战火和谈失败，双方陷入了僵局。土耳其出兵面临全面内战永久分裂风险。

苏丹

1 月 14 日下午，苏丹发生政变，安全部门和军方在首都喀土穆机场附近发生激烈对峙，并伴有阵阵枪声。军方戒严了城区主要街道，喀土穆国际机场已关闭。中国驻苏丹使馆发出安全警告，提醒中国公民不要靠近机场区域。

也门

1 月 19 日，也门西部一个军事训练营遭遇袭击，造成数十名也门政府军士兵死亡，至少 100 人受伤，胡塞武装在马里布市发动了大规模伤亡袭击，命令也门军队必须保持高度戒备，做好战斗准备。

印尼

印尼国家抗灾署 6 号通报，首都雅加达和周边地区日前遭遇的洪灾，已造成 67 人死亡。印尼国家抗灾署发言人阿古斯在一份声明中说，截至当地时间 6 日下午，灾害还造成 1 人失踪，另有 3.6 万人居住在临时避难所。由于强降雨引发洪灾、山体滑坡等灾害，雅加达周边的 12 个县市已陆续宣布进入为期一到两周的紧急状态，以便救援和物资运输工作展开。

东非

东非近期爆发蝗灾，这被称为 70 年来最严重的沙漠蝗灾，其中肯尼亚受灾最为严重，数亿只蝗虫在肯尼亚境内肆虐。据联合国估计此次蝗虫数量达 3600 亿只，且数量可能在数月后暴增 500 倍。非常令人惊恐的是沙漠蝗群一天内可以吃掉能养活 2500 人的粮食，这也令当地出现了严重的粮食危机。蝗群密度一般达到每平方公里 1.5 亿只，蝗群一天可以随风飞行 100 至 150 公里，破坏范围及力量惊人。联合国粮食及农业组织已经发出警告，蝗灾将会造成近年来罕见的粮食危机，1900 万人将面临危及生命的饥荒。这个确实非常严重的，一些更详细的报道大家可以了解澎湃新闻报道的视频：https://www.thepaper.cn/newsDetail_forward_5758503，真的难以想象。

总结

总的来说，全世界的 2020 开局的确可以说是不怎么太平。仔细想想，这些现象的发生有天灾，有人祸。除了一些政治上的问题，这些灾难其实来源于人们对大自然的过渡攫取，或者说是对野生动物的滥杀和捕食。多难兴邦，天灾无情人有情。在大自然的面前，我们显得非常渺小，在灾难的面前，我们都是受害者。这时候就需要我们团结一心，站在一个战线上去把这些困难渡过去，而不是在这个节骨眼上发国难财，造谣传谣。像我们之前非典、汶川地震一样，众志成城，再难我们也能挺过去的。相信我们的国家，相信世界的人们。加油武汉，加油中国，加油全世界！

参考来源

本文选题和主要参考来源：2020 年只过去了一个月，全世界正在发生什么？https://mp.weixin.qq.com/s/V1iioQsuYITpFfRijZkQHw
卫健委：全国除湖北外其他省份确诊病例下降超 40% http://news.sina.com.cn/c/2020-02-09/doc-iimxxstf0048640.shtml
美国 4 个月近 2000 万人感染流感今年或是 10 年来最严重 https://www.codingsky.com/news/2020-02-08/11567.html
Weekly U.S. Influenza Surveillance Report https://www.cdc.gov/flu/weekly/index.htm#ILIActivityMap
澳洲遭十年最大暴雨，悉尼全力应对洪水爆发 https://new.qq.com/rain/a/20200209A06URA
巴西遭创纪录暴雨肆虐泥石流冲毁房屋 http://www.chinanews.com/m/tp/hd/2020/0126/134972.shtml
也门政府军遭胡塞武装导弹袭击至少 40 人死亡 http://www.xinhuanet.com/mil/2020-01/19/c_1210444134.htm
苏丹安全部门和军方在喀土穆机场附近激烈对峙 https://news.sina.cn/gj/2020-01-15/detail-iihnzhha2484546.d.html
67 人死亡 1 人失踪印尼洪水灾情严重 http://news.cri.cn/20200107/235b849d-523f-b512-c6d4-4feacd8347f4.html
东非遭 70 年来最严重蝗灾，情况或将恶化 https://www.thepaper.cn/newsDetail_forward_5758503

作者崔庆才发表于 2020-02-10 阅读次数：本文字数： 4.9k 阅读时长 ≈ 4 分钟

技术杂谈 Kubernetes 批量部署 Splash 服务

做爬虫的小伙伴可能听说过 Splash，它可以提供动态页面渲染服务，如果我们要爬的某些页面是 JavaScript 渲染而成的，此时我们直接用 requests 或 Scrapy 来爬是没法直接爬到的，此时我们可以借助于 Splash 来帮我们把 JavaScript 渲染后的真实页面结果拿下来。不过 Splash 在大批量爬虫使用的时候坑不少，Splash 可能用着用着可能就内存炸了，如果只是单纯启 Docker 服务又不好 Scale，另外也不方便当前服务的使用状态，比如内存占用、CPU 消耗等等。最近把 Splash 迁移到了 Kubernetes 上面，正好上面的问题就一带解决了。我们既可以方便地扩容，又可以设置超额重启，又可以方便地观察到当前服务使用情况。下面简单记录一下我把 Splash 迁移到 Kubernetes 上面的过程，真的迁移过来之后省了很多麻烦，推荐大家也可以试试。好，下面正式开始介绍。

必备条件

首先，我们需要有一个 Kubernetes 集群，可以自己搭建，也可以使用 Minikube 或者用阿里云、腾讯云、Azure 等服务商直接提供的 Kubernetes 服务。另外我们需要能使用 kubectl 连接和控制当前的集群，同时需要安装好 helm 并配置好 stable 版本的 Charts，在这里我使用的是 Helm 2.x。在这里列一些参考资料：

搭建 Kubernetes 集群：https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/create-cluster-kubeadm/
Minikube：https://kubernetes.io/zh/docs/setup/learning-environment/minikube/
Helm V2 安装和使用：https://v2.helm.sh/docs/
Charts：https://github.com/helm/charts

上面的内容准备就绪之后，我们就可以开始 Kubernetes 搭建 Splash 服务的流程了。

整体流程

创建 NameSpace
创建 Service
创建 Deployment
安装 Ingress Controller
配置域名解析
配置 Authentication
配置 HTTPS

上面就是本节所要介绍的基本内容，下面我们开始吧。

创建 NameSpace

首先我们将 Splash 安装在一个独立的 Namespace 下面，名字就叫做 splash 吧。 yaml 内容如下：

apiVersion: v1
kind: Namespace
metadata:
  name: splash

这样就声明了一个 NameSpace，名字叫做 splash。

创建 Service

Service 的创建也很简单，我们注意声明好 namespace 和端口等信息即可：

apiVersion: v1
kind: Service
metadata:
  labels:
    app: splash
  name: splash
  namespace: splash
spec:
  ports:
    - name: "8050"
      port: 8050
      targetPort: 8050
  selector:
    app: splash
status:
  loadBalancer: {}

在这里选择了端口号 port 8050，即服务运行的端口为 8050。targetPort 也是 8050，这个代表 Pod 里面容器的运行端口。另外声明了 labels 和 selector 的内容，大家可以稍作了解。

创建 Deployment

接下来，就是最关键的了，我们使用 scrapinghub/splash 这个 Docker 镜像来创建一个 Deployment，yaml 文件如下：

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: splash
  name: splash
  namespace: splash
spec:
  replicas: 3
  selector:
    matchLabels:
      app: splash
  revisionHistoryLimit: 1
  strategy: {}
  template:
    metadata:
      labels:
        app: splash
    spec:
      containers:
        - image: scrapinghub/splash
          name: splash
          ports:
            - containerPort: 8050
          resources:
            requests:
              memory: "1Gi"
              cpu: "1"
            limits:
              memory: "4Gi"
              cpu: "4"
      restartPolicy: Always
status: {}

这里也有几个比较关键的点：

metadata.labels：这里需要和 Service 里面的 selector 对应起来。
spec.template.spec.containers[]：这里声明 splash 的镜像，用的是 latest 镜像 scrapinghub/splash；端口地址用的 8050；restartPolicy 使用的是 Always，这样 Splash 如果崩溃了会自动重启；resources 设置了使用的内存和 CPU 的请求和限制值，这里大家可以根据机器和爬取需求自行修改。
spec.replicas：运行的实例个数，这里设置为了 3，这样就会启动 3 个 Splash ，Service 会对其负载均衡。

好了，写了上面三个 yaml，我们可以将其合并到一个 yaml 文件里面，如 deployment.yml，然后执行：

1	kubectl apply -f deployment.yml

这样我们就可以观察到 NameSpace、Service、Deployment 都创建成功了，Pod 随之也创建成功了。

安装 Ingress Controller

接下来我们想要配置一个域名解析，并配置好 HTTPS。首先我们需要安装 Ingress，这里我们使用 Helm 2.x 安装，使用的 Charts 为：https://github.com/helm/charts/tree/master/stable/nginx-ingress。这里我们稍作修改，指定 NameSpace 和镜像即可：

1	helm install --name ingress-splash --namespace splash --set defaultBackend.image.repository=mirrorgooglecontainers/defaultbackend-amd64 stable/nginx-ingress

这里我们将镜像修改了一下，避免国内 Kubernetes 无法拉取镜像的问题。 OK，安装好了之后，可以看到 Ingress Controller 就安装成功了。

域名解析

域名解析就好配置了，直接将域名配置到 Ingress Controller Service 的 External IP 上面即可。

配置 Authentication

Splash 部署完了之后，默认是没有 Authentication 的，如果直接暴露在公网中，是可以被他人直接使用的。所以我们需要对其配置 Authentication，并配置 Ingress 域名解析。这里 Authentication 我们使用 HTTP Basic Auth 就好了，要配置这个，我们需要先新建一个 Secret。那么 Secret 怎么创建呢，我们先用 htpasswd 生成一个秘钥文件，用户名为 splash：

1	htpasswd -c auth splash

执行完了之后本地会生成一个 auth 文件，我们用这个 auth 文件创建一个 Secret 即可：

1	kubectl create secret generic basic-auth --from-file=auth --namespace splash

这样 Secret 就创建好啦，用户名就是 splash，密码就是刚才创建秘钥文件时输入的密码。上面更详细的介绍参见：https://kubernetes.github.io/ingress-nginx/examples/auth/basic/ 好，然后我们创建 Ingress。新建 ingress.yml 文件内容如下：

apiVersion: networking.k8s.io/v1beta1
kind: Ingress
metadata:
  name: ingress-splash
  namespace: splash
  annotations:
    nginx.ingress.kubernetes.io/auth-type: basic
    nginx.ingress.kubernetes.io/auth-secret: basic-auth
    nginx.ingress.kubernetes.io/auth-realm: 'Authentication Required'
spec:
  rules:
    - host: <domain>
      http:
        paths:
          - backend:
              serviceName: splash
              servicePort: 8050
            path: /

这里 metadata.annotations 里面声明了三个选项，就是设定 HTTP Basic Auth 的。注意这里 spec.rules[].host 的内容换成自己的域名。好，然后执行即可：

1	kubectl apply -f ingress.yml

OK，这样 Ingress 也创建好啦。现在我们只需要访问 http://<domain> 即可访问到 Splash 服务啦。初次访问需要输入用户名和密码，如图所示。登录完成之后就可以看到 Splash 的界面了，如图所示。

HTTPS

这时候整个 Endpoint 是 HTTP 协议，会被提示不安全，如果我们想要配置 HTTPS，还需要申请一个证书。证书可以到阿里云、腾讯云等等服务商申请即可。申请完了，我们可以得到 crt 和 key 两个文件。接下来我们首先需要配置一个 tls 类型的 Secret，命令如下：

1	kubectl create secret tls tls-splash -n splash --cert <cert_name>.crt --key <cert_name>.key

这里 <cert_name> 替换成你申请的证书文件名即可。这样我们就创建了一个名字为 tls-splash 的 Secret，下面我们开始使用。修改 ingress.yml 文件如下：

apiVersion: networking.k8s.io/v1beta1
kind: Ingress
metadata:
  name: ingress-splash
  namespace: splash
  annotations:
    nginx.ingress.kubernetes.io/auth-type: basic
    nginx.ingress.kubernetes.io/auth-secret: basic-auth
    nginx.ingress.kubernetes.io/auth-realm: 'Authentication Required'
    nginx.ingress.kubernetes.io/ssl-redirect: "true"
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  tls:
    - hosts:
        - <domain>
      secretName: tls-splash
  rules:
    - host: <domain>
      http:
        paths:
          - backend:
              serviceName: splash
              servicePort: 8050
            path: /

这里主要修改的点有两个，一个是增加了 ssl 重定向，这样如果我们以 HTTP 访问过去，就会被跳转到 HTTPS 的地址。另外就是 spec.tls 字段了，这里声明 hosts 和 secretName 即可。 OK，重新应用：

1	kubectl apply -f ingress.yml

大功告成，现在我们就可以使用 https://<domain> 来访问我们的 Splash 服务了。

测试

最后，输入个网址测试下吧，如百度，渲染成功，如图所示。以上，便是 Kubernetes 搭建 Splash 的方法。希望对大家有帮助。

作者崔庆才发表于 2020-01-29 阅读次数：本文字数： 5.1k 阅读时长 ≈ 5 分钟

技术杂谈 2019 年终总结：新生活、新探索

2020 年的新年过去了，去年也是在春节期间写的年终总结，今年也是时候再总结和反思一下我的 2019 年了。总的来说，2019 我给自己的一句话总结为：新生活、新探索。今年是我从学生时代正式迈入职场的第一年，也是体验了新的生活环境的第一年，没有预想到的变化有很多，接触的新的挑战也很多。这一年，我也在努力调整自己，去适应新的工作环境和生活节奏。但今年自己达成的面上的成就不算多，更多的时间在于学习、自我适应和调整，同时一年里我也有了一些新的感悟。所以，在此把我这一年的变化、思考和新一年的目标做一下总结，希望来年可以继续加油。

变化

第一次正式工作

2019 年 1 月份，我硕士毕业了，接下来就正式开始工作了。2019 年 3 月 1 日，我正式入职微软，在微软小冰部门，我换了一个新的小组，有了一群 Nice 的新同事。我的工作的内容属于 AI Creation，不过偏全栈一点，会涉及到自然语言处理、图像处理、前端、后端等各个方面的技术。正式入职之后，我负责小组的这一个全新的探索方向。怎么说呢？刚开始我接手这个项目的时候，基本上整个项目还是在实验阶段，我要做的就是把整个项目规范化、搭建一套完整的 End2End 的 Pipeline、检测模型、管理平台和服务器。我之前在实习阶段的时候没有接触过线上代码，不了解现在代码的一些逻辑和架构。所以刚开始的时候面对一些杂乱的实验数据、设计草稿、线上代码，面对这些一些需求，一段时间内真的是感觉不知道怎么办才好。那会儿我记得一直在梳理思路，在一点点 Debug 现有的代码的一些逻辑，然后和我的 Manager 和同事一起讨论实现的思路。慢慢地，我逐渐也清楚了现有的代码和架构，知道了我可以具体怎么实现，期间我把自己的一些设计思路改了好几次，比如我记得有好几个 Pipeline 拆了又拆，有一些设计 Schema 改了好几次，最后慢慢稳定下来了，渐渐地，我把一些模型、Pipeline、管理平台、服务器慢慢搭建好了，现在我做的一些东西也上线并正式投入使用了。回想起来，刚开始真的挺难的，不过现在做成了，还是很有成就感的。在这里真的要好好感谢我的 Manager 和同事们，他们对我的帮助很大。在讨论项目实现的过程中，我收获了很多新的想法。我承认我自己这个人并不是特别喜欢与人合作，倾向于坚持自己的想法，倾向于自己去把一件事去做完，所以我最开始可能更偏己见一点。但在讨论整个项目的过程中，我学到了，有些思路原来还可以这么想，原来还可以这么实现。真的，有些设计思路和想法我确实一开始没有想到，但经过讨论之后，确实学习到了很多技巧和方法，慢慢地，我的一些编程的思想也有了变化，我会有自己的想法，同时也倾向于把我的一些思路说给别人，看看别人怎么想的，在大多数情况下，我会想到更优的解决思路，即使没有，我也学到了一些新的思考方法或者知识点。另外在这期间，我的小组队伍也壮大了起来，我自己也作为小组长（算是）指导了几位新同事一起参与整个项目，在这期间我也悟到了一些合作或指导的一些经验，大家都非常给力，目前来说还是很不错的。要说这一年的工作压力和强度的话，整个走下来其实还是不小的。在前期阶段，其实更多来自于项目本身的压力，因为有太多的东西需要做，同时需要学习和了解的新东西也有很多，当时也没有找到适合自己的工作节奏，算是“摸爬滚打”了好一阵。在后期阶段，也有一些新的挑战，比如要去思考哪些方向是对的，怎样和同事更好地协作一起优化一些功能点，当然也一直有新的技术需要学习。整体感觉上来，比我的实习期的工作强度大了非常非常多，可以说和实习期的工作强度是没法比的。现在想想，实习的时候，我差不多半年时间写完了一本爬虫书，晚上还能和我的小伙伴们聚众开黑王者荣耀。现在？功能实现了吗？Bug 修完了吗？好了，滚去撸代码了。写书？开黑？一天，一晃就这么过去了。

公众号

正式工作之后，发现自己打理公众号的时间比我预想中的要紧张许多，没错就是这个「进击的Coder」。对于公众号的运营，我也慢慢地佛系了，在 2019 快年底的时候，我把我的公众号转给我的女朋友小马来运营了，不得不说她运营得非常好，会找一些很不错的技术文章帮我排版，帮我发布，我有原创文章我也会交给她帮我发一下，的确减轻了我不少的压力。她也有很多想法，写了一些原创，也会策划一些活动，后来，不少公众号的粉丝居然渐渐转成她的粉丝了？！我回来后，你们还认识我吗？说一下数据吧，写文章时，公众号粉丝数量为 57420，常读用户是 9857，平均阅读 3000 左右，算是技术号中比较普通的水平了，常读用户比例也不怎么高，而且对于我 2019 年的 Flag 10 万，还有挺大的差距，这个后文会详细说。说说公众号这件事吧，为什么我这次单独把「常读用户」数据放出来了呢？因为现在其实粉丝数并不是那么重要的，常读用户才是更重要的。公众号在 2019 年做了一次大的改动，「信息流」是其一，「在看」是其二，另一个大的改动就是有了「常读的订阅号」这个功能，大家应该也都注意到了，它会出现在最上端，几个圆形的公众号头像，如果公众号有了消息，它会有一个绿色的小点，大多数情况下，然后我们就会点开看了，可以说对阅读量的帮助是很大的。对于信息流来说，如果我们发文的时机把握不好的话，很可能文章就会被冲淡在信息流里面再也找不见了。所以，常读用户的多少和阅读量有着很大的关系。这也是有一些公众号虽然粉丝很多，但是阅读量并不高的很大原因；同时也是一些公众号虽然粉丝少，但是阅读量一直很高的很大原因。「在看」功能也是很重要的，当然这取决于文章质量了，如果文章质量高，「在看」多，大家从「朋友在看」入口进入到文章的的人也越多，阅读量自然也会高。另外还有原创，大家可以看到很多原创率高的号主，阅读量都是很高的，因为原创，内容独特，见解到位，他们的公众号常读用户量和常读用户比率一般都是非常高的，阅读量自然就高了。另外公众平台对于原创也有一定的鼓励和推荐机制，帮助原创号主获得更多的流量。另外现在我观察到技术公众号的一个趋势，就是很多文章都转来转去，大多数公众号的原创率都是很低的，另外广告现在也越来越多（我也参与了），读者又不是傻子，在筛选一篇优质公众号文章越来越难的今天，读者会倾向于阅读原创率高或内容优质的公众号。那些没有原创能力或者内容质量不高的公众号，阅读量增长会非常困难，甚至于淹没于越来越大的公众号海洋之中。所以，现在运营公众号，最重要的数据是什么？最直接的当然是平均阅读量，这可能直接关乎一个公众号值多少钱或者接到的广告值多少钱。平均阅读量更多取决于什么？「常读用户」和「在看」。所以一方面，我在运营的时候会更注意公众号的发文质量和频率，一定不能长时间不更新，否则万一公众号从「常读的订阅号」列表里面掉出去，就很难找回来了。另外我对于粉丝量其实并没有那么看重了，所以我也很少去参与互推的一些活动。 2019 年我发的文章一部分是原创的技术文，要写的话我会写好，把一些来龙去脉和原理都说清楚，保证文章的质量，但由于时间紧张，原创个人感觉发的并不多。另一部分是转载的一些觉得有价值的技术文，我会和小马一起去挑选一些我们认为还不错的技术文或时效新闻发给大家，希望读者能有所收获。最后就是广告了，2019 年接的广告其实说实话不少，当然接广告也基本上是为了恰口饭，如果大家看到了是广告标题，能帮着戳一戳进去加点阅读量我就非常感激不尽了。其他的互推或者抽奖送书等等活动，我很少很少参与了，一方面觉得意义并没有那么大，对读者也不友好。我觉得公众号专注于提供优质的内容、见解和想法，这才是好的发展路子，我的涨粉速度肯定没有互推来得快，而且确实也因为我的个人原因对公众号精力投入不够，导致阅读量增长比较慢，但我觉得这是适合我的初衷的发展路子，也是我比较舒服的运营方式。所以，接下来我还是秉承的之前的运营理念，公众号的方向还会专注于技术，致力去提供优质的内容给大家。另外我也有一些新的运营想法。我一直有关注一个公众号叫做「未闻Code」，公号主是「青南」，他是做网络爬虫方向的，也著有很不错的技术书籍，也在维护一个开源项目 GNE，即新闻网页正文通用抽取器，项目地址：https://github.com/kingname/GeneralNewsExtractor，可以实现新闻页面的自动化抽取，目前已经有 1k 多个 Star，推荐大家关注下。他的公众号有一个我觉得很不错的运营模式，那就是「一日一技」，他会把一些总结或新学到的技能整理出来发到公众号上，有的文章内容可能并不长，可能就是记录自己学习或踩坑的过程，甚至可能就是一个个小的零碎的知识点，但我感觉还是很有价值的，读者反响也不错。而我之前在写文章的时候，我会必须要把一个知识点扩得很大，把知识点或项目的来龙去脉或者完整的使用流程写一篇长文再发出来，因此大家可以看到我的技术原创文一般都会显得比较完整甚至叫啰嗦，为写这篇文章，我可能要去搜罗各种资料，可能也去新学一些新的东西，这样也致使我写一篇文章耗费的时间也会比较长。所以，我想寻求一个转变，我想，比如某天我在工作中解决了一个什么问题，或者我学到了一个小的骚操作，或者我就学到了一个小的知识点，我想也把它写下来，把这件事稍微说明白就行，暂时不去把所有的涉及这个知识点的的东西完整总结。比如我今天刚学到了 Kubernetes 在部署时动态替换环境变量的骚操作，我就只把这个记录下来，分享给大家，不再去展开讲。这样可以提高我的产量，同时把我今天学到的或想法写下来与大家分享，可能文章比较短，可能知识点描述得不够全，但我觉得是一个不错的路子。后面我会尝试下这个方案，如果得到的反响不错的话，我会继续坚持。

开源

作为一名程序猿，比起刷抖音，我更喜欢逛 GitHub，同时自己也会喜欢写一些开源项目并发到 GitHub 上面，如果能收获一些 Star，心里会有很大的成就感。先说一下目前的数据吧，我的 GitHub 地址是：https://github.com/Germey，目前粉丝数 4.9k，收获 Star 数约 4k，2019 年 Commits 数量 1053 次，目前主要维护了 Gerapy 和 ModelZoo 两个项目，还有一些其他的项目如 ProxyPool、CookiesPool 也有一些人在使用。由于时间问题，2019 年我在开源这一方面的贡献并不好，Gerapy 和 ModelZoo 两个项目也有一段时间的停更，导致现在也一直不瘟不火，Star 数也一直不多。我觉得能够有自己拿得出手的开源项目确实是一件很有成就感的事情，新的一年，我会投入更多的精力参与到上面来，目前还是会专注于 Gerapy 和 ModelZoo 两个项目上面来。同时随着学习和积累，可能还会酝酿出新的项目。新的一年，继续加油。

写作

关注我的读者可能知道我在 2018 年 4 月出版了一本《Python3网络爬虫开发实战》，这也是我写的第一本书，其目前销量已经远远超过我的预期，到现在为止不到两年时间，累积印刷 15 次，印刷量 7w 多，豆瓣评分 9.0 分，也已经被很多学校或培训机构当做教材或辅导书，这些都是我之前没有预料到的，同时这本书也为我带来了一笔可观的收入。但免不了的，讲爬虫，网站不会是一成不变的，网站一改版，整个案例就跑不通了。这本书，现在挺多案例已经过期了，书稿的内容不好直接修改，我只能在 GitHub 上尽量去跟进修改，但对于一些初学者来说，是很不友好的。另外，爬虫技术日新月异，很多技术或框架已经过时了，另外也出现了一些新的技术和知识点，当时在写书的时候并没有提及到。所以，我去年就跟编辑策划了《Python3网络爬虫开发实战》第二版的撰写。本次第二版相对于第一版来说，修订了过期的案例，补充了新的知识点。第二版为每个知识点的实战项目对接了针对性的练习平台，避免了案例过期的问题。另外主要增加了异步爬虫、JavaScript 逆向、App 逆向、智能网页解析、深度学习识别验证码、Kubernetes 运维及部署等知识点，同时各个爬虫知识点涉及到的请求、存储、解析、测试等工具也进行了丰富和更新。到现在算是基本完稿了，现在已经在审稿了，但我还想修改和增加一部分内容。比如最近提议出来的修订过期案例的问题，这个问题很重要，不然不知道啥时候我书里的案例就又过期了，为此我自建了爬虫案例平台，项目在这里：https://github.com/Germey/Scrape，最近忙着迁移和开发，现在正在把一些案例修改到案例平台上面。其他的稿子差不多了，正在审核中。所以基本上我现在是边改边审的状态，也希望能提前出版的时间。我知道有些读者很急，也盼着第二版的出版。现在没几天就会有读者问我第二版什么时候出版呀？情况，就是上面这个样子，已经开始审稿了，可能还得几个月吧，争取 2020 上半年可以出来，如有消息，我一定第一时间通知大家。当然写作也不仅仅是写书，也包括日常的积累。我自己在平时的工作和学习的过程中也会记一些笔记。我现在把我所有的笔记都用 Typora 这个 MarkDown 编辑工具写下来，然后整理和同步到 GitHub 和 GitBook 上面，我分了好几个记事本，有技术类、生活类、书稿类、开源文档类，整理和总结了不少东西，挺多东西并没有公开发出来，原因我也在上文「公众号」一节提及了一下，但我也想寻求一个新的运营方式，所以我准备把一些自己整理的东西，即便是小的知识点，也都发出来，跟大家一起学习和探讨。不怕被笑话「原来我这个知识点还不会呢」，我新学到的就发出来看。因为只有「改革开放」才能真正地进步，固步自封最终吃亏的还是自己。

知识

说到知识，今年来我个人觉得学习的还算及格，我学到的知识一方面来自于工作，一方面来自于平时生活。稍微总结一下今年来都学了些什么吧：

C#、.NET。其实在实习期间我不接触线上代码，C#、.NET 并不常用。正式开始工作了，这个必须学起来了，因为一些 Service 必须要用它来搭。学了之后，确实觉得 C# 设计得真的很棒，很多特性和理念值得好好学习。
爬虫逆向。在 2019 年之前，我对爬虫逆向可以说基本不了解，因为在写第一版书那段期间，网站采取混淆或加密的不多，App 抓包基本都能抓得到。后来时代变了，网站现在你没有个混淆，基本就不是个合格的网站，很多 App 接口抓包也搞不到，或者一些接口加了很多加密参数。所以说 JavaScript 逆向和 App 逆向不学基本上就没法玩爬虫了。所以我也在开始学习和了解这一部分的内容，在 2019 下半年加入了夜幕团队，团队有几位搞逆向非常厉害的大佬，同时我们也合作出了一套 JavaScript 逆向课，另一方面也为了写书做准备。总之，收获很大，也非常感谢大家的指导和帮助。但由于这个技术比较敏感，担心发出来被对方寄律师函什么的，所以我也几乎不发文。不过现在我有了新的思路了，自建爬虫案例平台，所以等建好了，我会发一些关于逆向方面的文章的，大家敬请期待。
Kubernetes、DevOps。现在 DevOps 和 Kubernetes 基本上可以说是大势了，部署一把梭。在工作中我们也慢慢地把一些服务迁移到 Kubernetes 上面，为此我也自己摸索和搭建过 Kubernetes 集群，搞了一些 Service、数据库的搭建，DevOps 一套主要用 Azure Pipelines、GitHub Actions，是真香！现在我的几乎所有服务都在往 Kubernetes 上面迁，新的爬虫案例平台也用了 GitHub Actions 来实现自动部署。
深度学习。在 2019 年之前，我也有一些深度学习的基础，但 2019 年我在实现一些自己的开源项目 ModelZoo 的的时候，又学习了一些新的模型，把 ModelZoo 重新迁移到 TensorFlow 2.0 上面。另外在工作之余也学习了一些新的模型，如序列标注相关、图像识别相关。但最近我又有了新的想法，用了一段时间 TensorFlow 2.0 之后，感觉有些地方实现起来还是别扭，对接了 Keras 之后，调试也还是不太方便。经过与一些大佬的交流，决定准备转 PyTorch 了，这真可能是趋势，不知道我的感觉对不对。但选择比努力更重要吗不是？方向感觉不对，就要及时调整，没毛病。（逃
各种开源库。这些也不算系统的知识点了，单纯就是逛 GitHub 看到的，比如一些实用的类库，比如 typing、loguru、retrying、faker、airtest 等等，学了，顺带写一篇总结文，慢慢积累下来。

总的来说，2019 学到的新东西还算不少，慢慢地我也摸清了我的技术路线，现在还会是 Python 主力的全栈方向，将来可能还会变，一些技术栈我会去慢慢补齐，我知道自己哪些不会，为了达成我的一些目标还需要去学什么。另外在学习过程中，思考和总结是非常重要的。

遇到不会的，多去思考和搜索，实在不行求助别人。
解决了问题，记得复盘和梳理下来。
学习新知识，顺带把学到的整理和记录下来。

个人觉得这样学习起来，效果还是不错的。新的一年，继续加油。当然除了技术，我自己也在学一些其他的，比如英语，之前跟小马出去塞尔维亚玩了一趟，英语要么听不懂，要么说不出来，太难受了。现在上班路上，我会抽时间听一点 BBC，用的是网易云。大家都在用啥学英语啊？另外理财相关的知识，我也在了解，同时买了点基金试试水，不过我还觉得储备的知识还不够，还需要继续学习。

健身

这个话题，真的有点让我难以开口。因为这个健身，我真是做的太失败了，我一年几乎没有健身几次，加上吃太好，从 116 斤胖到了 141 斤。141 - 116 = 25，没错，我一年胖了 25 斤！一方面，小马带我吃的太好了，哈哈哈哈，我们几乎每周都会出去吃好吃的，另外她还会给我买各种零食和好吃的，家里的零食一箱箱永远吃不完。有人说了，你胖了这么多，人家小马怎么瘦了呀？别找借口了。偷偷抹眼泪，说好一起变胖呢？另一方面，也是不运动，一坐一天，晚上还没啥空去健身房，日积月累，就成了这样子了，照片就不要看了，我不会给你们看的。说到健身，小马几乎每周都会去跳舞或者去健身房，我偶尔周末会跟着去体验几节课，但是上完之后，在家就没有继续炼了。哎，也是确实没太有时间锻炼，也有一个原因就是太懒了，可能后者才是最主要的原因。但这样下去我的体重就要收不住了。在年前的时候我立了 Flag，一周运动至少两次，主要是跑步，如果参与了一次健身也算，我成功坚持下来了。年后继续！我会变瘦的！没想到，短短一年，「减肥」这个词居然会落在了我的身上。

感情

嘿嘿，我和小马一起从 2018 跨到了 2020，在一起三年了（抖机灵。哈哈，其实我们已经在一起 449 天啦！总之和小马在一起的日子特别开心，以至于幸福肥了 25 斤（逃。想分享的生活有太多，但是又觉得在这里公开秀恩爱有点不好意思，反正就是很幸福哈哈哈。比如一起出去吃好吃的、一起旅游、一起健身、一起拍照、一起画画、一起插玩具、一起玩游戏、一起去看展、一起穿情侣装。有时候我们一起吃到了好吃的就会一起高呼「卧槽这个好吃，卧槽这个也好吃，卧槽这个怎么这么好吃！」，有时候走在路上两人就像小孩子一样牵着手或者追来追去，有时候好长时间（一天）不见面，我们再见到对方就互相扑过去，我们很多时候会在对方面前表现得像个孩子或者像一只动物（猫？），我们每人的表情包已经全是「猫」和「狗」了，不多，也就一百多套吧。不好意思，不小心又秀了一下。怎么说呢？我经常会在微博分享我们两人的生活。有人说我的微博已经从「互联网资讯博主」变成了「恋爱博主」，就是这么个感觉。本来我的书里面不是写了一节「Ajax 爬取微博」来教大家怎么学 Ajax 分析和爬取吗，结果大家爬下来了一堆狗粮，之后跟我说再也不学爬虫了。我：？？？嗯，我也不知道他后来有没有再学，可能真的没有再学了吗？不过有时候我也会犯蠢，惹小马不开心或生气（但我们不会分手的，我也慢慢地从中学到了很多，我们的感情也变得越来越好了。昨天我看到知乎一个推荐「女生最想收到男生送的什么礼物？」，我看了看这都什么玩意，然后发给了小马，说我要是送你这些肯定会被分手了，小马看完，说我长大了，开心！看我是不是变得越来越懂你了呢。新的一年，希望我们还会继续好好在一起呀！对了，朋友圈和微博没得刷了或者饿了的话，来刷刷我的微博「崔庆才丨静觅」吧（逃。

思考

关于思考，这是一个非常抽象的东西，看不见摸不着，但确实很多时候，某些事情思考的深度、广度决定了我们的高度。在这一年来，我接触了很多人，了解了一些事。比如一个技术项目吧，不同的人对于一个项目思考的深度就不同。很多人可能就是，接到了一个任务，别人告诉他要做什么，怎么做，那他就做完就行了，然后就完事了。但有的人，接到这个任务，会首先想，我这是在做什么？为什么要这么做而不是那么做？做的时候怎样实现才是最佳的？做完了还能做点什么才能变得更好？他会对事情的来龙去脉了解的非常清楚，结束了再去复盘和思考。这也是我觉得很多人所欠缺的一些地方。我觉得人和人之间段位的差距就是这么拉开的。有的人可能会觉得，考虑这么多，找这个麻烦干什么呢？这其实真不是自己找麻烦，思考的成本其实很低，我们用来思考的时间其实很多，比如路上、休息时、吃饭时、睡前等等。不怕思考浪费时间，怕的是不去思考。我前几天跟一位非常好的朋友吃饭聊天。这位朋友，我真的很佩服他，我觉得他有很多程序员少有的一些思维，他在思考一些事情时会考虑非常全面，就像上文所提到的一样。比如我之前曾经跟他商量一个实现方案，他第一个问我的问题是，为什么你会这么想这么做？你的理由是什么？你打算怎么来实现？只要你能把我说得通，我就支持你这么做。比如一些方法论上的东西，他一直在思考和探索一些适合自己的生活、工作方式，会思考自己想要做什么、为了达成某个目标怎样做最好、怎样才是最佳实践，同时他也在不断的探索和试错中完善自己的方法论。我从他身上学到了很多，同时我觉得我自己跟他还有很大的差距，还是要多多加油啊。所以，有时候，我们也需要停下来去思考，自己在做什么、为什么要这么做、怎样做最好，甚至需要去思考一下，自己是谁、从哪里来、要到哪里去。

合作

关于合作，今年我也体会到了很多，我的想法也变了许多。怎么说呢，我自己原本是一个倾向于单枪匹马挑战一切的人，同时也不想去麻烦别人，比如一件事情，我习惯于包揽下来，自己去完成，有时候不想给别人添麻烦，有时候觉得交给别人不太放心或者担心做出来不符合我的心意。慢慢地，在团队合作过程中，我意识到了，自己不是全能的，术业总会有专攻，总会有在某一方面比自己强的人。而且随着工作强度的变大，有些事情自己大包大揽真的有点力不从心。两点体会吧。

第一，一个人并不是万能的。每个人不可能在所有的事情上做到极致，同时一个人的精力也是有限的。几乎没有人能像 Linus 一样几乎单枪匹马做出一个 Linux 内核，但你说 Linux 和杜兰特比打篮球，谁更厉害？
第二，总会有人在某个方面强过自己。随着接触的人和事越来越多，我发现就是有人在某个方面比自己强，或者思考的问题深入，或者完成的效果好。所以，首先不要因为某个方面不如别人而感到难过，有些事，可以放心交给别人去做，有时候结果可能甚至远超过自己的预期。当然这个有个前提，确实也得看人，去学会分辨一些靠谱和不靠谱的人。

所以，现在我在工作中，一些功能和需求，我不会再像之前一样倾向于大包大揽，相信自己的一些靠谱的合作伙伴，每个人直接好好分配，合作的时候一起交流、探讨。同时我自己也指导着两位同事，有些任务我会交给他们去做，不会再因为不放心和给别人添麻烦而全把任务归到自己。有时候真的，最终可能还会有意想不到的效果，或者在跟别人交流的过程中学到一些新的东西。所以，Be Open，这是我的一点体会。

目标

关于这个，我体会也很深。我回顾了自己一年以来没有做和已经做的事情，发现了这么一个现象：有件事我确实给自己定目标了，比如我要学习 Go 语言。然后我就把这个加到了我的待做清单里面，没有给他设置时间限度，也没有具体规划我怎样去做，哪个时间去学什么，反而自己的时间被一些零碎的或更紧急的事情占据了，最后我一整年都没有学 Go。我仔细想想，其实也并不是没有时间，有时候，我在某个时间段，确实是完全闲着的，比如我周六的时候，可能会躺在床上玩手机，一玩一上午，但那会啥也不想做，也没想好要那会要做什么。我反思了一下自己，还是因为自己给自己的规划不明确。主要有这么两点：

第一，某些目标我设置的太大，没有详细去规划什么时间做什么。比如学 Go 语言，我应该去好好思考一下，我要在多久时间内达成这个目标，我应该什么时间去做什么，我应该去细分到每一章节，在最开始的时候可能没必要所有的都分的那么细，但真正下一步要做的，一定要列得详细再详细。比如说，我要三个月内学好 Go 语言，我可以先思考，三个月，我要学多少知识模块，比如有十个知识模块，那么我就规划每一个模块大体什么时候完成，每个模块列到自己的 Todo List 里面，设定好期限，注意，一定要设置好期限，不然真的会一拖再拖！然后，最开始我可能没必要把大把的时间把每个模块里面的每个小知识点都拆分好，但前面的一定要列好，比如我十个模块，我最开始的一两个模块一定要再拆分规划好，同时再设定好每个小知识点的时间。要是前面的模块学完了，再去抽时间规划下一个模块就好了。
第二，没有提前设定好每个小目标。我反思了，为什么有的时候我不知道要干些啥呢？原因就是我没有提前规划好我第二天或者接下来的时间做什么。所以我后面决定改变一下，我会为自己提前做好规划，比如我第二天做什么，以及另外一个很重要的，规划一些零碎的时间做什么，比如学习慕课网的一个视频，或者去学习某一节英语课，或者去完成某项健身活动，把时间都利用起来。

感悟

另外，这一年中，我也悟出了一些做事的原则或者生活上的感悟，我把一些体会比较深的写下来。

别自嗨，多往外看看。有时候我们可能新学到了一个知识点，或者新做成了一个功能，就觉得自己很了不起了，但殊不知，可能别人已经把这个知识点当做必备知识，或者我们做出来的这个功能拿到外面去，其实是完全被爆的。所以，不要闭门造车，多出去看看，多了解下别人是怎么做的，多了解下这个的前沿和天花板已经到了什么地步，站在巨人的肩膀上，往往会走得更远。
别沉浸于过去。有时候我就会沉浸或满足于自己已经取得的一些成就，去“啃老”，但这样是不对的。不论我现在已经取得了什么成就，我都不应该沉浸进去。要把每一天当成 0 起点去对待，和自己的前一天去比较，每天进步一点，这样日积月累，进步就显现出来了。
多反思和复盘。就像刚才说的，我们每个人可能一天上班完了，就回家睡大觉了，然后第二天接着去上班。但有多少人每天晚上回问，自己今天到底进步了什么，即使没有进步，也反思一下自己今天为什么没有进步，怎样来解决这个现状。所以，我觉得每天去反思和复盘是很重要的。睡前的十几二十分钟，去思考一下，今天做成了什么、没有做成什么、下一步该怎么做，我觉得还是非常有价值的。
不能打包票的不要许诺。很多事情，我们要量力而行。有时候我答应过别人一件事情，可是到了时候，我发现自己没有时间完成或者没有能力去完成，最后去跟别人说要拖延时间或者干脆不做了。这其实对别人来说也很不好，而且本来可能是帮别人一个忙，反而可能会成为倒忙。所以，一些事情，在答应之前，好好想想到底有没有问题，如果不能打包票，不要轻易许诺。
一些小事也别以为很简单，重要的是细节。一件事，做的时候不要眼高手低，本来以为很简单的一件事，觉得分分钟就能做完，结果做完了发现很多细节没有把握好，出了很多错误。比如我记得之前我答应小马改个文章，本来以为很简单的东西，心想不就是改个这个吗，当时改的时候还在想着别的东西，改的时候并没有那么认真，结果导致有些错别字，最后被打回来返工，使得事情变得更糟。我不止一次犯过这种毛病了，犯错之后我也深深自责，为什么这么简单的事也能错。所以，一些小事也不要以为很简单，要认认真真去做，一些细节要把握好。

还有一些别的感悟，有的感悟更深刻了，不过之前都写过了，我就不再写了，大家如果感兴趣可以看看我去年的年度总结或者之前我的一些分享。好了，一些变化和反思我就暂时总结这么多了，不足的地方还有很多，也希望来年我能变得更好，无愧于自己的努力。

目标

照例，新的 2020 年，我给自己立一点 Flag 吧！明年再来继续总结和验收。

工作

工作继续好好努力，这是最重要的，现在我规划了一些新的尝试的方向，愿明年能够顺利实现和上线。

健身减肥

新的一年，每个工作周，健身至少 2 次。体重减重到 130 斤并一直维持，减掉赘肉和小肚子。

读书

给自己定一个读书计划，读完自己规划的一些书，每一本写出自己的感悟。

日/周总结

每日复盘和总结，写到日记本中，每周末对该周的内容进行复盘和总结。

爬虫书

《Python3网络爬虫开发实战（第二版）》书籍完成，书籍争取在上半年发售。另外还规划了配套视频，按照计划顺利出来。

公众号

公众号我就不按照粉丝量来设定目标了，如果「常读用户」机制一直存在的话，新的一年，我希望公众号常读用户数目可以达到 2w，平均阅读量达到 6000，即翻倍。另外公众号会尝试新的运营思路，我会写一些小的知识点发到公众号上，如果反响不错，新的一年会一直保持。

开源

继续维护自己的项目 Gerapy 和 ModelZoo。 Gerapy 把已经规划好的「可视化爬虫」、「智能解析」、「监控分析」等功能完善，Star 数破 3k。 ModelZoo 将其迁移到 PyTorch，并对接好当前规划的前沿主流模型，总 Star 数破 1k。

理财

学习一些理财知识，记录成自己的一套方法论。

感情

当然是和小马好好在一起！让我们的感情变得更好！

收入

这个自己给自己定了一个目标，这个具体数字我不说啦，朝着我的小米之家梦进发！

作者崔庆才发表于 2020-01-29 阅读次数：本文字数： 12k 阅读时长 ≈ 11 分钟

Python 新书发售限时折扣｜《Python3 反爬虫原理与绕过实战》

无论是在学习还是工作中，反爬虫技术是所有爬虫工程师都要面对的问题。常见的反爬虫原理和绕过技巧也是中高级爬虫工程师面试中关注的焦点，尤其是那些竞争激烈的大型互联网企业。作为一名开发者，了解反爬虫原理和绕过技巧有助于设计出更合理的反爬虫策略，这会使你在同行中脱颖而出，大放异彩。

那么问题来了

如何深入学习反爬虫原理并掌握绕过技巧呢？今天给大家推荐业内深受欢迎的反爬虫专题书籍《Python3 反爬虫原理与绕过实战》

这本书于 2020 年 1 月出版，目前在各大电商平台和书城均有售。本书定价 89，现在各大平台均有不同的限时折扣，喜欢的朋友赶紧下手哦！【京东自营】 https://item.jd.com/12794078.html 【天猫】https://detail.tmall.com/item.htm?spm=a230r.1.14.201.15272c73Ta0USk&id=611222843708&ns=1&abbucket=7 【当当】http://product.dangdang.com/28508464.html 书中描述了爬虫技术与反爬虫技术的对抗过程，并详细介绍了这其中的原理和具体的实现方法。本书从开发环境的配置到 Web 网站的构成和页面渲染，再到动态网页和静态网页对爬虫造成的影响。然后介绍了不同类型的反爬虫原理、具体实现和绕过方法。书中还讲解了常见验证码的实现过程，并使用深度学习技术完成了验证。最后介绍了常见的编码和加密原理、JavaScript 代码混淆知识、前端禁止事件以及与爬虫相关的法律知识和风险点。

精彩抢先看

在原理探究和分析方面，你会经历细致的分析过程，并通过示意图加深对知识的理解。例如第 6 章第 2 节 CSS 偏移反爬虫中描述元素位置和样式值关系的示意图：

例如第 6 章第 3 节 SVG 反爬虫中描述 SVG text 定位的示意图：

例如第 10 章第 1 节编码与加密中描述加密过程的示意图：

例如第 9 章第 3 节滑动验证码中描述移动距离的示意图：

网站的反爬虫措施是会更新的，为了保证读者的学习质量，本书在编写过程中开发了一套拥有 21 个示例的练习平台 Steamboat。

练习平台与书本紧密结合，不会出现学习过程中找不到与书本相同环境的情况，同时也能避免因练习而导致的侵权问题。除了配套的示例之外，书中还分析了众多互联网产品中使用到的反爬虫手段，这些产品包括大众点评、淘宝滑动验证码、猫眼电影、京东商城、去哪儿网、掘金社区和掌上英雄联盟等。你有想过将深度学习应用到爬虫中吗？

书中介绍了如何通过卷积神经网络来应对字符验证码，并给出了训练用的图片和识别率高达 99% 的训练代码。其中部分代码如下：

`folders \= PATH_TEST # 指定预测集路径``trains \= get_image_name(PATH_TRAIN)  # 获取训练样本所有图片的名称``pres \= get_image_name(folders)  # 获取预测集所有图片的名称``repeat \= len([p for p in pres if p in trains])  # 获取重复数量``start_verifies(folders)  # 开启预测``logging.info('预测前确认待预测图片与训练样本的重复情况，'``'待预测图片%s张，训练样本%s张，重复数量为%s张' % (len(pres), len(trains), repeat))`

当然，还有通过目标检测算法来应对点选验证码的精彩章节。

这本书是谁写的？

作者韦世东是一名资深爬虫工程师，2019 年华为云认证云享专家、掘金社区优秀作者、GitChat 认证作者、夜幕团队 NightTeam 的成员。

他曾在掘金社区发布过电子小册《Python 实战：用 Scrapyd 打造个人化的爬虫部署管理控制台[1]》。也在 GitChat 上发布过 MongoDB 的 10 万字教程《超高性价比的 MongoDB 零基础快速入门实战教程[2]》。还在华为总部进行过时长 2 小时的技术直播，直播主题为《Python 项目部署与调度核心逻辑[3]》。

这本书适合哪些朋友？

这本书的目标读者分为两个阵营：爬虫和反爬虫。爬虫工程师自然不用多说，大家最期待的正是对反爬虫技术的剖析和绕过实战。反爬虫的设计者和实施者遍布于各个岗位，它可以是前端工程师、后端工程师、移动端研发甚至是产品经理。他们能够从书中了解到爬虫工程师常用的技术手段和思路，知道哪些防护措施容易被突破、哪些措施的绕过难度会更高以及如何限制爬虫，从而设计出适合的反爬虫策略。

大厂高级研发怎么看？

以下是几位大厂工程师为本书编写的推荐语。

详细的章节目录

详细目录如下：

这简直就是手把手带你探寻反爬虫的世界！

References

[1] Python 实战：用 Scrapyd 打造个人化的爬虫部署管理控制台: https://juejin.im/book/5bb5d3fa6fb9a05d2a1d819a/section [2] 超高性价比的 MongoDB 零基础快速入门实战教程: https://gitbook.cn/gitchat/activity/5d52baeaac15fd68e9f78297 [3] Python 项目部署与调度核心逻辑: http://huaweicloud.bugu.mudu.tv/watch/vondje76

作者韦世东学算法和反爬虫发表于 2020-01-03 阅读次数：本文字数： 2.2k 阅读时长 ≈ 2 分钟

Python 揭秘去哪儿网在用的 CSS 偏移反爬虫手段！

内容选自即将出版的《Python3 反爬虫原理与绕过实战》，本次公开书稿范围为第 6 章——文本混淆反爬虫。本篇为第 6 章中的第 2 小节，第 3、4 小节已发，直达链接：

其余小节将逐步放送。

CSS 偏移反爬虫

CSS 偏移反爬虫指的是利用 CSS 样式将乱序的文字排版为人类正常阅读顺序的行为。这个概念不是很好理解，我们可以通过对比两段文字来加深对这个概念的理解。

HTML 文本中的文字：我的学号是 1308205，我在北京大学读书。
浏览器显示的文字：我的学号是 1380205，我在北京大学读书。

爬虫提取到的学号是 1308205，但用户在浏览器中看到的却是 1380205。如果不细心观察，爬虫工程师很容易被爬取结果糊弄。这种混淆方法和图片伪装一样，是不会影响用户阅读的。让人好奇的是，浏览器如何将 HTML 文本中的数字按照开发者的意愿排序或放置呢？这种放置规则是如何运作的呢？我们可以通过一个具体的例子来了解 CSS 偏移反爬虫的应用和绕过方法。

6.2.1 CSS 偏移反爬虫绕过实战

示例 5：CSS 偏移反爬虫示例。网址：http://www.porters.vip/confusion/flight.html。任务：爬取航班查询和机票销售网站页面中的航站名称、所属航空公司和票价，页面内容如图 6-4 所示。图 6-4 示例 5 页面在编写 Python 代码之前，我们需要确定目标数据的元素定位。航空公司名称元素定位如图 6-5 所示。图 6-5 航空公司名称元素定位结果航空公司名称包裹在没有属性的 span 标签中，但该 span 标签包裹在 class 属性为 air g-tips 的 div 标签中。接下来我们看一下航站名称的元素定位，定位结果如图 6-6 所示。图 6-6 航站名称元素定位结果航站名称包裹在没有属性的 h2 标签中，h2 标签包裹在 class 为 sep-lf 的 div 标签中。我们再看一下票价的元素定位，定位结果如图 6-7 所示。图 6-7 票价的元素定位结果页面中显示的票价为 467，但是在网页中却有两组不同的数字，其中一组是[7, 7, 7]，而另一组是 [6, 4]，这看起来就有点奇怪了。难道是网页显示有问题？按照正常排序来说，这架航班的票价应该是 77 764 才对。我们可以查看第二架航班信息的价格，思考是网页显示问题还是做了什么反爬虫措施。第二架航班的票价元素定位结果如图 6-8 所示。图 6-8 第二架航班的票价元素定位结果结果与第一架航班的票价显示有同样的问题：网页显示内容和 HTML 代码中的内容不一致。我们分析一下 HTML 代码，看一看是否能找到什么线索。第一架航班票价的 HTML 代码为：

<span class="prc_wp" style="width:48px"> 
    <em class="rel"> 
        <b style="width:48px;left:-48px"> 
            <i style="width: 16px;">7</i> 
            <i style="width: 16px;">7</i> 
            <i style="width: 16px;">7</i> 
        </b> 
        <b style="width: 16px;left:-32px">6</b> 
        <b style="width: 16px;left:-48px">4</b> 
    </em> 
</span>

代码中有 3 对 b 标签，第 1 对 b 标签中包含 3 对 i 标签，i 标签中的数字都是 7，也就是说第 1 对 b 标签的显示结果应该是 777。而第 2 对 b 标签中的数字是 6，第 3 对 b 标签中的数字是 4。这些数字与页面所显示票价 467 的关系是什么呢？这一步找到的标签和数字有可能是数据源，但是数字的组合有很多种可能，如图 6-9 所示。图 6-9 数字组合推测 5 个数字的组合结果太多了，我们必须找出其中的规律，这样就能知道网页为什么显示 467 而不是 764 或者 776 。在仔细查看过后，发现每个带有数字的标签都设定了样式。第 1 对 b 标签的样式为：

1	width:48px;left:-48px

第 2 对 b 标签的样式为：

1	width: 16px;left:-32px

第 3 对 b 标签的样式为：

1	width: 16px;left:-48px

i 标签对的样式是相同的，都是：

1	width: 16px;

另外，还注意到最外层的 span 标签对的样式为：

1	width:48px

如果按照 CSS 样式这条线索来分析的话，第 1 对 b 标签中的 3 对 i 标签刚好占满 span 标签对的位置，其位置如图 6-10 所示。图 6-10 span 标签对和 i 标签对位置图此时网页中显示的价格应该是 777，但是由于第 2 和第 3 对 b 标签中有值，所以我们还需要计算它们的位置。此时标签位置的变化如图 6-11 所示。图 6-11 标签位置变化右侧是标签位置变化后的结果，由于第 2 对 b 标签的位置样式是 left:-32px，所以第 2 对 b 标签中的值 6 就会覆盖原来第 1 对 b 标签中的中的第 2 个数字 7，此时页面应该显示的数字是 767。按此规律推算，第 3 对 b 标签的位置样式是 left:-48px，这个标签的值会覆盖第 1 对 b 标签中的第 1 个数字 7，覆盖结果如图 6-12 所示，最后显示的票价是 467。图 6-12 覆盖结果根据结果来看这种算法是合理的，不过我们还需要对其进行验证，现在将第二架航班的 HTML 值和 CSS 样式按照这个规律进行推算。最后推算得到的结果与页面显示结果相同，说明这个位置偏移的计算方法是正确的，这样我们就可以编写 Python 代码获取网页中的票价信息了。因为 b 标签包裹在 class 属性为 rel 的 em 标签下，所以我们要定位所有的 em 标签。对应的 Python 代码如下：

import requests 
import re 
from parsel import Selector 
url = 'http://www.porters.vip/confusion/flight.html' 
resp = requests.get(url) 
sel = Selector(resp.text) 
em = sel.css('em.rel').extract()

接着定位所有的 b 标签。由于 b 标签中还有 i 标签，而且 i 标签的值是基准数据，所以可以直接提取。对应的 Python 代码如下：

for element in em: 
    element = Selector(element) 
    # 定位所有的<b>标签
    element_b = element.css('b').extract() 
    b1 = Selector(element_b.pop(0)) 
    # 获取第 1 对<b>标签中的值(列表) 
    base_price = b1.css('i::text').extract()

接下来要提取其他 b 标签的偏移量和数字。对应的 Python 代码如下：

alternate_price = [] 
for eb in element_b: 
   eb = Selector(eb) 
   # 提取<b>标签的 style 属性值
   style = eb.css('b::attr("style")').get() 
   # 获得具体的位置
   position = ''.join(re.findall('left:(.*)px', style)) 
   # 获得该标签下的数字
   value = eb.css('b::text').get() 
   # 将<b>标签的位置信息和数字以字典的格式添加到替补票价列表中
   alternate_price.append({'position': position, 'value': value})

然后根据偏移量决定基准数据列表的覆盖元素，实际上是完成图 6-11 中的操作。

for al in alternate_price: 
   position = int(al.get('position')) 
   value = al.get('value') 
   # 判断位置的数值是否正整数
   plus = True if position >= 0 else False 
   # 计算下标，以 16px 为基准
   index = int(position / 16) 
   # 替换第一对<b>标签值列表中的元素，也就是完成值覆盖操作
   base_price[index] = value 
print(base_price)

最后将数据列表打印出来，得到的输出结果为：

1 2	['4', '6', '7'] ['8', '7', '0', '5']

令人感到奇怪的是，输出结果中第一组票价数字与页面中显示的相同，但第二组却不同。这是因为第二架航班的票价基准数据有 4 个值。航班票价对应的 HTML 代码如下：

<em class="rel"> 
   <b style="width:64px;left:-64px"> 
       <i style="width: 16px;">8</i> 
       <i style="width: 16px;">3</i> 
       <i style="width: 16px;">9</i> 
       <i style="width: 16px;">5</i>
   </b> 
   <b style="width: 16px;left:-32px">0</b> 
   <b style="width: 16px;left:-48px">7</b> 
   <b style="width: 16px;left:-16px">5</b> 
</em>

覆盖操作是根据由偏移量计算得出的下标进行的，实际上就是列表元素的替换。当基准数据列表的元素数量超过包裹着 i 标签的 b 标签宽度时，我们就对列表进行切片，否则按照原来的替换规则进行。因此，需要对代码做一些调整。调整内容如下：

# 减号代表删除此行代码，加号代表新增代码
+ import re 
- base_price = b1.css('i::text').extract() 
+ b1_style = b1.css('b::attr("style")').get() 
# 获得具体的位置
+ b1_width = ''.join(re.findall('width:(.*)px;', b1_style)) 
+ number = int(int(b1_width) / 16) 
# 获取第 1 对 <b> 标签中的值(列表) 
+ base_price = b1.css('i::text').extract()[:number]

如果列表中元素的数量超过标签宽度，那么后面的元素是不会显示的。比如 width:32px，每个标签占位宽度 16 px，那么即使 b 标签下有 5 个 i 标签（base_price=[1, 2 ,3 ,4 , 5]），在页面中也仅显示前面的两个数字。代码调整完毕后，再次运行代码。运行结果为：

1 2	['4', '6', '7'] ['8', '7', '0', '5']

第二架航班的票价结果仍然跟页面显示的内容不同，但根据 CSS 宽度规则，我们之前分析的逻辑是正确的。为什么结果还是跟页面显示的不一样呢？实际上并不是我们的逻辑和代码有错，而是页面显示错误。要注意的是，页面数据显示错误是常发生的事，我们只需要按照正确的逻辑编写代码即可。

6.2.2 去哪儿网反爬虫案例

去哪儿网是中国领先的在线旅游平台，覆盖全球 68 万余条航线，并与国内的旅游景点和航空公司进行了深度的合作。去哪儿网也有用到类似的反爬虫手段，我们一起来了解一下。打开浏览器并访问 https://dwz.cn/d05zNKyq，页面内容如图 6-13 所示。图 6-13 去哪儿网航班信息航班票价对应的 HTML 代码如图 6-14 所示。图 6-14 去哪儿网航班票价 HTML 代码去哪儿网航班票价所对应的 HTML 代码结构和 CSS 与我们在示例 5 中见到的类似。我们可以大胆猜测，去哪儿网航班票价的显示规律与示例 5 中所用的方法也是类似的，感兴趣的同学可以按照 6.2.1 节的思路进行票价推算。去哪儿网航班票价中第 1 对 b 标签下的 i 标签数量与 width 是相匹配的，并未出现显示错误的问题。

6.2.3 小结

CSS 样式可以改变页面显示，但这种“改变”仅存在于浏览器（能够解释 CSS 的渲染工具）中，即使爬虫工程师借助渲染工具，也无法获得“见到”的内容。

新书福利

真是翘首以盼！《Python3 反爬虫原理与绕过实战》一书终于要跟大家见面了！为了感谢大家对韦世东和本书的期待与支持，在新书发布时会举办多场送书活动和限时折扣活动。想要与作者韦世东交流或者参加新书发布活动的朋友可以扫描二维码进群与我互动哦！

转载说明

本篇内容摘自出版图书《Python3 反爬虫原理与绕过实战》，欢迎各位好友与同行转载！记得带上相关的版权信息哦😊。

作者韦世东学算法和反爬虫发表于 2019-12-31 阅读次数：本文字数： 5.3k 阅读时长 ≈ 5 分钟

Python 大厂在用的反爬虫手段，破了它！

内容选自即将出版的《Python3 反爬虫原理与绕过实战》，本次公开书稿范围为第 6 章——文本混淆反爬虫。本篇为第 6 章中的第 3 小节，第 4 小节字体反爬虫已发布，其余小节将逐步放送。

新书福利

真是翘首以盼！《Python3 反爬虫原理与绕过实战》一书终于要跟大家见面了！为了感谢大家对韦世东和本书的期待与支持，在新书发布时会举办多场送书活动和限时折扣活动。

想要与作者韦世东交流或者参加新书发布活动的朋友可以扫描二维码进群与我互动哦！

SVG 映射反爬虫

SVG 是用于描述二维矢量图形的一种图形格式。它基于 XML 描述图形，对图形进行放大或缩小操作都不会影响图形质量。矢量图形的这个特点使得它被广泛应用在 Web 网站中。接下来我们要了解的反爬虫手段正是利用 SVG 实现的，这种反爬虫手段用矢量图形代替具体的文字，不会影响用户正常阅读，但爬虫程序却无法像读取文字那样获得 SVG 图形中的内容。由于 SVG 中的图形代表的也是一个个文字，所以在使用时必须在后端或前端将真实的文字与对应的 SVG 图形进行映射和替换，这种反爬虫手段被称为 SVG 映射反爬虫。

6.3.1 SVG 映射反爬虫绕过实战

示例 6：SVG 映射反爬虫示例。网址：http://www.porters.vip/confusion/food.html。任务：爬取美食商家评价网站页面中的商家联系电话、店铺地址和评分数据，页面内容如图 6-15 所示。图 6-15 示例 6 页面在编写 Python 代码之前，我们需要确定目标数据的元素定位。在定位过程中，发现一个与以往不同的现象：有些数字在 HTML 代码中并不存在。例如口味的评分数据，其元素定位如图 6-16 所示。图 6-16 评分数据中口味分数元素定位根据页面显示内容，HTML 代码中应该是 8.7 才对，但实际上我们看到的却是：

1	<span class="item">口味:<d class="vhkjj4"></d>.7</span>

HTML 代码中有数字 7 和小数点，但没有 8 这个数字，似乎数字 8 的位置被 d 标签占据。而商家电话号码处的显示就更奇怪了，一个数字都没有。商家电话对应的 HTML 代码如下：

<div class="col more"> 
        电话：
   <d class="vhkbvu"></d> 
   <d class="vhk08k"></d> 
   <d class="vhk08k"></d> 
   <d class="">-</d> 
   <d class="vhk84t"></d> 
   <d class="vhk6zl"></d> 
   <d class="vhkqsc"></d> 
   <d class="vhkqsc"></d> 
   <d class="vhk6zl"></d> 
</div>

包含很多的 d 标签，难道它使用 d 标签进行占位，然后用元素进行覆盖吗？我们可以将 d 标签的数量和数字的数量进行对比，发现它们的数量是相同的，也就是说一对 d 标签代表一个数字。每一对 d 标签都有 class 属性，有些 class 属性值是相同的，有些则不同。我们再将 class 属性值与数字进行对比，看一看能否找到规律，如图 6-17 所示。图 6-17 class 属性值和数字的对比从图 6-17 中可以看出，class 属性值和数字是一一对应的，如属性值 vhk08k 与数字 0 对应。根据这个线索，我们可以猜测每个数字都与一个属性值对应，对应关系如图 6-18 所示。图 6-18 数字与属性值对应关系浏览器在渲染页面的时候就会按照这个对应关系进行映射，所以页面中显示的是数字，而我们在 HTML 代码中看到的则是这些 class 属性值。浏览器在渲染时将 HTML 中的 d 标签与数字按照此关系进行映射，并将映射结果呈现在页面中。映射逻辑如图 6-19 所示。图 6-19 映射逻辑我们的爬虫代码可以按照同样的逻辑实现映射功能，在解析 HTML 代码时将 d 标签的 class 属性值取出来，然后进行映射即可得到页面中显示的数字。如何在爬虫代码中实现映射关系呢？实际上网页中使用的是“属性名数字”这种结构，Python 中内置的字典正好可以满足我们的需求。我们可以用 Python 代码测试一下，代码如下：

# 定义映射关系
mappings = {'vhk08k': 0, 'vhk6zl': 1, 'vhk9or': 2, 
   'vhkfln': 3, 'vhkbvu': 4, 'vhk84t': 5, 
   'vhkvxd': 6, 'vhkqsc': 7, 'vhkjj4': 8, 
   'vhk0f1': 9} 
# HTML 中得到的属性值
html_d_class = 'vhkvxd' 
# 将映射后的结果打印输出
print(mappings.get(html_d_class))

这段代码的逻辑是：首先定义属性值与数字的映射关系，然后假设一个 HTML 中 d 标签的属性值，接着将这个属性值的映射结果打印出来。代码运行后得到的结果为：

运行结果说明映射这种方法是可行的。接着我们试一试将商家的联系电话映射出来：

# 定义映射关系
mappings = {'vhk08k': 0, 'vhk6zl': 1, 'vhk9or': 2, 
            'vhkfln': 3, 'vhkbvu': 4, 'vhk84t': 5, 
            'vhkvxd': 6, 'vhkqsc': 7, 'vhkjj4': 8, 
            'vhk0f1': 9} 
# 商家联系电话 class 属性
html_d_class = ['vhkbvu', 'vhk08k', 'vhk08k', 
                '', 'vhk84t', 'vhk6zl', 
                'vhkqsc', 'vhkqsc', 'vhk6zl'] 

phone = [mappings.get(i) for i in html_d_class] 
# 将映射后的结果打印输出
print(phone)

运行结果为：

1	[4, 0, 0, None, 5, 1, 7, 7, 1]

我们使用映射的方法得到了商家联系电话，说明 SVG 映射反爬虫已经被我们绕过了。

6.3.2 大众点评反爬虫案例

这种映射手段不仅仅出现在本书的示例中，在大型网站中也有应用。大众点评是中国领先的本地生活信息及交易平台，也是全球最早建立的独立第三方消费点评网站。大众点评不仅为用户提供商户信息、消费点评及消费优惠等信息服务，同时提供团购、餐厅预订、外卖和电子会员卡等 O2O（Online To Offline）交易服务。大众点评网站也使用了映射型反爬虫手段，打开浏览器并访问 https://www.dianping.com/shop/14741057，页面如图 6-20 所示。图 6-20 大众点评商家信息页大众点评的商家信息页主要用于展示消费者对商家的各项评分、商家电话、店铺地址和推荐菜品等。我们可以看一看商家电话或评分的 HTML 代码，如图 6-21 所示。图 6-21 商家电话 HTML 代码大众点评中的商家号码并不是全部使用 d 标签代替，其中有部分使用了数字。但是仔细观察一下就可以发现商家号码的数量等于 d 标签数量加上数字的数量，说明 d 标签的 class 属性值与数字也有可能是一一对应的映射关系。感兴趣的同学可以使用示例 6 中的方法，尝试映射大众点评案例中的数字。如果这种手段的绕过方法这么简单的话，那么它早就被淘汰了，为什么连大众点评这样的大型网站都会使用呢？我们继续往下看，大众点评的商家营业时间部分的 HTML 代码如图 6-22 所示。图 6-22 大众点评商家营业时间除了刚才的数字映射之外，大众点评还对中文进行了映射。此时如果按照示例 6 中人为地将 class 值和对应的文字进行映射的话，就非常麻烦了。试想一下，如果网页中所有的文字都使用这种映射反爬虫的手段，那么爬虫工程师要如何应对呢？对所有用到的文字进行映射吗？这不可能做到，其中要完成映射的包括 10 个数字、26 个英文字母和几千个常用汉字。而且目标网站一旦更改文字的对应关系，那么爬虫工程师就需要重新映射所有文字。面对这样的问题，我们必须找到文字映射规律，并且能够使用 Python 语言实现映射算法。如此一来，无论目标网站文字映射的对应关系如何变化，我们都能够使用这套映射算法得到正确的结果。这种映射关系在网页中是如何实现的呢？是使用 JavaScript 在页面中定义数组吗？还是异步请求API 拿到 JSON 数据？这都有可能，接下来我们就去寻找答案。

6.3.3 SVG 反爬虫原理

映射关系不可能凭空出现，一定使用了某种技术特性。HTML 中与标签 class 属性相关的只有 JavaScript 和 CSS。根据这个线索，我们需要继续对示例 6 进行分析。案例中商家电话的 HTML 代码为：

<div class="col more">电话：
   <d class="vhkbvu"></d> 
   <d class="vhk08k"></d> 
   <d class="vhk08k"></d> 
   <d class="">-</d> 
   <d class="vhk84t"></d> 
   <d class="vhk6zl"></d> 
   <d class="vhkqsc"></d> 
   <d class="vhkqsc"></d> 
   <d class="vhk6zl"></d> 
</div>

我们可以随意选择一对 d 标签，然后观察它对应的 CSS 样式有没有可以深入分析的线索，如果没有线索再看 JavaScript。 d 标签的 CSS 样式如下：

d[class^="vhk"] { 
   width: 14px; 
   height: 30px; 
   margin-top: -9px; 
   background-image: url(../font/food.svg); 
   background-repeat: no-repeat; 
   display: inline-block; 
   vertical-align: middle; 
   margin-left: -6px; 
} 
.vhkqsc { 
    background: -288.0px -141.0px; 
}

d 标签样式看上去没有什么特别之处，只是设置了 background 属性的坐标值。但是上方 d 标签的公共样式中设置了背景图片，我们可以复制背景图片的地址，在浏览器的新标签页中打开，d 标签背景图如图 6-23 所示。图 6-23 标签背景图 d 标签的背景图中全部都是数字，这些无序的数字共有 4 行。但这好像不是一张大图片，我们查看该图片页面的源代码，内容如图 6-24 所示。图 6-24 图片页面源代码源代码中前两行表明这是一个 SVG 文件，该文件中使用 text 标签定义文本， style 标签用于设置文本样式， text 标签定义的文本正是图片页面显示的数字。难道这些无序的数字就是我们在页面中看到的电话号码和评分数字？除了 class 属性值为 vhkbvu 的 d 标签，其他标签也使用了这个的 CSS 样式，但每对 d 标签的坐标定位都不同。它们的坐标定位如下：

.vhkbvu { 
    background: -386px -97px; 
} 
.vhk08k { 
    background: -274px -141px; 
} 
.vhk84t {
    background: -176px -141px; 
}

坐标是定位数字的关键，要想知道坐标的计算方法，必须了解一些关于 SVG 的知识。在本节开始的时候，我们简单地了解了 SVG 的概念，知道 SVG 是基于 XML 的。实际上它是用文本格式的描述性语言来描述图像内容的，因此 SVG 是一种与图像分辨率无关的矢量图形格式。打开文本编辑器，并在新建的文件中写入以下内容：

<?xml version="1.0" encoding="UTF-8" standalone="no"?> 
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/ 
 DTD/svg11.dtd"> 
<svg xmlns="http://www.w3.org/2000/svg" version="1.1" xmlns:xlink="http://www.w3.org/ 
 1999/xlink" width="250px" height="250.0px"> 
    <text x='10' y='30'>hello,world</text> 
</svg>

将该文件保存为 test.svg，然后使用浏览器打开 test.svg 文件，显示内容如图 6-25 所示。图 6-25 test.svg 显示内容代码前 3 行声明文件类型，第 4 行~第 5 行定义了 SVG 内容块和画布宽高，第 6 行使用 text 标签定义了一段文本并指定了文本的坐标。这段文本就是我们在浏览器中看到的内容，而代码中的 x 坐标和 y 坐标则用于确定该文本在画布中的位置，坐标规则如下。

以页面的左上角为零坐标点，即坐标值为 (0, 0)。
坐标以像素为单位。
x 轴的正方向为从左到右，y 轴的正方向是从上到下。
n 个字符可以有 n 个位置参数。

如果字符数量大于位置参数数量，那么没有位置参数的字符将以最后一个位置参数为零坐标点，并按原文顺序排列。看上去并不是很好理解，我们可以通过修改代码来理解坐标轴的定义。首先是 x 轴， text 标签中的 x 代表列表字符在页面中的 x 轴位置，test.svg 中的 x 值为 10，现在我们将其设为 0 ，保存后刷新网页，页面内容如图 6-26 所示。图 6-26 x 为 0 时的 test.svg 显示内容 x 的值为 0 时，文本紧贴浏览器左侧。而 x 的值为 10 时，文本距离浏览器左侧有一定的距离，这说明 x 的值能够决定文字所在的位置。现在我们将代码中 x 对应的值改为“10 50 30 40 20 60”（注意这里特意将第 2个数字 20与第 5个数字互换了位置），这样做是为了设定前 6个字符的坐标位置。此时，第 1 个字符的位置参数为 10，第 2 个字符的位置参数为 50，第 3 个字符的位置参数为 30，以此类推，页面中正常显示的文字顺序应该是：

1	holle,world

但是由于我们调换了第 2 个字符和第 5 个字符的位置参数，即字母 e 和字母 o 的位置互换，如图 6-27 所示。图 6-27 设定多个 x 值的 svg 图 6-27 中文字顺序与我们猜测的顺序是一样的，这说明 SVG 中每个字符都可以有自己的 x 轴坐标值。y 与 x 同理，每个字符都可以有自己的 y 轴坐标值。虽然我们只设定了 6 个位置参数， svg 中的字符却有 11 个，但没有设定位置参数的字符依然能够按照原文顺序排序。在了解 SVG 基本知识之后，我们回头看一下案例中所使用的 SVG 文件中坐标参数的设定，图 6-23 中的字符与图 6-24 图片页源代码中的字符一一对应，且每个字符都设定了 x 轴的位置参数，而 y 轴则只有 1 个值。在了解位置参数之后，我们还需要弄清楚字符定位的问题。浏览器根据 CSS 样式中设定的坐标和元素宽高来确定 SVG 中对应数字。x 轴的正方向为从左到右，y 轴的正方向是从上到下，如图 6-28 所示。图 6-28 SVG x 轴和 y 轴与位置参数的关系而 CSS 样式中的 x 轴与 y 轴是相反的，也就是说 CSS 样式中 x 轴是负数向右的，y 轴是负数向下的，如图 6-29 所示。图 6-29 CSS x 轴和 y 轴与位置参数的关系所以当我们需要在 CSS 中定位 SVG 中的字符位置时，需要用负数表示。我们可以通过一个例子来理解它们的关系，现在需要在 CSS 中定位图 6-30 中第 1 行的第 1 个字符的中心点。图 6-30 SVG 假设字符大小为 14 px，那么 SVG 的计算规则如下。

字符在x轴中心点的计算规则为：字符大小除以2，再加字符的x轴起点位置参数，即14÷2+0 等于 7。
字符在 y 轴中心点的计算规则为：y 轴高度减字符 y 轴起点减字符大小，其值除以 2 后加上字符 y 轴起点位置参数，最后再加上字符大小数值的一半，即(38−0−14)÷2+0+7 等于 19。

最后得到 SVG 的坐标为：

1	x='7' y='19'

CSS 样式的 x 轴和 y 轴与 SVG 是相反的，所以 CSS 样式中对该字符的定位为：

1	\-7px -19px

这样就能够定位到指定字符的中心点了。但是如果要在 HTML 页面中完整显示该字符，那么还需要为 HTML 中对应的标签设置宽高样式，如：

1 2	width: 14px; height: 30px;

在了解了 SVG 与 CSS 样式的关联关系后，我们就能够根据 CSS 样式映射出 SVG 中对应的字符。在实际场景中，我们需要让程序能够自动处理 CSS 样式和 SVG 的映射关系，而不是人为地完成这些工作。以示例 6 中的 SVG 和 CSS 样式为例，假如我们需要用 Python 代码实现自动映射功能，首先我们就需要拿到这两个文件的 URL，如：

1 2	url_css = 'http://www.porters.vip/confusion/css/food.css' url_svg = 'http://www.porters.vip/confusion/font/food.svg'

还有需要映射的 HTML 标签的 class 属性值，如：

1	css_class_name = 'vhkbvu'

接下来使用 Requests 库向 URL 发出请求，拿到文本内容。对应代码如下：

1
2
3

import requests 
css_resp = requests.get(url_css).text 
svg_resp = requests.get(url_svg).text

提取 CSS 样式文件中标签属性对应的坐标值，这里使用正则进行匹配即可。对应代码如下：

import re 
pile = '.%s{background:-(d+)px-(d+)px;}' % css_class_name 
pattern = re.compile(pile) 
css = css_resp.replace('n', '').replace(' ', '') 
coord = pattern.findall(css) 
if coord: 
 x, y = coord[0] 
 x, y = int(x), int(y)

此时得到的坐标值是正数，可以直接用于 SVG 字符定位。定位前我们要先拿到 SVG 中所有 text 标签的 Element 对象：

1
2
3

from parsel import Selector 
svg_data = Selector(svg_resp) 
texts = svg_data.xpath('//text')

然后获取所有 text 标签中的 y 值，接着我们将上一步得到的 Element 对象进行循环取值即可：

1	axis_y = [i.attrib.get('y') for i in texts if y <= int(i.attrib.get('y'))][0]

得到 y 值后就可以开始字符定位了。要注意的是，SVG 中 text 标签的 y 值与 CSS 样式中得到的 y 值并不需要完全相等，因为样式可以随意调整，比如 CSS 样式中-90 和-92 对于 SVG 的定位来说并没有什么差别，所以我们只需要知道具体是哪一个 text 即可。那么如何确定是哪一个 text呢？我们可以用排除法来确定，假如当前 CSS 样式中的 y 值是-97，那么在 SVG 中 text 的 y 值就不可能小于 97，我们只需要取到比 97 大且最相近的 text 标签 y 值即可。比如当前 SVG 所有 text 标签的 y 值为：

1	[38, 83, 120, 164]

那么大于 97 且最相近的是 120。将这个逻辑转化为代码：

1	axis_y = [i.attrib.get('y') for i in texts if y <= int(i.attrib.get('y'))][0]

得到 y 值后就可以确定具体是哪个 text 标签了。对应代码如下：

1	svg_text = svg_data.xpath('//text[@y="%s"]/text()' % axis_y).extract_first()

接下来需要确认 SVG 中的文字大小，也就是需要找到 font-size 属性的值。对应代码如下：

1	font_size = re.search('font-size:(d+)px', svg_resp).group(1)

得到 font-size 的值后，我们就可以定位具体的字符了。x 轴有多少个字符呢？刚才我们拿到的 svg_text 就是指定的 text 标签中的字符：

1	'671260781104096663000892328440489239185923'

我们需要计算字符串长度吗？并不用，我们知道，每个字符大小为 14 px，只需要将 CSS 样式中的 x 值除以字符大小，得到的就是该字符在字符串中的位置。除法得到的结果有可能是整数也有可能是非整数，当结果是整数是说明定位完全准确，我们利用切片特性就可以拿到字符。如果结果是非整数，就说明定位不完全准确，由于字符不可能出现一半，所以我们利用地板除（编程语言中常见的向下取整除法，返回商的整数部分。）就可以拿到整数：

1	position = x // int(font_size) # 结果为 27

也就是说 CSS 样式 vhkbvu 映射的是 SVG 中第 4 行文本的第 27 个位置的值。映射结果如图 6-31 所示。图 6-31 映射结果然后再利用切片特性拿到字符。对应代码如下：

1 2	number = svg_text[position] print(number)

代码运行结果为 4。我们还可以尝试其他的 class 属性值，最后得到的结果与页面显示的字符都是相同的，说明这种映射算法是正确的。至此，我们已经完成了对映射型反爬虫的绕过。

6.3.4 小结

与 6.1 节和 6.2 节相同，本节示例所用的反爬虫手段，即使借助渲染工具也无法获得“见到”的内容。SVG 映射反爬虫利用了浏览器与编程语言在渲染方面的差异，以及 SVG 与 CSS 定位这样的前端知识。如果爬虫工程师不熟悉渲染原理和前端知识，那么这种反爬虫手段就会带来很大的困扰。

转载说明

本篇内容摘自出版图书《Python3 反爬虫原理与绕过实战》，欢迎各位好友与同行转载！记得带上相关的版权信息哦😊。

作者韦世东学算法和反爬虫发表于 2019-12-27 阅读次数：本文字数： 9.1k 阅读时长 ≈ 8 分钟

Python 谷歌验证码 ReCaptcha 破解教程，简单方便从零开始。

很久没有做爬虫破解类相关的分享了，之前交流群里有朋友提问谷歌系的 reCAPTCHA V2 验证码怎么破，因为工作的原因我是很久之后才看到的，也不知道那位朋友后来成功了没有。所以今天就来跟大家分享一下 reCAPTCHA V2 的破解。（小马补充：想加交流群的朋友，进入公众号下方，点击技术交流，有读者群和交流群，点击后都会弹出崔老师的二维码，扫微信二维码拉群～）如果大家访问国外的一些网站的话，想必肯定见过这样的一个验证码，它上面写着「I’m not a robot」，意为「我不是机器人」，验证码长这个样子：这时候，只要我们点击最前面的复选框，验证码算法会首先利用其「风险分析引擎」做一次安全检测，如果直接检验通过的话，我们会直接得到如下的结果：如果算法检测到当前系统存在风险，比如可能是陌生的网络环境，可能是模拟程序，会需要做二次校验。它会进一步弹出类似如下的内容：比如上面这张图，验证码页面会出现九张图片，同时最上方出现文字「树木」，我们需要点选下方九张图中出现「树木」的图片，点选完成之后，可能还会出现几张新的图片，我们需要再次完成点选，最后点击「验证」按钮即可完成验证。或者我们可以点击下方的「耳机」图标，这时候会切换到听写模式，验证码会变成这样：这时候我们如果能填写对验证码读的音频内容，同样可以通过验证。这两种方式都可以通过验证，验证完成之后，我们才能完成表单的提交，比如完成登录、注册等操作。这种验证码叫什么名字？这个验证码就是 Google 的 reCAPTCHA V2 验证码，它就属于行为验证码的一种，这些行为包括点选复选框、选择对应图片、语音听写等内容，只有将这些行为校验通过，此验证码才能通过验证。相比于一般的图形验证码来说，此种验证码交互体验更好、安全性会更高、破解难度更大。许多国外的网站都采用了此种验证码，由于某些原因，在国内其实无法直接使用，但只需要将验证码的域名更换为 recaptcha.net 同样是可以使用的，所以有时候我们在国内某些站点同样能看到它的身影。其实上文所介绍的验证码仅仅是 reCAPTCHA 验证码的一种形式，是 V2 的显式版本，另外其 V2 版本还有隐式版本，隐式版本在校验的时候不会再显式地出现验证页面，它是通过 JavaScript 将验证码和提交按钮进行绑定，在提交表单的时候会自动完成校验。除了 V2 版本，Google 又推出了最新的 V3 版本，reCAPTCHA V3 验证码会为根据用户的行为来计算一个分数，这个分数代表了用户可能为机器人的概率，最后通过概率来判断校验是否可以通过。其安全性更高、体验更好。具体的内容大家可以参考 reCAPTCHA 的官方介绍：https://developers.google.com/recaptcha。那么在做爬虫的时候，如果我们遇到了这样的验证码？该怎么办呢？不要着急，这篇文章就来介绍一个解决方案。

机器学习 vs 识别服务

之前我在写上一篇如何识别滑动验证码问题的时候，当时朋友留言问我能不能做一个机器学习的，我回复了，我说当然没问题，你等着，我这周就做。我那周从周一做到周五，我记得用的应该是 yolo，反复修改，小马还经常过来催崔稿，耗费良久，然后就在那周周五晚上的 23:59 分，我灵机一动，终于明白了。去他的机器学习，有服务不好吗？ reCAPTCHA 本身比极验还要复杂，国内网站我暂时没看到破解的，然后这次是用的俄罗斯的一个服务商 2Captcha 提供的图像识别和一系列行为验证码的识别服务。破解验证码背后有图像识别算法和大量人力的支撑，如果我们仅仅是简单的图形验证码，其可以通过一些图像识别算法将内容识别出来转化为文本内容。如果是较为复杂的图形验证码或者像 reCAPTCHA 类似的行为验证码，其背后会有人来对验证码进行模拟，然后返回其验证成功后的秘钥，我们利用其结果便可以完成一些验证码的绕过。当然这种网站肯定是要收费的，按照 1000 次识别为单位，其花费的费用为 0.5 美刀到 2.99 美刀不等，比如非常简单的图形验证码可能就是 0.5 美刀，这种验证码对于其人力和算力资源消耗都是相对较小的，对于复杂的 reCAPTCHA 验证码，就要花 2.99 美刀了，因为识别这么一个验证码并不容易，其背后的人可能需要看好多图，点选好多次才能完成一次成功的验证。目前我用的服务的收费标准是这样的：具体的内容或者更新大家可以到其官方说明 https://2captcha.com/2captcha-api#rates 去查看。后面我用他的服务来破解 reCAPTCHA，当然类比其他服务也是可以的，过程大概都是这样。

准备工作

要使用 2Captcha，第一步当然是注册一下它的账号了，注册完成之后我们可以进入到 2Captcha 的控制台，类似于这样子：在这里我们可以看到账户余额、API KEY、FAQ 等配置。这里最重要的就是 API KEY 了，它是我们用来使用 2Captcha 的凭证，我们将它复制下来，后面我们会在代码中使用它。好，准备工作完成了，我们接下来进入正式内容。

2Captcha for reCAPTCHA V2

在上文我们已经介绍过 reCAPTCHA V2 的使用和交互流程了，下面我们来介绍下其识别和绕过的基本流程。在这里我们就拿官方的 reCAPTCHA V2 的示例网站来做演示吧，其网址为：https://www.google.com/recaptcha/api2/demo，打开之后界面如下所示：在这里可以看到有一个表单，上面有一些输入框，下方是 reCAPTCHA V2 验证码。要识别这个验证码，第一步便是找到这个验证码 sitekey，这个是验证码的唯一标识。我们打开浏览器的开发者工具，查看其页面源码，首先找到 reCAPTCHA 的源代码，如下图所示：可以看到 reCAPTCHA 是对应了一个 iframe，我们看到的 reCAPTCHA 内容都是在 iframe 里面呈现出来的。这里我们可以观察到在 reCAPTCHA 的源码的最外层的 div 上面有一个字段，叫做 data-sitekey，这就是刚才我们所说的 sitekey，它是验证码的唯一标识，比如这里我先将这个 sitekey 保存下来，这里其值为：

1	6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-

下一步，我们就需要将这个 sitekey 和当前页面的 URL 告诉 2Captcha，让 2Captcha 来帮助我们识别这个 reCAPTCHA 验证码，告诉 2Captcha 之后，2Captcha 会利用这些信息加载出对应的验证码，再利用其背后的人力来对验证码进行识别，最后将识别得到的 token 返回给我们即可。好，那么接下来怎么把这个信息告诉 2Captcha 呢？很简单，2Captcha 为我们提供了一个接口，其接口地址为：https://2captcha.com/in.php，我们只需要将对应的信息发送到这个接口就好了。那么发送需要什么参数呢，在这里介绍一下：

参数

类型

必须

描述

key

String

Yes

我们自己的 API KEY

method

String

Yes

userrecaptcha，定义破解 reCAPTCHA 验证码的方式

googlekey

String

Yes

reCAPTCHA 的 sitekey

pageurl

String

Yes

reCAPTCHA 当前所在的 URL

invisible

Integer Default: 0

No

是否可见，1 代表是隐式验证码，0 代表普通验证码。

header_acao

Integer Default: 0

No

跨域访问配置

pingback

String

No

回调地址

json

Integer Default: 0

No

返回格式，1 代表返回 JSON 格式，0 代表纯文本，默认 0

soft_id

Integer

No

ID of software developer. Developers who integrated their software with 2captcha get reward: 10% of spendings of their software users.

proxy

String

No

代理配置

在这里我们可以构造一个 URL，它包括这几个参数：

key：注意这里的 KEY 换成你自己的 API KEY
method：直接赋值 userrecaptcha
googlekey：复制的 sitekey
pageurl：当前 URL
json：直接赋值 1，代表返回 JSON 格式

比如在这里我就构造了这个 URL，内容如下：

1	https://2captcha.com/in.php?key=c0ae5935d807c28f285e5cb16c676a48&method=userrecaptcha&googlekey=6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-&pageurl=https://www.google.com/recaptcha/api2/demo&json=1

这时候我们直接向这个 URL 发起一个 GET 请求即可。我们可以直接在浏览器里面输入这个 URL，也可以使用 requests 等请求库来完成：

import requests

response = requests.get(url)
print(response.json())

接口会返回如下格式的内容：

1	{'status': 1, 'request': '62919419695'}

这里它返回了一个 JSON 格式的数据，其中 status 代表请求状态，如果是 1 的话，代表请求成功，另外其还会包含一个 request 字段，其内容是一个 ID，这个 ID 就是识别这个验证码的任务的 ID。因为 2Captcha 背后有很多人来帮助识别验证码，所以 2Captcha 将每个验证码的识别划分为一个个任务，每个任务都有一个唯一的 ID，刚分配任务时，这个任务被标记为 NOT_READY 状态。这些任务接下来会被分发给一个个人，识别完成之后，该任务就会被标记为已经识别状态，同时附有识别之后的信息，如 token 等内容。好，刚才的接口请求成功之后，这个 reCAPTCHA 的识别任务就已经被下发了，其背后会有对应的人来对这个 reCAPTCHA 验证码进行识别，识别过程可能需要十几秒到几十秒不等，我们可以通过另一个接口来获取任务的结果。获取结果的接口地址为：https://2captcha.com/res.php，同样我们需要传入一些参数，其参数介绍如下：

参数

类型

必需

描述

key

String

Yes

API KEY

action

String

Yes

get，表示获取验证码的结果

id

Integer

Yes

任务 ID，就是刚才 in.php 接口返回的结果。

json

Integer Default: 0

No

返回 JSON 格式，1 代表使用 JSON 格式，0 代表纯文本格式

在这里我们构造一个 URL，它包括如上的参数：

key：在这里换成你的 API KEY
action：就直接赋值 get
id：任务 ID
json：在这里用 1，即返回 JSON 格式数据

这样我们就构造了如下的 URL：

1	https://2captcha.com/res.php?key=c0ae5935d807c28f285e5cb16c676a48&action=get&id=62919419695&json=1

同样我们可以在浏览器中访问或者用 requests 请求，得到如下结果：

{
    "status": 1,
    "request": "03AOLTBLSg0fQUUMtP2o3kvJWNm6zla8MEjP_vPh629-xS-d_QrlJwMcxQfSJMUIU92noqbJ16yt5a0PdB3ORW-5MEbqK7NZ82bTnSZohCG_mYVVv8TbuvM1A99DFvlepxGEKlGCoi5lTHJd5z_QQ2mV1trGlI8VJkHjVAhLZzlz67MVgQzIu7aDl39n6aocAIVueQuCyjmA1C3hUECxpNlXJuXYVD10eJrqY_Bu36_2E0uBrmDIkAIjxCzEZWgadToU4ByLReOrNJ7_4t-P8leTUbPC5YBXvoDZZZByz8-vNnHzUu3GNNESzGSCMFfVPYumnXXI6i7TO5p1k-AElgb7qor6vDJGA_RpNNSUgAj8B0synG9APpbMQ4cEprHXle5pJtNCBX_v_8uqJLobomIx0St5l_H1tHGuTgI2UU-nWmR9TwvKp6SR-6G2Fi6pv7c8350tPbqJWWMcV0AXdfM85GjRDh2t7wh1CMukLQE21aIIwHh88kR0Fh0481Kw_umw8IfFCHyHKu8IcTERUL5LZdDzQkiGdF1wqWP-GhySMXEx-eOT7tB6SqPEAmO_mbwtJtA-qKzcHP"
}

如果其返回的是如上格式的数据，就代表 reCAPTCHA 验证码已经识别成功了，其返回的 request 字段的内容就是识别的 token，我们直接拿着这个 token 放到表单里面提交就成功了。那这个 token 怎么来用呢？其实如果不走 2Captcha 接口，我们如果人工验证成功之后，在其表单里面会把一个 name 叫做 g-recaptcha-response 的 textarea 赋值，如果验证成功，它的 value 值就是验证之后得到的 token，这个会作为表单提交的一部分发送到服务器进行验证。如果这个字段校验成功了，那就没问题了。所以，2Captcha 相当于为我们模拟了点选验证码的过程，其最终得到的这个 token 其实就是我们应该赋值给 name 为 g-recaptcha-response 的内容。那么怎么赋值呢？很简单，用 JavaScript 就好了。我们可以用 JavaScript 选取到这个 textarea，然后直接赋值即可，代码如下：

1	document.getElementById("g-recaptcha-response").innerHTML="TOKEN_FROM_2CAPTCHA";

注意这里的 TOKEN_FROM_2CAPTCHA 需要换成刚才我们所得到的 token 值。我们做爬虫模拟登录的时候，假如是用 Selenium、Puppeteer 等软件，在模拟程序里面，只需要模拟执行这段 JavaScript 代码，就可以成功赋值了。执行之后，直接提交表单，我们查看下 Network 请求：可以看到其就是提交了一个表单，其中有一个字段就是 g-recaptcha-response，它会发送到服务端进行校验，校验通过，那就成功了。所以，如果我们借助于 2Captcha 得到了这个 token，然后把它赋值到表单的 textarea 里面，表单就会提交，如果 token 有效，就能成功绕过登录，而不需要我们再去点选验证码了。最后我们得到如下成功的页面：至此，我们就成功地借助 2Captcha 来完成了 reCAPTCHA V2 验证码的识别。

总结

本节我们介绍了利用 2Captcha 来帮助识别 reCAPTCHA V2 的流程。那应该来讲，我觉得工程师使用这样的服务并不是一种令人羞耻的过程，尤其是他可以以比较低的价格实现你的需求的情况下。毕竟你的时间，本身就是一种价值。最后 2Captcha 这个网站我放在下面，有感兴趣的朋友可以看一下。另外如果有什么爬虫方面想看的文章，也欢迎在下面留言，我们会挑选被点赞较多的主题尽快写文。谢谢！

2captcha.com/zh

作者崔庆才发表于 2019-12-27 阅读次数：本文字数： 6.3k 阅读时长 ≈ 6 分钟

Python 严选高质量文章 - 爬虫工程师必看，深入解读字体反爬虫

内容选自即将出版的《Python3 反爬虫原理与绕过实战》，本次公开书稿范围为第 6 章——文本混淆反爬虫。本篇为第 6 章中的第 4 小节，其余小节将逐步放送。

字体反爬虫开篇概述

在 CSS3 之前，Web 开发者必须使用用户计算机上已有的字体。但是在 CSS3 时代，开发者可以使用@font-face 为网页指定字体，对用户计算机字体的依赖。开发者可将心仪的字体文件放在 Web 服务器上，并在 CSS 样式中使用它。用户使用浏览器访问 Web 应用时，对应的字体会被浏览器下载到用户的计算机上。在学习浏览器和页面渲染的相关知识时，我们了解到 CSS 的作用是修饰 HTML ，所以在页面渲染的时候不会改变 HTML 文档内容。由于字体的加载和映射工作是由 CSS 完成的，所以即使我们借助 Splash、Selenium 和 Puppeteer 工具也无法获得对应的文字内容。字体反爬虫正是利用了这个特点，将自定义字体应用到网页中重要的数据上，使得爬虫程序无法获得正确的数据。

6.4.1 字体反爬虫示例

示例 7：字体反爬虫示例。网址：http://www.porters.vip/confusion/movie.html。任务：爬取影片信息展示页中的影片评分、评价人数和票房数据，页面内容如图 6-32 所示。图 6-32 示例 7 页面在编写代码之前，我们需要确定目标数据的元素定位。定位时，我们在 HTML 中发现了一些奇怪的符号，HTML 代码如下：

<div class="movie-index"> 
   <p class="movie-index-title">用户评分</p> 
   <div class="movie-index-content score normal-score"> 
       <span class="index-left info-num "> 
       <span class="stonefont"> ☒.☒ </span> 
       </span> 
   <div class="index-right"> 
   <div class="star-wrapper"> 
   <div class="star-on" style="width:90%;"></div> 
   </div> 
        <span class="score-num"><span class="stonefont"> ☒☒. ☒☒ 万</span>人评分</span> 
   </div> 
   </div> 
</div>

页面中重要的数据都是一些奇怪的字符，本应该显示“9.7”的地方在 HTML 中显示的是“☒.☒”，而本应该显示“56.83”的地方在 HTML 中显示的是“☒☒.☒☒”。与 6.3 节中的映射反爬虫不同，案例中的文字都被“☒”符号代替了，根本无法分辨。这就很奇怪了，“☒”能代表这么多种数字吗？要注意的是，Chrome 开发者工具的元素面板中显示的内容不一定是相应正文的原文，要想知道“☒”符号是什么，还需要到网页源代码中确认。对应的网页源代码如下：

<div class="movie-index">
    <p class="movie-index-title">用户评分</p>
    <div class="movie-index-content score normal-score">
        <span class="index-left info-num ">
            <span class="stonefont">&#xe624.&#xe9c7</span>
        </span>
        <div class="index-right">
          <div class="star-wrapper">
            <div class="star-on" style="width:90%;"></div>
          </div>
          <span class="score-num"><span class="stonefont">&#xf593&#xe9c7&#xe9c7.&#xe624万</span>人评分</span>
        </div>
    </div>
</div>

从网页源代码中看到的并不是符号，而是由&#x 开头的一些字符，这与示例 6 中的 SVG 映射反爬虫非常相似。我们将页面显示的数字与网页源代码中的字符进行比较，映射关系如图 6-33 所示。图 6-33 字符与数字的映射关系字符与数字是一一对应的，我们只需要多找一些页面，将 0 ~ 9 数字对应的字符凑齐即可。但如果目标网站的字体是动态变化的呢？映射关系也是变化的呢？根据 6.3 节的学习和分析，我们知道人为映射并不能解决这些问题，必须找到映射关系的规律，并使用 Python 代码实现映射算法才行。继续往下分析，难道字符映射是先异步加载数据再使用 JavaScript 渲染的？图 6-34 请求记录网络请求记录如图 6-34 所示，请求记录中并没有发现异步请求，这个猜测并没有得到证实。CSS 样式方面有没有线索呢？页面中包裹符号的标签的 class 属性值都是 stonefont：

1
2
3

<span class="stonefont">&#xe624.&#xe9c7</span> 
<span class="stonefont">&#xf593&#xe9c7&#xe9c7.&#xe624 万</span> 
<span class="stonefont">&#xea16&#xe339.&#xefd4&#xf19a</span>

但对应的 CSS 样式中仅设置了字体：

1
2
3

.stonefont { 
    font-family: stonefont; 
}

既然是自定义字体，就意味着会加载字体文件，我们可以在网络请求中找到加载的字体文件 movie.woff，并将其下载到本地，接着使用百度字体编辑器看一看里面的内容。百度字体编辑器 FontEditor （详见 http://fontstore.baidu.com/static/editor/index.html）是一款在线字体编辑软件，能够打开本地或者远程的 ttf、woff、eot、otf 格式的字体文件，具备这些格式字体文件的导入和导出功能，并且提供字形编辑、轮廓编辑和字体实时预览功能，界面如图 6-35 所示。图 6-35 百度字体编辑器界面打开页面后，将 movie.woff 文件拖曳到百度字体编辑器的灰色区域即可，字体文件内容如图 6-36 所示。图 6-36 字体文件 movie.woff 预览该字体文件中共有 12 个字体块，其中包括 2 个空白字体块和 0 ~ 9 的数字字体块。我们可以大胆地猜测，评分数据和票房数据中使用的数字正是从此而来。由此看来，我们还需要了解一些字体文件格式相关的知识，在了解文件格式和规律后，才能够找到更合理的解决办法。

6.4.2 字体文件 WOFF

WOFF（Web Open Font Format，Web 开放字体格式）是一种网页所采用的字体格式标准。本质上基于 SFNT 字体（如 TrueType），所以它具备 TrueType 的字体结构，我们只需要了解 TrueType 字体的相关知识即可。 TrueType 字体是苹果公司与微软公司联合开发的一种计算机轮廓字体，TrueType 字体中的每个字形由网格上的一系列点描述，点是字体中的最小单位，字形与点的关系如图 6-37 所示。图 6-37 字形与点的关系字体文件中不仅包含字形数据和点信息，还包括字符到字形映射、字体标题、命名和水平指标等，这些信息存在对应的表中，所以我们也可以认为 TrueType 字体文件由一系列的表组成，其中常用的表及其作用如图 6-38 所示。图 6-38 构成字体文件的常用表及其作用如何查看这些表的结构和所包含的信息呢？我们可以借助第三方 Python 库 fonttools 将 WOFF 等字体文件转换成 XML 文件，这样就能查看字体文件的结构和表信息了。首先我们要安装 fonttools 库，安装命令为：

1	$ pip install fonttools

安装完毕后就可以利用该库转换文件类型，对应的 Python 代码为：

1
2
3

from fontTools.ttLib import TTFont 
font = TTFont('movie.woff') # 打开当前目录的 movie.woff 文件
font.saveXML('movie.xml') # 另存为 movie.xml

代码运行后就会在当前目录生成名为 movie 的 XML 文件。文件中字符到字形映射表 cmap 的内容如下：

<cmap_format_4 platformID="0" platEncID="3" language="0"> 
   <map code="0x78" name="x"/> 
   <map code="0xe339" name="uniE339"/> 
   <map code="0xe624" name="uniE624"/> 
   <map code="0xe7df" name="uniE7DF"/> 
   <map code="0xe9c7" name="uniE9C7"/> 
   <map code="0xea16" name="uniEA16"/> 
   <map code="0xee76" name="uniEE76"/> 
   <map code="0xefd4" name="uniEFD4"/> 
   <map code="0xf19a" name="uniF19A"/> 
   <map code="0xf57b" name="uniF57B"/> 
   <map code="0xf593" name="uniF593"/> 
</cmap_format_4>

map 标签中的 code 代表字符，name 代表字形名称，关系如图 6-39 所示。图 6-39 字符到字形映射关系示例 XML 中的字符 0xe339 与网页源代码中的字符 对应，这样我们就确定了 HTML 中的字符码与 movie.woff 字体文件中对应的字形关系。字形数据存储在 glyf 表中，每个字形的数据都是独立的，例如字形 uniE339 的字形数据如下：

<TTGlyph name="uniE339" xMin="0" yMin="-12" xMax="510" yMax="719"> 
   <contour> 
     <pt x="410" y="534" on="1"/> 
     <pt x="398" y="586" on="0"/> 
     <pt x="377" y="609" on="1"/> 
     <pt x="341" y="646" on="0"/> 
     <pt x="289" y="646" on="1"/> 
     ... 
   </contour> 
   <contour> 
     <pt x="139" y="232" on="1"/> 
     <pt x="139" y="188" on="0"/> 
     <pt x="178" y="103" on="0"/> 
     ... 
   </contour> 
   <instructions/> 
</TTGlyph>

TTGlyph 标签中记录着字形的名称、x 轴坐标和 y 轴坐标（坐标也可以理解为字形的宽高）。contour 标签记录的是字形的轮廓信息，也就是多个点的坐标位置，正是这些点构成了如图 6-40 所示的字形。图 6-40 字形 uniE339 的轮廓我们可以在百度字体编辑器中调整点的位置，然后保存字体文件并将新字体文件转换为 XML 格式，相同名称的字形数据如下：

<TTGlyph name="uniE339" xMin="115" yMin="6" xMax="430" yMax="495"> 
 <contour> 
   <pt x="400" y="352" on="1"/> 
   <pt x="356" y="406" on="0"/> 
   <pt x="342" y="421" on="1"/> 
   <pt x="318" y="446" on="0"/> 
   <pt x="283" y="446" on="1"/> 
   ... 
 </contour> 
 <instructions/> 
</TTGlyph>

接着将调整前的字形数据和调整后的字形数据进行对比。如图 6-41 所示，点的位置调整后，字形数据也会发生相应的变化，如 xMin、xMax、yMin、yMax 还有 pt 标签中的 x 坐标 y 坐标都与之前的不同了。图 6-41 字形数据对比 XML 文件中记录的是字形坐标信息，实际上，我们没有办法直接通过字形数据获得文字，只能从其他方面想办法。虽然目标网站使用多套字体，但相同文字的字形也是相同的。比如现在有 movie.woff 和 food.woff 这两套字体，它们包含的字形如下：

# movie.woff 
# 包含 10 个字形数据：[0123456789] 
<cmap_format_4 platformID="0" platEncID="3" language="0"> 
   <map code="0x78" name="x"/> 
   <map code="0xe339" name="uniE339"/> # 数字 6 
   <map code="0xe624" name="uniE624"/> # 数字 9 
   <map code="0xe7df" name="uniE7DF"/> # 数字 2 
   <map code="0xe9c7" name="uniE9C7"/> # 数字 7 
   <map code="0xea16" name="uniEA16"/> # 数字 5 
   <map code="0xee76" name="uniEE76"/> # 数字 0 
   <map code="0xefd4" name="uniEFD4"/> # 数字 8 
   <map code="0xf19a" name="uniF19A"/> # 数字 3 
   <map code="0xf57b" name="uniF57B"/> # 数字 1
   <map code="0xf593" name="uniF593"/> # 数字 4 
</cmap_format_4> 

# food.woff 
# 包含 3 个字形数据：[012] 
<cmap_format_4 platformID="0" platEncID="3" language="0"> 
   <map code="0x78" name="x"/> 
   <map code="0xe556" name="uniE556"/> # 数字 0 
   <map code="0xe667" name="uniE667"/> # 数字 1 
   <map code="0xe778" name="uniE778"/> # 数字 2 
</cmap_format_4>

要实现自动识别文字，需要先准备参照字形，也就是人为地准备数字 0 ~ 9 的字形映射关系和字形数据，如：

# 0 和 7 与字形名称的映射伪代码，data 键对应的值是字形数据
font_mapping = [ 
   {'name': 'uniE9C7', 'words': '7', 'data': 'uniE9C7_contour_pt'}, 
   {'name': 'uniEE76', 'words': '0', 'data': 'uniEE76_countr_pt'}, 
]

当我们遇到目标网站上其他字体文件时，就可以使用参照字形中的字形数据与目标字形进行匹配，如果字形数据非常接近，就认为这两个字形描述的是相同的文字。字形数据包含记录字形名称和字形起止坐标的 TTGlyph 标签以及记录点坐标的 pt 标签，起止坐标代表的是字形在画布上的位置，点坐标代表字形中每个点在画布上的位置。在起止坐标中，x 轴差值代表字形宽度，y 轴差值代表字形高度。如图 6-42 所示，两个字形的起止坐标和宽高都有很大的差别，但是却能够描述相同的文字，所以字形在画布中的位置并不会影响描述的文字，字形宽度和字形高度也不会影响描述的文字。图 6-42 描述相同文字的两个字形点坐标的数量和坐标值可以作为比较条件吗？如图 6-43 所示，两个不同文字的字形数据是不一样的。虽然这两种字形的 name 都是 uniE9C7，但是字形数据中大部分 pt 标签 x 和 y 的差距都很大，所以我们可以判定这两个字形描述的并不是同一个文字。你可能会想到点的数量也可以作为排除条件，也就是说如果点的数量不相同，那么这个两个字形描述的就不是同一个文字。真的是这样吗？图 6-43 描述不同文字的字形数据对比在图 6-44 中，左侧描述文字 7 的字形有 17 个点，而右侧描述文字 7 的字形却有 20 个点。对应的字形信息如图 6-45 所示。图 6-44 描述相同文字的字形图 6-45 描述相同文字的字形信息虽然点的数量不一样，但是它们的字形并没有太大的变化，也不会造成用户误读，所以点的数量并不能作为排除不同字形的条件。因此，只有起止坐标和点坐标数据完全相同的字形，描述的才是相同字符。

6.4.3 字体反爬虫绕过实战

要确定两组字形数据描述的是否为相同字符，我们必须取出 HTML 中对应的字形数据，然后将待确认的字形与我们准备好的基准字形数据进行对比。现在我们来整理一下这一系列工作的步骤。 (1) 准备基准字形描述信息。 (2) 访问目标网页。 (3) 从目标网页中读取字体编码字符。 (4) 下载 WOFF 文件并用 Python 代码打开。 (5) 根据字体编码字符找到 WOFF 文件中的字形轮廓信息。 (6) 将该字形轮廓信息与基准字形轮廓信息进行对比。 (7) 得出对比结果。我们先完成前 4 个步骤的代码。下载 WOFF 文件并将其中字形描述的文字与人类认知的文字进行映射。由于字形数据比较庞大，所以我们可以将字形数据进行散列计算，这样得到的结果既简短又唯一，不会影响对比结果。这里以数字 0 ~ 9 为例：

base_font = { 
 "font": [{"name": "uniEE76", "value": "0", "hex": "fc170db1563e66547e9100cf7784951f"}, 
 {"name": "uniF57B", "value": "1", "hex": "251357942c5160a003eec31c68a06f64"}, 
 {"name": "uniE7DF", "value": "2", "hex": "8a3ab2e9ca7db2b13ce198521010bde4"}, 
 {"name": "uniF19A", "value": "3", "hex": "712e4b5abd0ba2b09aff19be89e75146"}, 
 {"name": "uniF593", "value": "4", "hex": "e5764c45cf9de7f0a4ada6b0370b81a1"}, 
 {"name": "uniEA16", "value": "5", "hex": "c631abb5e408146eb1a17db4113f878f"}, 
 {"name": "uniE339", "value": "6", "hex": "0833d3b4f61f02258217421b4e4bde24"}, 
 {"name": "uniE9C7", "value": "7", "hex": "4aa5ac9a6741107dca4c5dd05176ec4c"}, 
 {"name": "uniEFD4", "value": "8", "hex": "c37e95c05e0dd147b47f3cb1e5ac60d7"}, 
 {"name": "uniE624", "value": "9", "hex": "704362b6e0feb6cd0b1303f10c000f95"}] 
}

字典中的 name 代表该字形的名称，value 代表该字形描述的文字，hex 代表字形信息的 MD5 值。考虑到网络请求记录中的字体文件路径有可能会变化，我们必须找到 CSS 中设定的字体文件路径，引入 CSS 的 HTML 代码为：

1	<link href="./css/movie.css" rel="stylesheet">

由引入代码得知该 CSS 文件的路径为 http://www.porters.vip/confusion/css/movie.css，文件中 @font-face 处就是设置字体的代码：

@font-face { 
   font-family: stonefont; 
   src:url('../font/movie.woff') format('woff'); 
}

字体文件路径为 http://www.porters.vip/confusion/font/movie.woff。找到文件后，我们就可以开始编写代码了，对应的 Python 代码如下：

import re 
from parsel import Selector 
from urllib import parse 
from fontTools.ttLib import TTFont 
url = 'http://www.porters.vip/confusion/movie.html' 
resp = requests.get(url) 
sel = Selector(resp.text) 
# 提取页面加载的所有 css 文件路径
css_path = sel.css('link[rel=stylesheet]::attr(href)').extract() 
woffs = [] 
for c in css_path: 
   # 拼接正确的 css 文件路径
   css_url = parse.urljoin(url, c) 
   # 向 css 文件发起请求
   css_resp = requests.get(css_url) 
   # 匹配 css 文件中的 woff 文件路径
   woff_path = re.findall("src:url('..(.*.woff)') format('woff');", 
   css_resp.text)
   if woff_path: 
       # 如故路径存在则添加到 woffs 列表中
       woffs += woff_path 
woff_url = 'http://www.porters.vip/confusion' + woffs.pop() 
woff = requests.get(woff_url) 
filename = 'target.woff' 
with open(filename, 'wb') as f: 
   # 将文件保存到本地
   f.write(woff.content) 
# 使用 TTFont 库打开刚才下载的 woff 文件
font = TTFont(filename)

因为 TTFont 可以直接读取 woff 文件的结构，所以这里不需要将 woff 保存为 XML 文件。接着以评分数据 9.7 对应的编码 #xe624.#xe9c7 进行测试，在原来的代码中引入基准字体数据 base_font，然后新增以下代码：

web_code = '&#xe624.&#xe9c7'
# 编码文字替换
woff_code = [i.upper().replace('&#X', 'uni') for i in web_code.split('.')] 
import hashlib 
result = [] 
for w in woff_code: 
   # 从字体文件中取出对应编码的字形信息
   content = font['glyf'].glyphs.get(w).data 
   # 字形信息 MD5 
   glyph = hashlib.md5(content).hexdigest() 
   for b in base_font.get('font'): 
       # 与基准字形中的 MD5 值进行对比，如果相同则取出该字形描述的文字
       if b.get('hex') == glyph: 
           result.append(b.get('value')) 
           break 
# 打印映射结果
print(result)

以上代码运行结果为：

1	['9', '7']

运行结果说明能够正确映射字体文件中字形描述的文字。

6.4.4 小结

字体反爬能给爬虫工程师带来很大的麻烦。虽然爬虫工程师找到了应对方法，但这种方法依赖的条件比较严苛，如果开发者频繁改动字体文件或准备多套字体文件并随机切换，那真是一件令爬虫工程师头疼的事。不过，这些工作对于开发者来说也不是轻松的事。

新书福利

真是翘首以盼！《Python3 反爬虫原理与绕过实战》一书终于要跟大家见面了！为了感谢大家对韦世东和本书的期待与支持，在新书发布时会举办多场送书活动和限时折扣活动。想要与作者韦世东交流或者参加新书发布活动的朋友可以扫描二维码进群与我互动哦！

转载说明

本篇内容摘自出版图书《Python3 反爬虫原理与绕过实战》，欢迎各位好友与同行转载！记得带上相关的版权信息哦😊。

作者韦世东学算法和反爬虫发表于 2019-12-26 阅读次数：本文字数： 11k 阅读时长 ≈ 10 分钟

技术杂谈 如何通过 Tampermonkey 快速查找 JavaScript 加密入口

在很多情况下，我们可能想要在网页中自动执行某些代码，帮助我们完成一些操作。如自动抢票、自动刷单、自动爬虫等等，这些操作绝大部分都是借助 JavaScript 来实现的。那么问题来了？在浏览器里面怎样才能方便地执行我们所期望执行的 JavaScript 代码呢？在这里推荐一个插件，叫做 Tampermonkey。这个插件的功能非常强大，利用它我们几乎可以在网页中执行任何 JavaScript 代码，实现我们想要的功能。当然不仅仅是自动抢票、自动刷单、自动爬虫，Tampermonkey 的用途远远不止这些，只要我们想要的功能能用 JavaScript 实现，Tampermonkey 就可以帮我们做到。比如我们可以将 Tampermonkey 应用到 JavaScript 逆向分析中，去帮助我们更方便地分析一些 JavaScript 加密和混淆代码。本节我们就来介绍一下这个插件的使用方法，并结合一个实际案例，介绍下这个插件在 JavaScript 逆向分析中的用途。

Tampermonkey

Tampermonkey，中文也叫作「油猴」，它是一款浏览器插件，支持 Chrome。利用它我们可以在浏览器加载页面时自动执行某些 JavaScript 脚本。由于执行的是 JavaScript，所以我们几乎可以在网页中完成任何我们想实现的效果，如自动爬虫、自动修改页面、自动响应事件等等。

安装

首先我们需要安装 Tampermonkey，这里我们使用的浏览器是 Chrome。直接在 Chrome 应用商店或者在 Tampermonkey 的官网 https://www.tampermonkey.net/ 下载安装即可。安装完成之后，在 Chrome 浏览器的右上角会出现 Tampermonkey 的图标，这就代表安装成功了。

获取脚本

Tampermonkey 运行的是 JavaScript 脚本，每个网站都能有对应的脚本运行，不同的脚本能完成不同的功能。这些脚本我们可以自定义，同样也可以用已经写好的很多脚本，毕竟有些轮子有了，我们就不需要再去造了。我们可以在 https://greasyfork.org/zh-CN/scripts 这个网站找到一些非常实用的脚本，如全网视频去广告、百度云全网搜索等等，大家可以体验一下。

脚本编写

除了使用别人已经写好的脚本，我们也可以自己编写脚本来实现想要的功能。编写脚本难不难呢？其实就是写 JavaScript 代码，只要懂一些 JavaScript 的语法就好了。另外除了懂 JavaScript 语法，我们还需要遵循脚本的一些写作规范，这其中就包括一些参数的设置。下面我们就简单实现一个小的脚本，实现某个功能。首先我们可以点击 Tampermonkey 插件图标，点击「管理面板」按钮，打开脚本管理页面。界面类似显示如下图所示。在这里显示了我们已经有的一些 Tampermonkey 脚本，包括我们自行创建的，也包括从第三方网站下载安装的。另外这里也提供了编辑、调试、删除等管理功能，我们可以方便地对脚本进行管理。接下来我们来创建一个新的脚本来试试，点击左侧的「+」号，会显示如图所示的页面。初始化的代码如下：

// ==UserScript==
// @name         New Userscript
// @namespace    http://tampermonkey.net/
// @version      0.1
// @description  try to take over the world!
// @author       You
// @match        https://www.tampermonkey.net/documentation.php?ext=dhdg
// @grant        none
// ==/UserScript==

(function() {
    'use strict';

    // Your code here...
})();

这里最上面是一些注释，但这些注释是非常有用的，这部分内容叫做 UserScript Header ，我们可以在里面配置一些脚本的信息，如名称、版本、描述、生效站点等等。下面简单介绍下 UserScript Header 的一些参数定义。

@name：脚本的名称，就是在控制面板显示的脚本名称。
@namespace：脚本的命名空间。
@version：脚本的版本，主要是做版本更新时用。
@author：作者。
@description：脚本描述。
@homepage, @homepageURL, @website，@source：作者主页，用于在 Tampermonkey 选项页面上从脚本名称点击跳转。请注意，如果 @namespace 标记以 http://开头，此处也要一样。
@icon, @iconURL and @defaulticon：低分辨率图标。
@icon64 and @icon64URL：64x64 高分辨率图标。
@updateURL：检查更新的网址，需要定义 @version。
@downloadURL：更新下载脚本的网址，如果定义成 none 就不会检查更新。
@supportURL：报告问题的网址。

@include：生效页面，可以配置多个，但注意这里并不支持 URL Hash。例如：

// @include http://www.tampermonkey.net/*
// @include http://*
// @include https://*
// @include *

@match：约等于 @include 标签，可以配置多个。
@exclude：不生效页面，可配置多个，优先级高于 @include 和 @match。

@require：附加脚本网址，相当于引入外部的脚本，这些脚本会在自定义脚本执行之前执行，比如引入一些必须的库，如 jQuery 等，这里可以支持配置多个 @require 参数。例如：

1
2
3

// @require https://code.jquery.com/jquery-2.1.4.min.js
// @require https://code.jquery.com/jquery-2.1.3.min.js#sha256=23456...
// @require https://code.jquery.com/jquery-2.1.2.min.js#md5=34567...,sha256=6789...

@resource：预加载资源，可通过 GM_getResourceURL 和 GM_getResourceText 读取。
@connect：允许被 GM_xmlhttpRequest 访问的域名，每行一个。
@run-at：脚本注入的时刻，如页面刚加载时，某个事件发生后等等。例如：
- document-start：尽可能地早执行此脚本。
- document-body：DOM 的 body 出现时执行。
- document-end：DOMContentLoaded 事件发生时或发生后后执行。
- document-idle：DOMContentLoaded 事件发生后执行，即 DOM 加载完成之后执行，这是默认的选项。
- context-menu：如果在浏览器上下文菜单（仅限桌面 Chrome 浏览器）中点击该脚本，则会注入该脚本。注意：如果使用此值，则将忽略所有 @include 和 @exclude 语句。

@grant：用于添加 GM 函数到白名单，相当于授权某些 GM 函数的使用权限。例如：

// @grant GM_setValue
// @grant GM_getValue
// @grant GM_setClipboard
// @grant unsafeWindow
// @grant window.close
// @grant window.focus

如果没有定义过 @grant 选项，Tampermonkey 会猜测所需要的函数使用情况。

@noframes：此标记使脚本在主页面上运行，但不会在 iframe 上运行。

@nocompat：由于部分代码可能是专门为专门的浏览器所写，通过此标记，Tampermonkey 会知道脚本可以运行的浏览器。例如：

1	// @nocompat Chrome

这样就指定了脚本只在 Chrome 浏览器中运行。

除此之外，Tampermonkey 还定义了一些 API，使得我们可以方便地完成某个操作，如：

GM_log：将日志输出到控制台。
GM_setValue：将参数内容保存到 Storage 中。
GM_addValueChangeListener：为某个变量添加监听，当这个变量的值改变时，就会触发回调。
GM_xmlhttpRequest：发起 Ajax 请求。
GM_download：下载某个文件到磁盘。
GM_setClipboard：将某个内容保存到粘贴板。

还有很多其他的 API，大家可以到 https://www.tampermonkey.net/documentation.php 来查看更多的内容。在 UserScript Header 下方是 JavaScript 函数和调用的代码，其中 'use strict' 标明代码使用 JavaScript 的严格模式，在严格模式下可以消除 Javascript 语法的一些不合理、不严谨之处，减少一些怪异行为，如不能直接使用未声明的变量，这样可以保证代码的运行安全，同时提高编译器的效率，提高运行速度。在下方 // Your code here... 这里我们就可以编写自己的代码了。

实战 JavaScript 逆向

下面我们来通过一个简单的 JavaScript 逆向案例来演示一下 Tampermonkey 的作用。在 JavaScript 逆向的时候，我们经常会需要追踪某些方法的堆栈调用情况，但很多情况下，一些 JavaScript 的变量或者方法名经过混淆之后是非常难以捕捉的。但如果我们能掌握一定的门路或规律，辅助以 Tampermonkey，就可以更轻松地找出一些 JavaScript 方法的断点位置，从而加速逆向过程。在逆向过程中，一个非常典型的技术就是 Hook 技术。Hook 技术中文又叫做钩子技术，它就是在程序运行的过程中，对其中的某个方法进行重写，在原先的方法前后加入我们自定义的代码。相当于在系统没有调用该函数之前，钩子程序就先捕获该消息，钩子函数先得到控制权，这时钩子函数既可以加工处理（改变）该函数的执行行为，还可以强制结束消息的传递。如果觉得比较抽象，看完下面的 Hook 案例就懂了。例如，我们接下来使用 Tampermonkey 实现对某个 JavaScript 方法的 Hook，轻松找到某个方法执行的位置，从而快速定位到逆向入口。接下来我们来这么一个简单的网站：https://scrape.cuiqingcai.com/login1，这个网站结构非常简单，就是一个用户名密码登录，但是不同的是，点击 Submit 的时候，表单提交 POST 的内容并不是单纯的用户名和密码，而是一个加密后的 Token。页面长这样：我们随便输入用户名密码，点击登录按钮，观察一下网络请求的变化。可以看到如下结果：看到实际上控制台提交了一个 POST 请求，内容为：

1	{"token":"eyJ1c2VybmFtZSI6ImFkbWluIiwicGFzc3dvcmQiOiJhZG1pbiJ9"}

嗯，确实，没有诸如 username 和 password 的内容了，那这究竟是个啥？我要是做爬虫的话？怎么模拟登录呢？模拟登录的前提当然就是找到当前 token 生成的逻辑了，那么问题来了，到底这个 token 和用户名、密码什么关系呢？我们怎么来找寻其中的蛛丝马迹呢？这里我们就可能思考了，本身输入的是用户名和密码，但是提交的时候却变成了一个 token，经过观察 token 的内容还很像 Base64 编码。这就代表，网站可能首先将用户名密码混为了一个新的字符串，然后最后经过了一次 Base64 编码，最后将其赋值为 token 来提交了。所以，初步观察我们可以得出这么多信息。好，那就来验证下吧，看看网站 JavaScript 代码里面是咋实现的。接下来我们看看网站的源码，打开 Sources 面板，好家伙，看起来都是 Webpack 打包之后的内容，经过了一些混淆，类似结果如下：这么多混淆代码，总不能一点点扒着看吧？这得找到猴年马月？那么遇到这种情形，这怎么去找 token 的生成位置呢？解决方法其实有两种。

Ajax 断点

由于这个请求正好是一个 Ajax 请求，所以我们可以添加一个 XHR 断点监听，把 POST 的网址加到断点监听上面去，在 Sources 面板右侧添加这么一个 XHR 断点，如图所示：这时候如果我们再次点击登录按钮的时候，正好发起一次 Ajax 请求，就进入到断点了，然后再看堆栈信息就可以一步步找到编码的入口了。点击 Submit 之后，页面就进入了 Debug 状态停下来了，结果如下：一步步找，我们最后其实可以找到入口其实是在 onSubmit 方法这里。但实际上，我们观察到，这里的断点的栈顶还会包括了一些 async Promise 等无关的内容，而我们真正想找的是用户名和密码经过处理，再进行 Base64 编码的地方，这些请求的调用实际上和我们找寻的入口是没有很大的关系的。另外，如果我们想找的入口位置并不伴随这一次 Ajax 请求，这个方法就没法用了。这个方法是奏效的，但是我们先不讲 onSubmit 方法里面究竟是什么逻辑，下一个方法再来讲。

Hook Function

所以，这里介绍第二种可以快速定位入口的方法，那就是使用 Tampermonkey 自定义 JavaScript 实现某个 JavaScript 方法的 Hook。Hook 哪里呢？最明显的，Hook Base64 编码的位置就好了。那么这里就涉及到一个小知识点，JavaScript 里面的 Base64 编码是怎么实现的。没错就是 btoa 方法，所以说，我们来 Hook btoa 方法就好了。好，这里我们新建一个 Tampermonkey 脚本，内容如下：

// ==UserScript==
// @name         HookBase64
// @namespace    https://scrape.cuiqingcai.com/
// @version      0.1
// @description  Hook Base64 encode function
// @author       Germey
// @match       https://scrape.cuiqingcai.com/login1
// @grant        none
// ==/UserScript==
(function () {
    'use strict'
    function hook(object, attr) {
        var func = object[attr]
        object[attr] = function () {
            console.log('hooked', object, attr)
            var ret = func.apply(object, arguments)
            debugger
            return ret
        }
    }
    hook(window, 'btoa')
})()

首先我们定义了一些 UserScript Header，包括 @name、@match 等等，这里比较重要的就是 @name，表示脚本名称；另外一个就是 @match，代表脚本生效的网址。脚本的内容如上所示。我们定义了一个 hook 方法，传入 object 和 attr 参数，意思就是 Hook object 对象的 attr 参数。例如我们如果想 Hook 一个 alert 方法，那就把 object 设置为 window，把 attr 设置为 alert 字符串。这里我们想要 Hook Base64 的编码方法，在 JavaScript 中，Based64 编码是用 btoa 方法实现的，那么这里我们就只需要 Hook window 对象的 btoa 方法就好了。那么 Hook 是怎么实现的呢？我们来看下，首先一句 var func = object[attr]，相当于我们先把它赋值为一个变量，我们调用 func 方法就可以实现和原来相同的功能。接着，我们再直接改写这个方法的定义，直接改写 object[attr]，将其改写成一个新的方法，在新的方法中，通过 func.apply 方法又重新调用了原来的方法。这样我们就可以保证，前后方法的执行效果是不受什么影响的，之前这个方法该干啥就还是干啥的。但是和之前不同的是，我们自定义方法之后，现在可以在 func 方法执行的前后，再加入自己的代码，如 console.log 将信息输出到控制台，如 debugger 进入断点等等。这个过程中，我们先临时保存下来了 func 方法，然后定义一个新的方法，接管程序控制权，在其中自定义我们想要的实现，同时在新的方法里面再重新调回 func 方法，保证前后结果是不受影响的。所以，我们达到了在不影响原有方法效果的前提下，可以实现在方法的前后实现自定义的功能，就是 Hook 的过程。最后，我们调用 hook 方法，传入 window 对象和 btoa 字符串，保存。接下来刷新下页面，这时候我们就可以看到这个脚本就在当前页面生效了，如图所示。接下来，打开控制台，切换到 Sources 面板，这时候我们可以看到站点下面的资源多了一个叫做 Tampermonkey 的目录，展开之后，发现就是我们刚刚自定义的脚本。然后输入用户名、密码，点击提交。发现成功进入了断点模式停下来了，代码就卡在了我们自定义的 debugger 这一行代码的位置，如下图所示。成功 Hook 住了，这说明 JavaScript 代码在执行过程中调用到了 btoa 方法。看下控制台，如下图所示。这里也输出了 window 对象和 btoa 方法，验证正确。这样，我们就顺利找到了 Base64 编码操作这个路口，然后看看堆栈信息，也已经不会出现 async、Promise 这样的调用，很清晰地呈现了 btoa 方法逐层调用的过程，非常清晰明了了，如图所示。各个底层的 encode 方法略过，这样我们也非常顺利地找到了 onSubmit 方法里面的处理逻辑：

onSubmit: function() {
  var e = c.encode(JSON.stringify(this.form));
  this.$http.post(a["a"].state.url.root, {
    token: e
  }).then((function(e) {
    console.log("data", e)
  }))
}

仔细看看，encode 方法其实就是调用了一下 btoa 方法，就是一个 Base64 编码的过程。另外堆栈信息中可以清晰地看到 Hook 的方法在执行前传入的参数值，即 arguments。另外执行的之后的结果 ret 也可以轻松地找到了，如图所示：所以，现在我们知道了 token 和用户名、密码是什么关系了吧。这里一目了然了，就是对表单进行了 JSON 序列化，然后调用了 encode 也就是 btoa 方法，并赋值为了 token，入口顺利解开。后面，我们只需要模拟这个过程就 OK 了。所以，我们通过 Tampermonkey 自定义 JavaScript 脚本的方式实现了某个方法调用的 Hook，使得我们快速能定位到加密入口的位置，非常方便。以后如果观察出来了一些门道，可以多使用这种方法来尝试，如 Hook encode 方法、decode 方法、stringify 方法、log 方法、alert 方法等等，简单而又高效。以上便是通过 Tampermonkey 实现简单 Hook 的基础操作，当然这个仅仅是一个常见的基础案例，不过从中我们也可以总结出一些 Hook 的基本门道。后面我们会继续介绍更多相关内容。

参考来源

Hook 技术：https://www.jianshu.com/p/3382cc765b39
Tampermonkey：http://www.tampermonkey.net/
Base64 编码：https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/atob。
示例网址：https://github.com/Python3WebSpider/Scrape

注明

本篇属于 JavaScript 逆向系列内容。由于某些原因，JavaScript 逆向是在爬虫中比较敏感的内容，因此文章中不会选取当前市面上任何一个商业网站作为案例，都是通过自建平台示例的方式来单独讲解某个知识点。另外大家不要将相关技术应用到非法用途，惜命惜命。

作者崔庆才发表于 2019-12-24 阅读次数：本文字数： 8.3k 阅读时长 ≈ 8 分钟

Python [Python3网络爬虫开发实战] 15.5–Gerapy 分布式管理

15.5 Gerapy 分布式管理

我们可以通过 Scrapyd-Client 将 Scrapy 项目部署到 Scrapyd 上，并且可以通过 Scrapyd API 来控制 Scrapy 的运行。那么，我们是否可以做到更优化？方法是否可以更方便可控？我们重新分析一下当前可以优化的问题。

使用 Scrapyd-Client 部署时，需要在配置文件中配置好各台主机的地址，然后利用命令行执行部署过程。如果我们省去各台主机的地址配置，将命令行对接图形界面，只需要点击按钮即可实现批量部署，这样就更方便了。
使用 Scrapyd API 可以控制 Scrapy 任务的启动、终止等工作，但很多操作还是需要代码来实现，同时获取爬取日志还比较烦琐。如果我们有一个图形界面，只需要点击按钮即可启动和终止爬虫任务，同时还可以实时查看爬取日志报告，那这将大大节省我们的时间和精力。

所以我们的终极目标是如下内容。

更方便地控制爬虫运行
更直观地查看爬虫状态
更实时地查看爬取结果
更简单地实现项目部署
更统一地实现主机管理

而这所有的工作均可通过 Gerapy 来实现。 Gerapy 是一个基于 Scrapyd、Scrapyd API、Django、Vue.js 搭建的分布式爬虫管理框架。接下来将简单介绍它的使用方法。

1. 准备工作

在本节开始之前请确保已经正确安装好了 Gerapy，安装方式可以参考第一章。

2. 使用说明

首先可以利用 gerapy 命令新建一个项目，命令如下：

1	gerapy init

这样会在当前目录下生成一个 gerapy 文件夹，然后进入 gerapy 文件夹，会发现一个空的 projects 文件夹，我们后文会提及。这时先对数据库进行初始化：

1	gerapy migrate

这样即会生成一个 SQLite 数据库，数据库中会用于保存各个主机配置信息、部署版本等。接下来启动 Gerapy 服务，命令如下：

1	gerapy runserver

这样即可在默认 8000 端口上开启 Gerapy 服务，我们浏览器打开：http://localhost:8000 即可进入 Gerapy 的管理页面，在这里提供了主机管理和项目管理的功能。主机管理中，我们可以将各台主机的 Scrapyd 运行地址和端口添加，并加以名称标记，添加之后便会出现在主机列表中，Gerapy 会监控各台主机的运行状况并以不同的状态标识，如图 15-6 所示：图 15-6 主机列表另外刚才我们提到在 gerapy 目录下有一个空的 projects 文件夹，这就是存放 Scrapy 目录的文件夹，如果我们想要部署某个 Scrapy 项目，只需要将该项目文件放到 projects 文件夹下即可。比如这里我放了两个 Scrapy 项目，如图 15-7 所示：图 15-7 项目目录这时重新回到 Gerapy 管理界面，点击项目管理，即可看到当前项目列表，如图 15-8 所示：图 15-8 项目列表由于此处我有过打包和部署记录，在这里分别予以显示。 Gerapy 提供了项目在线编辑功能，我们可以点击编辑即可可视化地对项目进行编辑，如图 15-9 所示：图 15-9 可视化编辑如果项目没有问题，可以点击部署进行打包和部署，部署之前需要打包项目，打包时可以指定版本描述，如图 15-10 所示：图 15-10 项目打包打包完成之后可以直接点击部署按钮即可将打包好的 Scrapy 项目部署到对应的云主机上，同时也可以批量部署，如图 15-11 所示：图 15-11 部署页面部署完毕之后就可以回到主机管理页面进行任务调度了，点击调度即可查看进入任务管理页面，可以当前主机所有任务的运行状态，如图 15-12 所示：图 15-12 任务运行状态我们可以通过点击新任务、停止等按钮来实现任务的启动和停止等操作，同时也可以通过展开任务条目查看日志详情，如图 15-13 所示：图 15-13 查看日志这样我们就可以实时查看到各个任务运行状态了。以上便是 Gerapy 的一些功能的简单介绍，使用它我们可以更加方便地管理、部署和监控 Scrapy 项目，尤其是对分布式爬虫来说。更多的信息可以查看 Gerapy 的 GitHub 地址：https://github.com/Gerapy。

3. 结语

本节我们介绍了 Gerapy 的简单使用，利用它我们可以方便地实现 Scrapy 项目的部署、管理等操作，可以大大提高效率。

作者崔庆才发表于 2019-12-12 阅读次数：本文字数： 1.7k 阅读时长 ≈ 2 分钟

Python [Python3网络爬虫开发实战] 15.4–Scrapyd 批量部署

15.4 Scrapyd 批量部署

我们在上一节实现了 Scrapyd 和 Docker 的对接，这样每台主机就不用再安装 Python 环境和安装 Scrapyd 了，直接执行一句 Docker 命令运行 Scrapyd 服务即可。但是这种做法有个前提，那就是每台主机都安装 Docker，然后再去运行 Scrapyd 服务。如果我们需要部署 10 台主机的话，工作量确实不小。一种方案是，一台主机已经安装好各种开发环境，我们取到它的镜像，然后用镜像来批量复制多台主机，批量部署就可以轻松实现了。另一种方案是，我们在新建主机的时候直接指定一个运行脚本，脚本里写好配置各种环境的命令，指定其在新建主机的时候自动执行，那么主机创建之后所有的环境就按照自定义的命令配置好了，这样也可以很方便地实现批量部署。目前很多服务商都提供云主机服务，如阿里云、腾讯云、Azure、Amazon 等，不同的服务商提供了不同的批量部署云主机的方式。例如，腾讯云提供了创建自定义镜像的服务，在新建主机的时候使用自定义镜像创建新的主机即可，这样就可以批量生成多个相同的环境。Azure 提供了模板部署的服务，我们可以在模板中指定新建主机时执行的配置环境的命令，这样在主机创建之后环境就配置完成了。本节我们就来看看这两种批量部署的方式，来实现 Docker 和 Scrapyd 服务的批量部署。

1. 镜像部署

以腾讯云为例进行说明。首先需要有一台已经安装好环境的云主机，Docker 和 Scrapyd 镜像均已经正确安装，Scrapyd 镜像启动加到开机启动脚本中，可以在开机时自动启动。接下来我们来看下腾讯云下批量部署相同云服务的方法。首先进入到腾讯云后台，可以点击更多选项制作镜像，如图 15-3 所示。图 15-3 制作镜像然后输入镜像的一些配置信息，如图 15-4 所示。图 15-4 镜像配置最后确认制作镜像即可，稍等片刻即可制作成功。接下来我们可以创建新的主机，在新建主机时选择已经制作好的镜像即可，如图 15-5 所示。图 15-5 新建主机后续配置过程按照提示进行即可。配置完成之后登录新到云主机，即可看到当前主机 Docker 和 Scrapyd 镜像都已经安装好，Scrapyd 服务已经正常运行。我们就通过自定义镜像的方式实现了相同环境的云主机的批量部署。

2. 模板部署

Azure 的云主机在部署时都会使用一个部署模板，这个模板实际上是一个 JSON 文件，里面包含了很多部署时的配置选项，如主机名称、用户名、密码、主机型号等。在模板中我们可以指定新建完云主机之后执行的命令行脚本，如安装 Docker、运行镜像等。等部署工作全部完成之后，新创建的云主机就已经完成环境配置，同时运行相关服务。这里提供一个部署 Linux 主机时自动安装 Docker 和运行 Scrapyd 镜像的模板，模板内容太多，源文件可以查看：https://github.com/Python3WebSpider/ScrapydDeploy/blob/master/azuredeploy.json。模板中 Microsoft.Compute/virtualMachines/extensions 部分有一个 commandToExecute 字段，它可以指定建立主机后自动执行的命令。这里的命令完成的是安装 Docker 并运行 Scrapyd 镜像服务的过程。首先安装一个 Azure 组件，安装过程可以参考：https://docs.azure.cn/zh-cn/xplat-cli-install。之后就可以使用 azure 命令行进行部署。登录 Azure，这里登录的是中国区，命令如下：

1	azure login -e AzureChinaCloud

如果没有资源组的话需要新建一个资源组，命令如下：

1	azure group create myResourceGroup chinanorth

其中 myResourceGroup 就是资源组的名称，可以自行定义。接下来就可以使用该模板进行部署了，命令如下：

1	azure group deployment create --template-file azuredeploy.json myResourceGroup myDeploymentName

这里 myResourceGroup 就是资源组的名称，myDeploymentName 是部署任务的名称。例如，部署一台 Linux 主机的过程如下：

azure group deployment create --template-file azuredeploy.json MyResourceGroup SingleVMDeploy
info:    Executing command group deployment create
info:    Supply values for the following parameters
adminUsername:  datacrawl
adminPassword:  DataCrawl123
vmSize:  Standard_D2_v2
vmName:  datacrawl-vm
dnsLabelPrefix:  datacrawlvm
storageAccountName:  datacrawlstorage

运行命令后会提示输入各个配置参数，如主机用户名、密码等。之后等待整个部署工作完成即可，命令行会自动退出。然后，我们登录云主机即可查看到 Docker 已经成功安装并且 Scrapyd 服务正常运行。

3. 结语

以上内容便是批量部署的两种方法。在大规模分布式爬虫架构中，如果需要批量部署多个爬虫环境，使用如上方法可以快速批量完成环境的搭建工作，而不用再去逐个主机配置环境。到此为止，我们解决了批量部署的问题，创建主机完毕之后即可直接使用 Scrapyd 服务。

作者崔庆才发表于 2019-12-12 阅读次数：本文字数： 2.3k 阅读时长 ≈ 2 分钟

写在最前面：本人也是个算法小白，如果有什么不对还望大佬指正，谢谢

算法设计评价基本标准

算法:

算法的重要特性：

有穷性：

确定性：

可行性：

有输入:

有输出：

算法设计目标：

正确性：

可读性：

健壮性：

时间效率与存储占用量：

算法复杂度

算法的时间复杂度：

算法的空间复杂度：

如何评定一个程序算法的好坏？

探究算法优化（自我一点点小体悟-个人能力有限）

网络爬虫工程师面试小笔记

面试题之一：Python单例模式

什么是Python的单例模式？

如何实现单例模式？

1.基于类：

基于装饰器

使用模块的方法

面试题之二：Redis有几种数据类型？

面试题之三：Scrapy框架的运行流程及各模块的作用

面试题之四：scrapy去重所用的几种机制

引入

框架

功能

使用

算法

说明

待开发功能

MySQL 基本配置

window：

Linux：

管理员密码设置与找回：

MySQL 密码找回：

SSH 配置：

远程库操作

创建远程库地址别名

推送操作：

克隆操作：

团队内协作

邀请成员加入仓库工作团队：

fetch and merge 操作（二者一起使用相当于 pull）

fetch：

merge：将远程库下载的内容与本地库合并

Pull 使用：

pull 冲突处理：

团队外协作：

在编辑前首先介绍以下工作流程

本地库与远程库

团队内部协作：

跨团队协作：

添加提交以及查看状态

添加：将工作区的“新建/修改”添加到暂存区

暂存区删除

查看状态：查看工作区、暂存区状态

提交：将暂存区的内容提交到本地库

查看历史(日志)

实际操作

版本前进与后退：(基于索引值对文件进行前进与后退操作)

实际操作：查看 reflog

给‘项目’版本进行更新：

版本后退：

基于符号的版本控制

reset 命令参数对比：

分支：

分支操作：

// 解决冲突（手动），当不能直接使用 merge 合并时，则需要

Git 使用前许初始化本地库，具体操作如下：

本地库初始化:(命令行：Git Bash Here)

Git 的安装：

各系统的安装(并非唯一方式！)

MacOS：在命令行中输入以下命令即可

Linux：(sudo:以管理员权限运行相关的命令，中间的‘-y’：默认同意安装)

一了解加密与解密：

二造！点击进入本节源码

命令行下，运行虚拟环境直接 Python （Reptile Engineering.py）即可