在本教程中，你将了解如何使用 pathlib 模块操作目录和文件的名称。 学习如何读取和写入文件，拼接路径和操作底层文件系统的新方法，以及如何列出文件并迭代它们的一些示例。 大多人处理文件用的最多的还是 os 模快吧，比如下面这样的操作

1

>>> path.rsplit('\\', maxsplit=1)[0]

或者写出下面这样长长的代码

1

>>> os.path.isfile(os.path.join(os.path.expanduser('~'), 'realpython.txt'))

使用 pathlib 模块，可以使代码使用优雅，可读和 Pythonic 代码重写上面的两个示例，如：

1
2

>>> path.parent
>>> (pathlib.Path.home() / 'realpython.txt').is_file()

Python 文件路径处理问题

由于许多不同的原因，使用文件和与文件系统交互很重要。 最简单的情况可能只涉及读取或写入文件，但有时候会有更复杂的任务。 也许你需要列出给定类型的目录中的所有文件，查找给定文件的父目录，或者创建一个尚不存在的唯一文件名。 一般情况，Python 使用常规文本字符串表示文件路径。 一般在使用 os,glob 和 shutil 等库的时候会使用到路径拼接的操作，使用os模块拼接起来显得略显复杂，以下示例仅需要三个 import 语句来将所有文本文件移动到归档目录：

1
2
3
4
5
6
7

import glob
import os
import shutil

for file_name in glob.glob('*.txt'):
    new_path = os.path.join('archive', file_name)
    shutil.move(file_name, new_path)

使用常规的字符串去拼接路径是可以的，但是由于不同的操作系统使用的分隔符不同，这样就容易出现问题，所以一般我们使用最多的还是使用 os.path.join()。 Python 3.4 中引入了 pathlib 模块（PEP 428）再一次的优化了路径的拼接。使用 pathlib 库的 Path 方法，可以将一个普通的字符串转换为 pathlib.Path 对象类型的路径。 早期，其他软件包仍然使用字符串作为文件路径，但从 Python 3.6 开始，pathlib 模块在整个标准库中得到支持，部分原因是由于增加了文件系统路径协议。 如果你坚持使用传统的 Python，那么 Python 2 也有一个可用的向后移植。 ok，说了那么多下面让我们看看 pathlib 如何在实践中发挥作用。

创建路径

这里我们首先要知道两个用法，先看代码:

1

from pathlib import Path

你真正需要知道的是 pathlib.Path 类。 创建路径有几种不同的方式。 首先，有类方法，如 .cwd（当前工作目录）和 .home（用户的主目录）：

1
2
3
4
5
6
7

from pathlib import Path

now_path = Path.cwd()
home_path = Path.home()

print("当前工作目录",now_path,type(now_path))
print("home目录",home_path,type(home_path))

输出内容

1
2

当前工作目录 /Users/chennan/pythonproject/demo <class 'pathlib.PosixPath'>
home目录 /Users/chennan <class 'pathlib.PosixPath'>

可以发现路径格式为 pathlib.PosixPath 这是在 unix 系统下的显示。在不同的系统上显示的格式也是不一样，在 windows 系统会显示为 WindowsPath。但是不管什么显示类型，都不影响后面的操作。 前面我们提到过可以通过把字符串类型的路径，转换为 Pathlib.Path 类型的路径，经过测试发现在 Python3.4 以后很多模块以及支持该格式的路径。不用转为成字符串使用了。比起 os.path.join 拼接路径的方式, pathlib 使用起来更加的方便,使用示例如下:

1
2
3

import pathlib
DIR_PATH = pathlib.Path("/Users/chennan/CDM")
print(DIR_PATH,type(DIR_PATH))

输出内容:

1

/Users/chennan/CDM <class 'pathlib.PosixPath'>

通过 “/“ 我们就可以对路径进行拼接了，怎么样是不是很方便呢。

读文件和写文件

在我们使用 open 来操作文件读写操作的时候,不仅可以使用字符串格式的路径，对于 pathlib 生成的路径完全可以直接使用:

1
2
3
4

path = pathlib.Path.cwd() / 'test.md'
with open(path, mode='r') as fid:
    headers = [line.strip() for line in fid if line.startswith('#')]
print('\n'.join(headers))

或者在 pathlib 的基础使用 open,我们推荐使用下面的方式

1
2
3
4
5

import pathlib
DIR_PATH = pathlib.Path("/Users/chennan/CDM") / "2000" / "hehe.txt"
with DIR_PATH.open("r") as fs:
     data = fs.read() 
print(data)

这样写的好处就是 open 里面我们不需要再去传入路径了，直接指定文件读写模式即可。实际上这里的 open 方法，底层也是调用了 os.open 的方法。使用哪种方式看个人的喜好。 pathlib 还提供几种文件的读写方式: 可以不用再使用 with open 的形式即可以进行读写。

1
2
3
4

.read_text(): 找到对应的路径然后打开文件，读成str格式。等同open操作文件的"r"格式。
.read_bytes(): 读取字节流的方式。等同open操作文件的"rb"格式。
.write_text(): 文件的写的操作，等同open操作文件的"w"格式。
.write_bytes(): 文件的写的操作，等同open操作文件的"wb"格式。

使用 resolve 可以通过传入文件名，来返回文件的完整路径，使用方式如下

1
2
3

import pathlib
py_path =pathlib.Path("superdemo.py")
print(py_path.resolve())

输出

1

/Users/chennan/pythonproject/demo/superdemo.py

需要注意的是 “superdemo.py” 文件要和我当前的程序文件在同一级目录。

选择路径的不同组成部分

pathlib 还提供了很多路径操作的属性，这些属性可以选择路径的不用部位，如 .name: 可以获取文件的名字，包含拓展名。 .parent: 返回上级文件夹的名字 .stem: 获取文件名不包含拓展名 .suffix: 获取文件的拓展名 .anchor: 类似盘符的一个东西,

1
2
3
4
5
6
7
8

import pathlib

now_path = pathlib.Path.cwd() / "demo.txt"
print("name",now_path.name)
print("stem",now_path.stem)
print("suffix",now_path.suffix)
print("parent",now_path.parent)
print("anchor",now_path.anchor)

输出内容如下

1
2
3
4
5

name demo.txt
stem demo
suffix .txt
parent /Users/chennan/pythonproject/demo
anchor /

移动和删除文件

当然 pathlib 还可以支持文件其他操作，像移动，更新，甚至删除文件，但是使用这些方法的时候要小心因为，使用过程不用有任何的错误提示即使文件不存在也不会出现等待的情况。 使用 replace 方法可以移动文件，如果文件存在则会覆盖。为避免文件可能被覆盖，最简单的方法是在替换之前测试目标是否存在。

1
2
3
4
5
6

import pathlib

destination = pathlib.Path.cwd() / "target" 
source = pathlib.Path.cwd() / "demo.txt"
if not destination.exists():
    source.replace(destination)

但是上面的方法存在问题就是，在多个进程多 destination 进行的操作的时候就会现问题，可以使用下面的方法避免这个问题。也就是说上面的方法适合单个文件的操作。

1
2
3
4
5
6
7

import pathlib

destination = pathlib.Path.cwd() / "target" 
source = pathlib.Path.cwd() / "demo.txt"
with destination.open(mode='xb') as fid: 
    #xb表示文件不存在才操作
    fid.write(source.read_bytes())

当 destination文件存在的时候上面的代码就会出现 FileExistsError 异常。 从技术上讲，这会复制一个文件。 要执行移动，只需在复制完成后删除源即可。 使用 with_name 和 with.shuffix 可以修改文件名字或者后缀。

1
2
3

import pathlib
source = pathlib.Path.cwd() / "demo.py"
source.replace(source.with_suffix(".txt")) #修改后缀并移动文件，即重命名

可以使用 .rmdir() 和 .unlink() 来删除文件。

1
2
3
4
5

import pathlib

destination = pathlib.Path.cwd() / "target" 
source = pathlib.Path.cwd() / "demo.txt"
source.unlink()

几个 pathlib 的使用例子

统计文件个数

我们可以使用.iterdir方法获取当前文件下的所以文件.

1
2
3
4
5

import pathlib
from collections import Counter
now_path = pathlib.Path.cwd()
gen = (i.suffix for i in now_path.iterdir())
print(Counter(gen))

输出内容

1

Counter({'.py': 16, '': 11, '.txt': 1, '.png': 1, '.csv': 1})

通过配合使用 collections 模块的 Counter 方法，我们获取了当文件夹下文件类型情况。 前面我们说过 glob 模块点这里了解【https://www.cnblogs.com/c-x-a/p/9261832.html】，同样的 pathlib 也有 glob 方法和 rglob 方法，不同的是 glob 模块里的 glob 方法结果是列表形式的，iglob 是生成器类型，在这里 pathlib 的 glob 模块返回的是生成器类型，然后 pathlib 还有一个支持递归操作的 rglob 方法。 下面的这个操作我通过使用 glob 方法，设定规则进行文件的匹配。

1
2
3
4

import pathlib
from  collections import Counter
gen =(p.suffix for p in pathlib.Path.cwd().glob('*.py'))
print(Counter(gen))

展示目录树

下一个示例定义了一个函数 tree()，该函数的作用是打印一个表示文件层次结构的可视树，该树以一个给定目录为根。因为想列出其子目录，所以我们要使用 .rglob() 方法：

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

import pathlib
from  collections import Counter
def tree(directory):
    print(f'+ {directory}')
    for path in sorted(directory.rglob('*')):
        depth = len(path.relative_to(directory).parts)
        spacer = '    ' * depth
        print(f'{spacer}+ {path.name}')

now_path = pathlib.Path.cwd()

if __name__ == '__main__':
    tree(now_path)

其中 relative_to 的方法的作用是返回 path 相对于 directory 的路径。 parts 方法可以返回路径的各部分。例如

1
2
3
4

import pathlib
now_path = pathlib.Path.cwd()
if __name__ == '__main__':
    print(now_path.parts)

返回

1

('/', 'Users', 'chennan', 'pythonproject', 'demo')

获取文件最后一次修改时间

iterdir(),.glob()和.rglob()方法非常适合于生成器表达式和列表理解。 使用stat()方法可以获取文件的一些基本信息，使用.stat().st_mtime可以获取文件最后一次修改的信息

1
2
3
4
5

import pathlib
now_path = pathlib.Path.cwd()
from datetime import datetime
time, file_path = max((f.stat().st_mtime, f) for f in now_path.iterdir())
print(datetime.fromtimestamp(time), file_path)

甚至可以使用类似的表达式获取上次修改的文件内容

1
2
3
4
5

import pathlib
from datetime import datetime
now_path =pathlib.Path.cwd()
result = max((f.stat().st_mtime, f) for f in now_path.iterdir())[1]
print(result.read_text())

.stat().st_mtime 会返回文件的时间戳，可以使用 datetime 或者 time 模块对时间格式进行进一步转换。

其他内容

关于 pathlib.Path 格式路径转换为字符串类型

因为通过 pathlib 模块操作生成的路径，不能直接应用字符串的一些操作，所以需要转换成字符串，虽然可以使用 str() 函数进行转换，但是安全性不高，建议使用 os.fspath() 方法，因为如果路径格式非法的，可以抛出一个异常。str()就不能做到这一点。

拼接符号”/“背后的秘密

/ 运算符由 truediv 方法定义。 实际上，如果你看一下 pathlib 的源代码，你会看到类似的东西。

1
2
3
4

class PurePath(object):

    def __truediv__(self, key):
        return self._make_child((key,))

后记

从 Python 3.4 开始，pathlib 已在标准库中提供。 使用 pathlib，文件路径可以由适当的 Path 对象表示，而不是像以前一样用纯字符串表示。 这些对象使代码处理文件路径：

• 更容易阅读，特别是可以使用“/”将路径连接在一起
• 更强大，直接在对象上提供最必要的方法和属性
• 在操作系统中更加一致，因为Path对象隐藏了不同系统的特性

在本教程中，你已经了解了如何创建 Path 对象、读取和写入文件、操作路径和底层文件系统，以及如何遍历多个文件路径等一系列实例。 最后，建议下去自己多加练习，我对文章中的代码都进行了验证，不会出现运行错误的情况。 ————————————————————————————————————————————— 原文: https://realpython.com/python-pathlib/ 译者: 陈祥安 [gallery ids=”6600”] 更多精彩内容，请关注微信公众号: python学习开发。

想写这篇文章很久了，也想做这件事很久了，我个人感觉自己是有强迫症的，所以一直有什么事让我看着不太舒服就想把它纠正过来。 文字，也不例外。 现在大家看各种新闻啊、文章啊，几乎每篇文章都会有点数字和英文的吧，比如就拿 Python 来说，看下面两句话：

• 卧槽 Python 真牛逼啊排名第 1 了。
• 卧槽 Python 真牛逼啊排名第 1 了。

Python 是不是第一先不说，就看看上面两句话的排版，哪个看起来更舒服？说实话我是真觉得第一句话太别扭了。因为我们大部分的文本编辑器和浏览器是没有对中文和外文的混排做排版优化的，所以如果写的时候如果二者之间不加个空格，二者就会紧紧贴在一起，然后就变成了上面第一句的样子。 当然如果你觉得第一句的排版更好看，好吧，那么本文后面的内容其实可以不必看了。OK，如果你觉得第二个好看，那不妨接着看下去哈。

出发点

首先有一点需要明确的是，中英文排版的美学是在于 Readability，易读性。而为了易读性，中英文之间是需要留有”间距”的，注意这里是间距，不是说的”空格”。”空格”会造成间距，但是间距不一定非得需要”空格”。 好，所以，其实我们只需要留有适当的间距，就会显得美观易读，这个间距大约是一个半角空格的距离。 好明确了这一点，我们只要能留有间距，不一定非得加空格。 现在很多专业的排版软件，比如 Adobe InDesign、Microsoft Word 对中英文混排支持非常好，他们会有这么一个功能：可以设置中文西文之间留适当的间距。 所以，如果如果我们使用了这些软件，本身就可以做到 Readability，这就够了。 但是，为什么还会说空格的问题呢？这是因为现在绝大多数软件，不管是文本编辑器还是网页，都没有这个机制。 几乎所有的文本编辑器和浏览器中，只要我们中文和英文连续输入，它们之间是不会出现间距的，就像文章开头所示的样例中的第一句话，显得很别扭。但比如 Adobe InDesign、Microsoft Word、IE 浏览器会有这方面的支持。 所以，怎么解决？手动加空格。 因此，总结下：

• 间距要有，但不一定是空格。
• 部分软件能自动呈现间距，那就不必加空格。
• 绝大多数软件不能自动呈现间距，那就需要手动加空格。

所以，作为强迫症的我，一定是会为了这个间距而去敲下一个空格的。 「有研究显示，打字的时候不喜欢在中文和英文之间加空格的人，感情路都走得很辛苦，有七成的比例会在 34 岁的时候跟自己不爱的人结婚，而其余三成的人最后只能把遗产留给自己的猫。毕竟爱情跟书写都需要适时地留白。与大家共勉之。」 所以，求求你加个空格吧（逃。

规范

好，下面就说到规范的问题了，到底什么时候应该加空格什么时候不加，这也是有讲究的。下面的内容摘自 GitHub 上的一个中英文混排规范，网址为：https://github.com/mzlogin/chinese-copywriting-guidelines，下面转述一下。

1. 中英文之间需要增加空格

中英文之间是需要添加空格的，不论是普通英文还是引用的英文，下面给个示例： 正确：

• 在 LeanCloud 上，数据存储是围绕 AVObject 进行的。

错误：

• 在 LeanCloud 上，数据存储是围绕AVObject进行的。
• 在 LeanCloud 上，数据存储是围绕AVObject 进行的。

完整的正确用法：

• 在 LeanCloud 上，数据存储是围绕 AVObject 进行的。每个 AVObject 都包含了与 JSON 兼容的 key-value 对应的数据。数据是 schema-free 的，你不需要在每个 AVObject 上提前指定存在哪些键，只要直接设定对应的 key-value 即可。

但有例外，比如「豆瓣 FM」等产品名词，按照官方所定义的格式书写。 再比如，我的公众号为「进击的 Coder」，那么这里面就不要加空格，按照其本身的形式书写即可。

中文与数字之间需要增加空格

中文和数字之间也是需要的，下面给个示例： 正确：

• 今天出去买菜花了 5000 元。

错误：

• 今天出去买菜花了 5000 元。
• 今天出去买菜花了 5000 元。

数字与单位之间无需增加空格

但是数字和单位之间不需要再加额外的空格了，下面给个 正确：

• 我家的光纤入户宽带有 10Gbps，SSD 一共有 10TB。

错误：

• 我家的光纤入户宽带有 10 Gbps，SSD 一共有 20 TB。

另外，度／百分比与数字之间不需要增加空格： 正确：

• 今天是 233° 的高温。
• 新 MacBook Pro 有 15% 的 CPU 性能提升。

错误：

• 今天是 233 ° 的高温。
• 新 MacBook Pro 有 15 % 的 CPU 性能提升。

全角标点与其他字符之间不加空格

标点是分全角和半角的，全角标点一般是在中文状态下输出来的，比如 ，、。、！，半角标点一般是在英文状态下输出来的，比如 ,、.、!，两个看起来不一样吧？所以，如果是中文标点，即全角标点，那不需要加空格。 正确：

• 刚刚买了一部 iPhone，好开心！

错误：

• 刚刚买了一部 iPhone ，好开心！

嗯，基本就是以上的几个规范，只要明白了这些规范，中英文混排就 OK 了！

网页

有人说，我就是不想打空格，在网页中，我能像 Microsoft Word 一样不打空格而直接显示间距吗？ 也就是说，我能不能设置一个 CSS 样式，就能使得中英文之间自动留有间距呢？ 其实，只有 IE 有这样的支持。这个 CSS 样式叫做 \-ms-text-autospace ，可以在这里了解下：https://msdn.microsoft.com/library/ms531164(v=vs.85).aspx.aspx>)。 但是很遗憾的是，几乎所有其他的浏览器都不支持这个，Chrome、Firefox 统统都不支持这个特性。放弃吧。 这里提供一些手动的解决方案，比如使用 JavaScript 添加标记，然后 CSS 控制标记的间距，解决方案可以参考：http://mastermay.github.io/text-autospace.js/。

编辑器

那么有编辑器支持这个吗？有，Microsoft Word，用它我们不用加空格，会自动给我们加好间距。 有人说，我平时不想用 Word，我就想用 Markdown，有编辑器吗？有，叫做 MarkEditor，它的 2.0 Pro 版本可以在打字的时候自动给我们添加空格。注意，这里是自动添加空格，不是自动留间距，是用空格的方式实现了间距。但是这个只能在你一个个打字的时候自动添加空格，如果把一个不带空格的话粘贴进去是不行的。另外 MarkEditor 解锁这个功能需要付费，所以我个人感觉其实不太划算的。 所以，平时还是自己手动加空格吧，经济实惠方便。 其他的编辑器如有好用的欢迎大家推荐哈。

类库

好吧，看到现在，你是不是现在都想把自己的中英文笔记加上空格了？难道要手调吗？不需要。 有现成的工具了，名字叫做 pangu，它支持各种语言，另外还有浏览器插件可以用，列表如下：

浏览器插件

• Google Chrome
• Mozilla Firefox

开发工具包

• Official supports:
  • pangu.go (Go)
  • pangu.java (Java)
  • pangu.js (JavaScript)
  • pangu.py (Python)
  • pangu.space (Web API)
• Community supports:
  • pangu.clj (Clojure)
  • pangu.dart (Dart)
  • pangu.ex (Elixir)
  • pangu.objective-c (Objective-C)
  • pangu.php (PHP)
  • pangu.rb (Ruby)
  • pangu.rs (Rust)
  • pangu.swift (Swift)

比如 Python 的话，就可以使用 pangu.py 这个包，GitHub 地址为：https://github.com/vinta/pangu.py，安装方式如下：

1

pip3 install -U pangu

这么用就好了：

1
2

import pangu
print(pangu.spacing_text('當你凝視著bug，bug也凝視著你'))

运行结果如下：

1

當你凝視著 bug，bug 也凝視著你

嗯，它自动给我们添加好了空格，非常不错。 不过这有点费劲，有简单一点的工具吗？ 有，我为此专门做了一个网页，功能很简单。 在左侧输入源文本，右侧就会显示添加空格之后的文本，页面如下： 这个是我用 Vue.js 开发的，实际上就是用了 pangu.js 这个库实现的，原理非常简单，主要目的就是为了方便空格排版。 另外这个网站我也部署了一下，叫做：http://space.cuiqingcai.com/，大家以后也可以直接访问使用，以后我有想调整的文本，直接就用它了。 如果大家想获取源码，可以在公众号「进击的 Coder」回复”空格”。 希望对大家有所帮助。 最后，为了世界的美好与和平，加个空格吧！

最近碰到了一个问题，项目中很多文件都是接手过来的中文命名的一些素材，结果在部署的时候文件名全都乱码了，导致项目无法正常运行。 后来请教了一位大佬怎么解决文件名乱码的问题，他说这个需要正面解决吗？不需要，把文件名全部改掉，文件名永远不要用中文，永远不要。 我想他这么说的话，一定也是凭经验得出来的。 这里也友情提示大家，项目里面文件永远不要用中文，永远不要！ 好，那不用中文用啥？平时来看，一般我们都会用英文来命名，一般也不会出现中文，比如 resource, controller, result, view, spider 等等，所以绝大多数情况下，是不会出现什么问题的。但是也有个别的情况，比如一些素材、资源文件可能的中文命名的，那么这时候该咋办呢？ 首先像，因为是中文资源文件，我们要改成非中文命名的，无非两种，一种是英文，一种是拼音。 如果改英文，当然可以翻译、我们想翻译的话，逐个人工翻译成本太高，机器翻译的话，翻译完可能有些文不对题了，而且我们自己也不知道一些奇怪的资源英语应该叫什么，所以到时候真的找起来都找不到了。 所以第二种解决方案，那就是拼音了。中文转拼音，很自然，而且一个字就对应一串拼音，而且也非常容易从拼音看懂是什么意思，所以这确实是一个不错的方案。 那么问题就来了，怎样把一批中文文件转拼音命名呢？下面就让我们来了解 Python 的一个库 PyPinyin 吧！

概述

Python 中提供了汉字转拼音的库，名字叫做 PyPinyin，可以用于汉字注音、排序、检索等等场合，是基于 hotto/pinyin 这个库开发的，一些站点链接如下：

• GitHub: https://github.com/mozillazg/python-pinyin
• 文档：https://pypinyin.readthedocs.io/zh_CN/master/
• PyPi：https://pypi.org/project/pypinyin/

它有这么几个特性：

• 根据词组智能匹配最正确的拼音。
• 支持多音字。
• 简单的繁体支持, 注音支持。
• 支持多种不同拼音/注音风格。

是不是等不及了呢？那就让我们来了解一下它的用法吧！

安装

首先就是这个库的安装了，通过 pip 安装即可：

1

pip3 install pypinyin

安装完成之后导入一下这个库，如果不报错，那就说明安装成功了。

1

\>>> import pypinyin

好，接下来我们看下它的具体功能。

基本拼音

首先我们进行一下基本的拼音转换，方法非常简单，直接调用 pinyin 方法即可：

1
2

from pypinyin import pinyin
print(pinyin('中心'))

运行结果：

1

[['zhōng'], ['xīn']]

可以看到结果会是一个二维的列表，每个元素都另外成了一个列表，其中包含了每个字的读音。 那么如果这个词是多音字咋办呢？比如 “朝阳”，它有两个读音，我们拿来试下：

1
2

from pypinyin import pinyin
print(pinyin('朝阳'))

运行结果：

1

[['zhāo'], ['yáng']]

好吧，它只给出来了一个读音，但是如果我们想要另外一种读音咋办呢？ 其实很简单，只需添加 heteronym 参数并设置为 True 就好了，我们试下：

1
2

from pypinyin import pinyin
print(pinyin('朝阳', heteronym=True))

运行结果：

1

[['zhāo', 'cháo'], ['yáng']]

OK 了，这下子就显示出来了两个读音了，而且我们也明白了结果为什么是一个二维列表，因为里面的一维的结果可能是多个，比如多音字的情况就是这样。 但这个多少解析起来有点麻烦，很多情况下我们是不需要管多音字的，我们只是用它来转换一下名字而已，而处理上面的二维数组又比较麻烦。 所以有没有一个方法直接给我们一个一维列表呢？有！ 我们可以使用 lazy_pinyin 这个方法来生成，尝试一下：

1
2

from pypinyin import lazy_pinyin
print(lazy_pinyin('聪明的小兔子'))

运行结果：

1

['cong', 'ming', 'de', 'xiao', 'tu', 'zi']

这时候观察到得到的是一个列表，并且不再包含音调了。 这里我们就有一个疑问了，为啥 pinyin 方法返回的结果默认是带音调的，而 lazy_pinyin 是不带的，这里面就涉及到一个风格转换的问题了。

风格转换

我们可以对结果进行一些风格转换，比如不带声调风格、标准声调风格、声调在拼音之后、声调在韵母之后、注音风格等等，比如我们想要声调放在拼音后面，可以这么来实现：

1
2
3
4

from pypinyin import lazy_pinyin, Style

style = Style.TONE3
print(lazy_pinyin('聪明的小兔子', style=style))

运行结果：

1

['cong1', 'ming2', 'de', 'xiao3', 'tu4', 'zi']

可以看到运行结果每个拼音后面就多了一个声调，这就是其中的一个风格，叫做 TONE3，其实还有很多风格，下面是我从源码里面找出来的定义：

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

#: 普通风格，不带声调。如： 中国 -> ``zhong guo``
NORMAL = 0
#: 标准声调风格，拼音声调在韵母第一个字母上（默认风格）。如： 中国 -> ``zhōng guó``
TONE = 1
#: 声调风格2，即拼音声调在各个韵母之后，用数字 [1-4] 进行表示。如： 中国 -> ``zho1ng guo2``
TONE2 = 2
#: 声调风格3，即拼音声调在各个拼音之后，用数字 [1-4] 进行表示。如： 中国 -> ``zhong1 guo2``
TONE3 = 8
#: 声母风格，只返回各个拼音的声母部分（注：有的拼音没有声母，详见 `#27`_）。如： 中国 -> ``zh g``
INITIALS = 3
#: 首字母风格，只返回拼音的首字母部分。如： 中国 -> ``z g``
FIRST_LETTER = 4
#: 韵母风格，只返回各个拼音的韵母部分，不带声调。如： 中国 -> ``ong uo``
FINALS = 5
#: 标准韵母风格，带声调，声调在韵母第一个字母上。如：中国 -> ``ōng uó``
FINALS_TONE = 6
#: 韵母风格2，带声调，声调在各个韵母之后，用数字 [1-4] 进行表示。如： 中国 -> ``o1ng uo2``
FINALS_TONE2 = 7
#: 韵母风格3，带声调，声调在各个拼音之后，用数字 [1-4] 进行表示。如： 中国 -> ``ong1 uo2``
FINALS_TONE3 = 9
#: 注音风格，带声调，阴平（第一声）不标。如： 中国 -> ``ㄓㄨㄥ ㄍㄨㄛˊ``
BOPOMOFO = 10
#: 注音风格，仅首字母。如： 中国 -> ``ㄓ ㄍ``
BOPOMOFO_FIRST = 11
#: 汉语拼音与俄语字母对照风格，声调在各个拼音之后，用数字 [1-4] 进行表示。如： 中国 -> ``чжун1 го2``
CYRILLIC = 12
#: 汉语拼音与俄语字母对照风格，仅首字母。如： 中国 -> ``ч г``
CYRILLIC_FIRST = 13

有了这些，我们就可以轻松地实现风格转换了。 好，再回到原来的问题，为什么 pinyin 的方法默认带声调，而 lazy_pinyin 方法不带声调，答案就是：它们二者使用的默认风格不同，我们看下它的函数定义就知道了： pinyin 方法的定义如下：

1

def pinyin(hans, style=Style.TONE, heteronym=False, errors='default', strict=True)

lazy_pinyin 方法的定义如下：

1

def lazy_pinyin(hans, style=Style.NORMAL, errors='default', strict=True)

这下懂了吧，因为 pinyin 方法默认使用了 TONE 的风格，而 lazy_pinyin 方法默认使用了 NORMAL 的风格，所以就导致二者返回风格不同了。 好了，有了这两个函数的定义，我们再来研究下其他的参数，比如定义里面的 errors 和 strict 参数又怎么用呢？

错误处理

在这里我们先做一个测试，比如我们传入无法转拼音的字，比如：

1
2

from pypinyin import lazy_pinyin
print(lazy_pinyin('你好☆☆，我是xxx'))

其中包含了星号两个，还有标点一个，另外还包含了一个 xxx 英文字符，结果会是什么呢？

1

['ni', 'hao', '☆☆，', 'wo', 'shi', 'xxx']

可以看到结果中星号和英文字符都作为一个整体并原模原样返回了。 那么这种特殊字符可以单独进行处理吗？当然可以，这里就用到刚才提到的 errors 参数了。 errors 参数是有几种模式的：

• default：默认行为，不处理，原木原样返回
• ignore：忽略字符，直接抛掉
• replace：直接替换为去掉 u 的 unicode 编码
• callable 对象：当传入一个可调用的对象的时候，则可以自定义处理方式。

下面是 errors 这个参数的源码实现逻辑：

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

def _handle_nopinyin_char(chars, errors='default'):
    """处理没有拼音的字符"""
    if callable_check(errors):
        return errors(chars)

    if errors == 'default':
        return chars
    elif errors == 'ignore':
        return None
    elif errors == 'replace':
        if len(chars) > 1:
            return ''.join(text_type('%x' % ord(x)) for x in chars)
        else:
            return text_type('%x' % ord(chars))

当处理没有拼音的字符的时候，errors 的不同参数会有不同的处理结果，更详细的逻辑可以翻看源码。 好了，下面我们来尝试一下，比如我们想将不能转拼音的字符去掉，则可以这么设置：

1
2

from pypinyin import lazy_pinyin
print(lazy_pinyin('你好☆☆，我是xxx', errors='ignore'))

运行结果：

1

['ni', 'hao', 'wo', 'shi']

如果我们想要自定义处理，比如把 ☆ 转化为 ※，则可以这么设置：

1

print(lazy_pinyin('你好☆☆，我是xxx', errors=lambda item: ''.join(['※' if c == '☆' else c for c in item])))

运行结果：

1

['ni', 'hao', '※※，', 'wo', 'shi', 'xxx']

如上便是一些相关异常处理的操作，我们可以随心所欲地处理自己想处理的字符了。

严格模式

最后再看下 strict 模式，这个参数用于控制处理声母和韵母时是否严格遵循 《汉语拼音方案》 标准。 下面的一些说明来源于官方文档： 当 strict 参数为 True 时根据 《汉语拼音方案》 的如下规则处理声母、在韵母相关风格下还原正确的韵母：

• 21 个声母： b p m f d t n l g k h j q x zh ch sh r z c s （y, w 不是声母）
• i行的韵母，前面没有声母的时候，写成yi(衣)，ya(呀)，ye(耶)，yao(腰)，you(忧)，yan(烟)， yin(因)，yang(央)，ying(英)，yong(雍)。（y 不是声母）
• u行的韵母，前面没有声母的时候，写成wu(乌)，wa(蛙)，wo(窝)，wai(歪)，wei(威)，wan(弯)， wen(温)，wang(汪)，weng(翁)。（w 不是声母）
• ü行的韵母，前面没有声母的时候，写成yu(迂)，yue(约)，yuan(冤)，yun(晕)；ü上两点省略。 （韵母相关风格下还原正确的韵母 ü）
• ü行的韵跟声母j，q，x拼的时候，写成ju(居)，qu(区)，xu(虚)，ü上两点也省略； 但是跟声母n，l拼的时候，仍然写成nü(女)，lü(吕)。（韵母相关风格下还原正确的韵母 ü）
• iou，uei，uen前面加声母的时候，写成iu，ui，un。例如niu(牛)，gui(归)，lun(论)。 （韵母相关风格下还原正确的韵母 iou，uei，uen）

当 strict 为 False 时就是不遵守上面的规则来处理声母和韵母， 比如：y, w 会被当做声母，yu(迂) 的韵母就是一般认为的 u 等。 具体差异可以查看源码中 tests/test_standard.py 中的对比结果测试用例。

自定义拼音

如果对库返回的结果不满意，我们还可以自定义自己的拼音库，这里用到的方法就有 load_single_dict 和 load_phrases_dict 方法了。 比如刚才我们看到 “朝阳” 两个字的发音默认返回的是 zhao yang，我们想默认返回 chao yang，那可以这么做：

1
2
3
4
5
6
7
8

from pypinyin import lazy_pinyin, load_phrases_dict

print(lazy_pinyin('朝阳'))
personalized_dict = {
    '朝阳': [['cháo'], ['yáng']]
}
load_phrases_dict(personalized_dict)
print(lazy_pinyin('朝阳'))

这里我们自定义了一个词典，然后使用 load_phrases_dict 方法设置了一下就可以了。 运行结果：

1
2

['zhao', 'yang']
['chao', 'yang']

这样就可以完成自定义的设置了。 在一些项目里面我们可以自定义很多拼音库，然后加载就可以了。 另外我们还可以注册样式实现自定义，比如将某个拼音前面加上 Emoji 表情，样例：

1
2
3
4
5
6
7
8
9
10

from pypinyin.style import register
from pypinyin import lazy_pinyin

@register('kiss')
def kiss(pinyin, **kwargs):
    if pinyin == 'me':
        return f'?{pinyin}'
    return pinyin

print(lazy_pinyin('么么哒', style='kiss'))

运行结果：

1

['?me', '?me', 'dá']

这里我们调用 register 方法注册了一个样式 style，然后转换的时候指定即可，通过观察运行结果我们可以发现，这样我们就可以将 me 字的拼音前面加上 ? 这个 Emoji 表情了。 以上就是 PyPinyin 这个库的基本用法，更多的用法建议大家看看源码或者看 API 文档：https://pypinyin.readthedocs.io/zh_CN/master/api.html。

正式入职微软，提交了第一个 PR 之后，我坐在椅子上思考人生。终于我也变成了一名正式的企业员工，变成了一名正式的踏入社会的职业人士，从此我的学生生涯也算是画上了一个句号，不，更确切的说应该是画上了一个引号。 和同事租了房子，生活条件算是还不错，有了属于自己的房间，有了专属自己的衣柜、书橱、办公桌，想要的硬件、软件、日常用品想配就配，算是应有尽有了。首先日常生活上最大的感受就是自己的生活条件变得更好、更自由，不再像学校一样有各种限制了，虽然日常花销变多了，但总体上来说我更喜欢现在的生活环境。

回顾

先回想一下自己的学生生活吧，初高中就不说了，就天天上课为了高考，后来在大学基本上就是三点一线，宿舍——食堂——教室/实验室，然后读研，研究生模式也差不多，宿舍——食堂——实验室/公司。

编程入门

我大学的时候选的就是计算机科学与技术这个专业，当时学校开的第一门入门课就是 Java，当时可以说是对编程一窍不通，什么 print？打印机吗？控制台是什么？控制谁？什么面向对象？我对象在哪里？都是些什么玩意。就这样，随着老师的课堂洗脑和一些并不怎么感兴趣的编程作业，我慢慢理解了原来 print 是这么个玩意，对象原来不是那个对象，就慢慢对编程建立了一个概念。插句话，其实我感觉编程的一些概念和思维还是很重要的，有人说编程学不会，可能就是脑中没有形成一个比较清晰的概念，想清楚它能做到什么，怎样从用双手解决一件事的思维转换成用编程解决一件事的思维。 扯远了，但那时候仅仅 Java 是一门课而已，虽然最后考试考得还不错，但是还是不是很懂它能为我带来些什么东西。后来大学就开了一个叫做课程设计的课，意思就是说让自己动手编程实现一个可以操作的项目。我们当时学校要求的就是实现一个黑白棋在线对战系统，当时可把我为难坏了。后来了解到了这里面还挺复杂的，又得编写界面又得搞一些算法，还得搞一个在线 WebSocket 通信，当时可以说是毫无思路，然后就去网上搜一些 Java 的教程，当时是搜到了马士兵的 Java 课就顺着看了起来，可以说马士兵是我的 Java 最重要的启蒙老师了，慢慢地把一些原理和基础学会了之后就有了基本的编程思路了，开始上手编，做界面，做服务器等等。另外还有一些小插曲，有的界面还得抠图，当时为了打造一个完美的棋盘效果还学了 PS 来花了一个木质棋盘和黑白棋子，估计得花了好几个月的时间终于做出来了一个像样点的系统，虽然现在源码已经找不到了，但真的说这个课程设计真的让我理解了编程的一些思维和理念以及它能为我带来些什么，我能够用它做到什么，脑中的一些概念变得更加清晰了，收获非常大。 后来学校开了数据结构和算法的一些课，慢慢地我又对一些基础的算法和 C++ 的一些编程语言有了一定的了解。再后来就是一些基础专业课了，比如操作系统，计算机组成原理，计算机网络等等，总体来说其实我没太感觉出具体有多大作用，但你要假设我没学过，我可能有很多东西都不知其理。人就是这样，有些东西在拥有的时候觉不出有什么好的，但一旦没有才会有明显的感觉。

加实验室

好吧又扯远了，然后就可以说迈入了我人生中一个比较重要的点了，那就是加入学校的一个实验室。之前许多东西我和室友自己瞎倒腾，比如当时进行版本控制的话，就是自己手动压缩一下，命名项目的时候添加一个版本号并用下划线分割，后来进了实验室才知道还有 Git 这么牛逼的东西，于是乎就跟着学习了 Git，了解了 GitHub，觉得整个代码世界都光明了。当时我加入的是后台组，一开始是从 PHP 开始学起的，从原生的 PHP，到普通的 CodeIgniter 框架，到高级的 Laravel 框架，当时写的时候主要用是 MVC 模式，所以前端的东西也难免需要用到的，所以那会儿又学习了前端的一些知识，慢慢地就变成了 Web 前后端通吃，自己也可以逐渐完成一些大型项目的开发工作。当时还自己开通了博客来记录自己学习的一些经验，然后跟着实验室一起接外包做外包，做了不下十个门户及商业网站的开发。

学习爬虫

再往后可能就是临近大学毕业的时候了，那会儿实验室的一位学长写了一些爬虫的入门文章，当时也跟着学了起来，边学边记录，学的整理的一些知识点都放在了自己的博客上。后来又探索了一些新的爬取方案，也一并整理到博客上了，形成了一个入门到进阶的一套简易版教程，后来随着写的越来越多，来看的人也越来越多了，后来访问量也逐渐上来了，现在的话日均访问量可以达到 15000+。 再往后可能就差不多大学毕业了，当时由于是保研到北航的，所以就提前来到了北京开始了研究生的预备工作，也节省了不少时间。那会儿就有充足的时间来做自己的事情，比如学习一些网络课程，继续做一些关于爬虫的研究工作。当时随着我的博客访问量越来越大，图灵便联系我看能不能写一本关于爬虫的书，当时想的一个是可以把自己学习的知识好好整理一下，还可以作为自己的一部个人作品出版出来，的确是一件非常不错的事情，所以当时就答应下来了。不得不说写书的过程是非常艰辛的，舍去了好多平时的休息时间，同时还发现了自己的很多不足的地方去查漏补缺，最终也不得不延期了好几个月才交上稿。后来又审校了非常久的时间，到去年五月份才出版出来，定名字叫《Python3网络爬虫开发实战》。不过后来的销量还算不错，现在已经重印了 10 次，50000 本了。现在还在继续撰写第二版中，把一些过期的案例和知识点更新，再把一些新的技术加进去。

研究生生活

OK，当然研究生阶段也不是都写书了。研究生阶段其实一开始是比较迷茫的，其实当时并不知道自己毕业之后要做什么方面的工作以及想去哪里。最初读的时候是选了网络安全的方向，做一些 Web 渗透方面的研究，后来觉得研究得差不多了，就又转了自然语言处理的方向，从吴恩达的机器学习开始学起，然后了解了深度学习的一些模型，又了解了自然语言处理的一些知识。与此同时，我也在微软这边当实习生，从最初的爬虫、 Platform 再到 Science NLP 研究，慢慢地也认识了一些大佬，和他们一起交流的确让我学习到了不少。 由于我在微软这边实习时间不短，所以当时也参加了实习生转正的面试。微软整个的面试流程还是很规范和严格的，包括多面技术面，另外每一面的要求也都不低的。首先最基础的要求就是算法，给你几道题目，来白纸上把这道题的代码写出来，面试官会非常注重边界处理和细节把握，如果要写不出来，基本上也离凉凉不远了。接下来还有一些基本的公式推导，比如如果要面试机器学习算法工程师的话，可能会让手写推导 SVM、LR 等算法。另外还有一些系统设计题，来看看你的思维和架构是不是能达到要求。最后我记得还有一些智力题，看看反应得快不快。再往后的面试也是谈谈自己对行业的一些理解和看法，谈得还是比较深入的。总之考察得非常综合，当时准备面试的期间真的是无比焦虑，感觉人心惶惶的，当时在疯狂地刷题，复习各种算法推导，准备了也差不多有一两个月。最后得知 Offer 的那一刻，一块石头终于落地了。最后我也如愿入职了微软小冰，今年三月刚刚入职，也希望能为小冰带来更多的贡献，也希望大家可以多多关注微软小冰。 其实我已经在微软这边实习了一年多的时间了，平时很多时间也都呆在公司里，自己也算提前一步迈入职场了，经过我个人实习的体验和感受，同时也结合自己平时的了解，总结出来了一些经验。当然这仅仅是我个人的一些看法，仁者见仁智者见智，在这里仅仅做一些经验总结和分享，总结一些从学生迈入职场之后，我会注重的一些地方。如果对你有些启发，那是再好不过了。

工作相关

首先就是工作相关的一些东西了，由学生到工作，我个人觉得还是有一些需要调整的地方的，下面稍微这里说一下。

转换思维

学生到职场的转换，第一个重要的就是转变自己看待事情的思维。迈入职场，就别再有一种”我是学生“、”我刚刚毕业“ 这样的想法，在职场里别人才不管我们是不是刚毕业的学生，他们看的基本上都是我们能不能完成工作或者配合他们完成工作。 另外也别总有一种”努力必有回报“这样的思维。学生时代，可能一道题解不出来，一个项目做不出来，努努力很大程度上还是可以能解的。但是到了职场，这个很不一样，很多事情并不是一定存在因果这样的线性关系的。比如说某个项目你辛辛苦苦做了很久，可能就因为领导不想要这个功能而直接砍掉了。比如说你辛辛苦苦写了稿子，可能因为和某个评阅人的想法不一致而被直接拒掉了。想开点，有时候就是这么操蛋。 还有一个就是别把一件事想的太简单，在工作中，其实很多事上牵扯的东西是很多的。学生的一件事可能就是一件事，一道题可能就是一套题。工作中一件事可能不仅仅是一件事，它所关系到的东西要复杂的多。我们可能会考虑到对公司、对领导、对同事、对绩效、对家人的很多事情，多考虑考虑。 总之，思维的转换是第一步，别再像之前当学生的时候一样了。

靠真本事

首先得考虑清楚啊，公司把我们招来是为了让我们来发挥价值的。 而我们的价值在哪里发挥？当然是体现在工作成果中。那成果哪里来的？那当然是把自己的能力转化过来的。 不同职位有不同的要求，首先确保的是要利用自己的能力把本职工作做好。当然我是做技术的，我所专注的就是技术这个领域了，技术能力是必不可少的，当然做这份工作需要的其实也不仅仅是技术能力，还有一些非表面意义上的能力，如学习探索能力、沟通合作能力等等。 而这些吧，归根结底还是要靠自己的真本事的。别想着投机取巧，别想着耍点小聪明，虽然一时方便了，但是长远来看，吃亏的还是自己。 当然这例子很多，比如明明不是自己做的，却要为了某些目的非要伪装自己，被看穿之后，不少人其实是看破不说破的，慢慢地自己就会知道后果了。比如为了某些目标，背地里各种跟领导各种小恩小惠等，其实领导基本不会 Care 你这种小聪明，甚至还觉得这个人有点靠不住，自己的受信任度也会大打折扣，另外自己不会感到心虚吗？ 最好的办法是什么，其实就是把该做完的工作保质保量完成，靠自己的真本事，实打实做好要求的每一件事就好了，领导看重的就是这个。

利益为先

职场上面啊，你说人情，当然也是会有的，但是更多的人关注的其实是工作本身以及自己的利益。这和学校的差距还是很大的。比如你要是个学生的话，有些人可能觉得你的身份而稍微谅解一下，而踏入社会之后，基本就不会了。 比如你要跟某个人交流和合作，就别总是寒暄以此来套近乎，不是说这个一点用都没有，多少可能还是有点用的，如果你有价值，靠这个可能能快速拉近他与你的距离。但很多情况下，这个的效果可能真的作用不大。 到了职场，大家都很忙的，比如找人谈事情，稍微介绍几句，开口直接谈正事、谈利益就好了。如果不能为对方提供有价值的信息，或者提供的价值并不是对方想要的，对方会觉得比较浪费时间。这种时候就别掺杂什么别的什么交情之类的东西了，虽说我认为成年人只看利益不够准确，但基本上是没错的。 比如跟人谈个合作的时候，讲清楚两点，第一是我们能提供什么价值和服务，第二是他能得到什么利益。当然第二点有的情况下是不需要说的，因为我们本身提供的价值就是给对方的利益，对方觉得值，自然会跟我们合作的。其中也不乏一些沟通的小技巧，还需要在这个过程中慢慢摸索。

保持交流

领导给了一个要求，如果有疑问，要多问多交流，别偏离了方向，别是自作主张。 之前的时候，我接到了一个任务，了解了基本的需求时候就开始开工干。在做的过程中其实有不少不确定的地方，但是当时我也不知道是不好意思还是什么原因，就没有跟领导交流，按照自己的想法做了出来。最后演示的时候，领导说你怎么做成这样了？我本意不是这样的，你有疑问怎么不跟我讨论呢？ 我就意识到了，这其实也可以多少印证”选择比努力更重要“，方向性或方案性的东西是很重要的。 所以，遇到什么不确定的点，要多多沟通交流。当然这并不是说突然想到了某个点就去找对方讨论，把自己的疑问以及可能解决方案和结果梳理清楚再好好交流一下，效果一定好上太多。

工作日志

做好工作日志，时间长了，会发现这个非常有用，它的有用不仅仅是体现在它仅仅是做了总结，它也会潜移默化地影响我们自己。 比如每天可以找个时间简单记录一下自己今天做了什么事情，收获了什么，还需要做什么。这个记录的过程就是一个思考的过程，它会让我们反思自己的一些不足和需要做的更好的地方，会变成一种激励的。 另外工作日志，等某天你打开的时候，会发现成就感满满，同时写什么总计和汇报也就不用愁了。

个人相关

刚才所说的挺多都是和工作相关的，另外还有一些和个人相关的我觉得也应该好好注意下。

迈出第一步

我曾经尝试过很多坚持每天做点什么的事情，发现有的挺难坚持下来的，一而再再而三地累积，就变得越来越多，后来整个坚持的事情就失败了，这就是拖延症的一种现象。 拖延症应该很多人都会有，当然我也是。我平时分析拖延症的一个很大的原因就是迈不出第一步，进而一件事就搁置了。就比如说要去健身房，我觉得最难的就是出家门；比如说要每天刷一道算法题，最难的可能就是打开LeetCode界面。不知道你们什么意见，我至少是这么认为的。 因此，迈出第一步非常重要，迈出了第一步，可以说就成功了一半。

言多必失

的确是，言多必失，这话没毛病。 可能我们仅仅是刚入职的新人，很多情况下不该说的就别说。你永远也不知道你说了某些话之后，你在别人耳中会变成什么样的版本。另外如果我们突然说错了什么话，被人揪住了把柄，那可是很难的。所以，一些场景中，我们一些没必要说的就不要去说，不知道该说不该说的也不要说。 另外我个人比较反感的是明一套暗一套。我们不可能让所有人都认同我们自己，不认同我们的，他们表现出来，我们道不同不相为谋。认同我们的支持我们的，我们可以与他们成为朋友。但表面上显得非常友好，然而在背地里面却说坏话，这是非常令人反感的。

终身学习

虽然表面上看学生生涯结束了，但实际上迈入职场恰恰是一个新的开始，其实人与人之间的差距就是因为工作后的这些年逐渐拉开的，所以不论什么时候都不能放弃学习。 当然迈入职场以后，学习的一些侧重点可能就不太一样了。工作后学习的第一肯定是能用在岗位之上的专业知识，我们所掌握的知识一定至少要能够让我们顺利地专业地完成自己的任务。其次可以扩宽一下知识面，比如可以关注下经济、理财、交际等知识。 总之还是一句话，学习到的本事是别人所偷不走的，做一个终身学习者。

做好记录

很多事情是确实很有必要记录下来的。首先不瞒说，随着事情的增多，工作的忙碌，我发现比原来更加”忘事“了。后来我看了一篇报道，说其实并不是脑子记忆力下降了多少，而是集中的注意力变得更少了。 一件事如果注意力分配得少了，自然很多事情就不容易被我们记住。想想确实是这样的，现在我每天都把自己的计划安排得满满当当，现在连拿出时间好好读一本书的时间都不多了，因此就别提那些日常小事了。那咋办？随手记录下来，比如记到手机的备忘录或者自己的 TodoList 软件里面，然后再进一步安排如何执行就好。 当然记录并不仅仅局限于这个记录下来平时的闪念，平时的一些工作总结、学习笔记也可以时刻记录下来。我有记录学习笔记的习惯，当然肯定也有的时候有一些内容没有及时记录下来。过了一段时间，我发现唯一记得的就是自己曾经整理过笔记甚至发表博客的那些内容，没写过的或者没发过的基本都忘干净了。 记录，成为更好的自己。

作息调整

良好的作息还是非常有必要的。现在肯定非常多的朋友会倾向于熬夜，十二点之后才睡。我之前实习的时候，比这个更狠，经常一两点钟睡觉，睡到将近中午，就直接吃中午饭得了，然后一上午就没有了，当时就有一种半天已经被我浪费的感觉，会有一种负罪感。 后来我开始逐步调整我的作息，尽量早睡早起，从之前的九点多慢慢地调整到八点，甚至是七点多，醒来之后整理一些东西，开始全新的一天，整体的体验确实是比之前睡到中午好太多了。另外我个人也参加了一个早起打卡活动，现在已经坚持每天打卡将近一个月了，基本上也养成了早起的习惯。 另外工作之后，下班的时间也可以好好利用起来，比如晚上稍微拉伸一下，睡前记得喝水等等，由于我平时也每天对着电脑，所以也需要定期地起来活动一下。我把它们设置到滴答清单里面，每天都有软件的定时提醒，到了时间就做，一天天坚持下来。总体来说，感觉也比之前好多了。 所以从现在起，拿起笔好好规划下自己的目标和平时的作息吧。 另外可能大家听说过，某个老板每天只睡五个多小时，晚上工作到很晚才走，早上一大早就在了。我当时也比较好奇这到底是怎么做到的？难道有什么特殊的睡眠技巧？经过我的一阵搜罗，结果是，没有。BOSS 们并没有我们这么忙，可能早上开完会，我们去干活了，而人家去补觉了。所以，保证充足的睡眠还是很有必要的。

合理分配时间

从学生到工作，其实就相当于我们的事情又多了一部分，工作日大部分为工作时间，非工作日则大部分是自己的时间。另外工作之后，相比学生时代来说，事情可能也会变得更多更繁琐。那么如何合理分配自己的时间呢？ 我这边采用了目前比较流行的四象限时间管理法，他就是把处理的事按“重要”和“紧急”两个维度划分，并对应到四种待处理状态中，分别叫做”重要不紧急“，”重要紧急“，”不重要紧急“，”不重要不紧急“四个类别。 通常来说，我们需要马上执行“急事”，确保它们不会延期。但长远来看，我们最好将重心放在“要事”上。可能有一些紧急的小事，它确实是不重要的，但我们能比较快的做完，然后把它勾掉，所以现在很多人可能更加优先处理的是紧急的事情而不是重要事情，最后紧急的事情做完了，剩下重要的事情没做完，所以要么加班熬夜，要么就延期。回想起来，其实这是很得不偿失的，忙活了一天，重要的事情还是没完成。 所以，我们需要尽量减少”不重要紧急“事件的忙碌，尽早处理”重要不紧急“的事情，合理分配时间，去做对我们而言重要的事情，才是四象限理论的核心。 我自己使用了滴答清单这款软件，之前使用的是 Todoist，这两款软件都非常不错，但是由于滴答清单多了番茄时钟的功能，我就改用了滴答清单，我利用它建立了四个智能清单，分别叫做”重要不紧急“，”重要紧急“，”不重要紧急“，”不重要不紧急“，然后建立筛选条件，软件就会根据任务的优先级和到期日期自动更新。然后就可以每天查看、处理并调整任务——做完的事情及时打勾，有变更的事情及时移动，可以遵循这样的一些准则：

• 优先执行重要且紧急的事件
• 尽量提前规划重要不紧急事件，在它们变得紧急前就完成
• 如果可以的话，试着将不重要但紧急的事情交由他人处理，或者学会对别人的请求说 Sorry
• 需要控制去做不重要不紧急事件的时间，不要过度放松

有了这几条原则，我们就可以很好的分配我们的时间了，如果大家觉得有用的话也可以试一下。 以上就是我的成长历程以及我所想到的一些需要调整和坚持的一些做法，如果能为大家带来一些帮助，那就再好不过了。

入职微软之后，这边大多数是使用 Windows 进行开发的，比如我的台式机是 Windows 的，还有一部分服务器是 Windows 的，当然 Linux 是也非常多。 很多情况下我是使用自己的 Mac 笔记本来远程连接我的 Windows 机器来开发的。比如如果我在工位上，我会用我的 Mac 连接两块显示屏，然后一种一块用来远程桌面连接我的 Windows 开发机，这样另外一块屏幕和 Mac 自带的屏幕就用来看文档或者使用 Teams 通讯等等。如果我回家了，我家里也是有两块屏，开上 VPN，照样用一块屏使用远程桌面，另外一块屏幕和 Mac 自带屏幕就可以做其他事情了。 这样就解决了一个问题：我的 Windows 基本上都是仅用作开发的，一块屏幕就开着一个 Visual Studio，其他的操作都会在 Mac 进行，比如查文档，发消息等等。这样我下班之后照样使用远程连接的方式来操作，和在公司就是一样的。这样就避免了一些软件的来回登录，比如如果我上班只用公司机器，下班了之后换了 Mac 还得切 Teams、切微信、切浏览器等等，还是很麻烦的，而且上班期间 Mac 就闲置了也不好。所以我就采取了这样的开发方案。

需求分析

有了这个情景，就引入了一个问题。开了一个远程桌面之后，我几乎一个屏幕都是被 Visual Studio 占据的，而远程桌面貌似只能开一个屏幕？如果我要再开一个终端窗口的话，那可能屏幕就不太够用了，或者它就得覆盖我的全屏 Visual Stuido。 另外我平时 Mac 终端软件都是使用 SSH 的，基本都是用来连 Linux 的，Windows 一般都是开远程桌面。但命令行这个情形的确让我头疼，让我感到不够爽，因为毕竟远程桌面之后，Windows 里面的操作都得挤在一个桌面里面操作了。当然可能能设置多个桌面，如果可以的话，麻烦大家告知一下谢谢。 所以解决的痛点在于：我要把一些操作尽量从 Windows 里面分离出来，例如终端软件，我能否在远程桌面外面操作，能否使用 SSH 来控制我的 Windows 机器。 好，有需求才有动力，说干就干。

配置

查了一下，Windows 上其实也是有 SSH 服务器的，只不过默认是没有装的，这里只需要安装一个 OpenSSH 服务器就好了。 Win10 的话，就在设置里面可以安装，从开始菜单打开“设置”，然后选择应用和功能，这里就有一个“管理可选功能”的选项。 点击之后便可以看到一个可选功能，选择 OpenSSH 服务器即可，一般情况下是没有安装的。如果没有安装的话它会提示一个安装按钮，这里我已经安装好了，就提示了一个卸载按钮。 OK，有了它，直接点击安装即可完成 OpenSSH 服务器的安装。 当然如果你是想批量部署 Windows 服务器的话，当然是推荐使用 PowerShell 来自动化部署了。 首先需要用管理员身份启动 PowerShell，使用如下命令看一下，要确保 OpenSSH 可用于安装：

1

Get-WindowsCapability -Online | ? Name -like 'OpenSSH*'

输出应该是类似的结果：

1
2
3
4

Name  : OpenSSH.Client~~~~0.0.1.0
State : NotPresent
Name  : OpenSSH.Server~~~~0.0.1.0
State : NotPresent

然后使用 PowerShell 安装服务器即可：

1

Add-WindowsCapability -Online -Name OpenSSH.Server~~~~0.0.1.0

输出结果类似：

1
2
3

Path          :
Online        : True
RestartNeeded : False

这样也可以完成 OpenSSH 的安装。 安装完成之后，就需要进行一些初始化配置了，还是以管理员身份，使用 PowerShell 执行即可。 首先需要开启 SSHD 服务：

1

Start-Service sshd

然后设置服务的自动启动：

1

Set-Service -Name sshd -StartupType 'Automatic'

最后确认一下防火墙是否是放开的：

1

Get-NetFirewallRule -Name *ssh*

如果是放开的，那么结果会提示 OpenSSH-Server-In-TCP这个状态是 enabled。 好了，完成如上操作之后我们就可以使用 SSH 来连接我们的 Windows 服务器了。

连接

连接非常简单了，用户名密码就是 Windows 的用户名和密码，使用 IP 地址链接即可。 比如我的 Windows 开发机的局域网 IP 为：10.172.134.88，那么就可以使用如下命令完成链接：

1

ssh user@10.172.134.88

然后输入密码，就连接成功了，和 Linux 的是一样的。 另外我自己现在 Mac 常用的 SSH 客户端工具有 Termius，可以多终端同步使用，非常方便，这里我只需要添加我的 Windows 机器就好了，如图所示： OK，以后就可以非常轻松地用 SSH 连接我的 Windows 服务器了，爽歪歪，上面的需求也成功解决。 以上便是使用 SSH 来连接 Windows 服务器的方法，如果大家有需求可以试试。

都说程序猿是一类不解风情的生物，“赚的多，花的少，死的早”已经成为了程序猿的标志，“眼镜、格子衫、垢面蓬头、拖鞋裤衩”已然也成了程序猿的代表形象，“代码、游戏、老湿”也已经快要成了程序猿的生命。 但！有的时候，比如情人节，我们就可以发挥我们的特长了，我们程序猿也可以有自己的浪漫！ 不过这个第一步是，你得有一个女朋友（哦哦，是不是可以不用往下看了？ 那么有了第一步之后，下面我们应该怎么办呢？ 下面介绍一个比较实用的可以送给女朋友的礼物（这其实也是我今天送给女朋友的礼物嘿嘿。 首先想想，作为程序猿，我们的专长是什么？废话，当然是代码。 有了代码，还需要送口红吗？还需要送包包吗？还需要送鲜花吗？废话，都有了代码了，这些当然就….还是要送的。万一写的代码你女朋友看不懂那岂不是死翘翘了。 好那送完了口红或包包或鲜花之后，确保已经平安无事了，我们就可以再发挥我们的光和热了（听起来咋这么奇怪呢？ 进入正题，那我们可以利用代码做点什么呢？想想可以做文章的地方有什么，你们的纪念日，你们曾经做过的事情，你们在一起的时间，这些都是属于你们的独一无二的，我们可以想方设法把它们和代码联系起来。 那怎么发给女朋友看呢？做个 App、小程序、网页什么的都是可以的吧，其中网页可能是做起来最快最方便的了，然后配上一个专属域名，简直美滋滋。 好，那一想，基本方向就确定了，直接开干，接下来就描述一下我准备这个礼物的历程吧。 对于我来说，我就计划做一个网页，同时用代码的形式把和女朋友在一起的时间呈现出来，通过网页的动效来呈现我们在一起的时间，另外还计划把我们之间的故事用代码关联表示出来。 本来我打算是从零开始手撸一个的，但是一些组件比如动画特效，还有一些倒计时的组件是相对比较难做的，于是我就在 GitHub 上逛了一下，看了几个示例，找到了一个和我理想作品差不多的项目，然后在它的基础上做了一些改动，就成了最终的效果。 主要功能如下：

• 第一是通过代码来表述出来和女朋友之间的故事。由于我和女朋友是因为 Python 认识的，而且我们两个平时都会写一些 Python，所以我决定用 Python 来写出我们之间的故事，加上 Python 的注释来辅助描述每一行代码的意义。
• 第二是通过代码来呈现我和女朋友在一起的时间。这里就用上了一些动画特效和秒数计时方案，实时地呈现出来我和女朋友在一起已经有多久了。

最终完成之后的效果是这样子的： 然后由于我自己有一个域名，叫做 cuiqingcai.com，然后我就把它设置了二级域名解析，二级域名名称就叫做 love，域名最终就是 love.cuiqingcai.com。 最终的效果大家可以扫码或者复制链接查看一下最终的效果：http://love.cuiqingcai.com/，二维码如下： 感觉还可以吧？如果你也想送这样的礼物的话，可以根据我现有的代码来进行修改，我已经将源码放到 GitHub 了，地址为：https://github.com/Germey/ValentinesDay，大家可以修改源码，把它变成属于你和你女朋友的专属页面，然后送给女朋友。 下面说一些关键的技术和需要修改的点。

代码动画

打开页面之后，我们可以看到页面的代码是一个字一个字敲出来的，这实际上是利用了一个定时器来实现的。 首先我们可以预定义好所有的文本，然后动画播放的时候，首先把所有的文本隐藏，然后每隔几十毫秒读取一个字符，然后将其呈现出来。由于文本本身就是换行的，所以在呈现的时候就会一行一行地像打字机一样呈现出来。 另外为了模拟打字的效果，在呈现的时候可以在最后的字符后面添加一个下划线符号，模拟打字的效果。 其关键的实现代码如下：

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

(function (a) {
    a.fn.typewriter = function () {
        this.each(function () {
            var d = a(this), c = d.html(), b = 0;
            d.html("");
            var e = setInterval(function () {
                var f = c.substr(b, 1);
                if (f == "<") {
                    b = c.indexOf(">", b) + 1
                } else {
                    b++
                }
                d.html(c.substring(0, b) + (b & 1 ? "_" : ""));
                if (b >= c.length) {
                    clearInterval(e)
                }
            }, 75)
        });
        return this
    }
})(jQuery);

这里可以看到，首先获取了页面代码区域的内容，然后通过 DOM 操作将代码先清空，然后利用 setInterval 方法设置一个定时器，定时间隔 75 毫秒，也就是说 75 毫秒循环调用一次。每调用一次，就会从原来的字符上多取一个字符，然后尾部拼接一个下划线就好了。

代码内容

接下来就是代码内容了，这里面要想好怎样把一些关键时间来表示出来。比如和女朋友怎样认识的，后来什么时间在一起的，一起做过什么事情，将来有什么计划和打算，都可以来描述出来，另外编程语言可以选择你喜欢的语言，然后配以一定的注释来描述代码所代表的含义。 我和女朋友是在 PyCon 认识的，也算是因为 Python 结缘，然后平时我们都会写一些 Python，所以我就选用 Python 作为编程语言了。 然后我又加上了我们认识的时间、在一起的时间、一起做过的事情，然后再配以一段代码来表达自己的想法，其中的一些灵感也是我看了一些案例想出来的，在表述过程中我使用了面向对象的思维声明了两个对象，一个代表我，一个代表我女朋友，然后一起做过的事情就可以通过对象调用方法的形式来表述出来了，另外一些动作和标志可以通过自定义方法或者代码的参数来表示出来，其中每一行代码的动作我都配以一条 Python 的注释来完成，注释当然是用英文，一些话我还用了翻译软件一句句查的。 然后最后我用了一段 Python 代码来表达了自己的感情，内容如下：

1
2
3
4
5
6

# You are the greatest love of my life.
while True:
    if u.with(i):
        you = everything
    else:
        everything = u

这个代码的含义叫做“无论天涯海角，你都是我的一切。“，一个 while True 循环代表了永久。 这些代码其实都是在 HTML 代码中预定义好的，其中注释需要用 span 标签配以 comments 的 class 来修饰，缩进需要用 span 标签配以 placeholder 的 class 来修饰，例如：

1
2
3
4
5
6

<span class="comments"># You are the greatest love of my life.</span><br/>
while <span class="keyword">True</span>:<br/>
<span class="placeholder"></span><span class="keyword">if</span> u.with(i):<br/>
<span class="placeholder"></span><span class="placeholder"></span>you = everything<br/>
<span class="placeholder"></span><span class="keyword">else</span>:<br/>
<span class="placeholder"></span><span class="placeholder"></span>everything = u<br/>

这里不同的格式用 span 的不同 class 来标识，空格缩进一个 placeholder 是两个空格，comments 代表注释格式，关键词使用 keyword 来标识。如果你需要自定义自己的内容，通过控制这些内容穿插写入就好了。

纪念日计时

关于纪念日，这个实现起来其实挺简单的，就是首先定义好你们的纪念日，然后获取当前系统时间，然后计算秒数差值，然后将其转化为天数、小时数即可，关键核心代码实现如下：

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

function timeElapse(c) {
    var e = Date();
    var f = (Date.parse(e) - Date.parse(c)) / 1000;
    var g = Math.floor(f / (3600 * 24));
    f = f % (3600 * 24);
    var b = Math.floor(f / 3600);
    if (b < 10) {
        b = "0" + b
    }
    f = f % 3600;
    var d = Math.floor(f / 60);
    if (d < 10) {
        d = "0" + d
    }
    f = f % 60;
    if (f < 10) {
        f = "0" + f
    }
}

另外它也是通过一个定时器来实现的时间刷新，每隔 500 毫秒调用一次：

1
2
3

setInterval(function () {
    timeElapse(together);
}, 500);

动画心形

动画心形，其实这个实现起来是很巧妙的。这里在画的时候实际上是利用了贝塞尔曲线来绘制一个心形，同时在在画的过程中还加了花开的效果，花开的效果使用了随机数和随机颜色生成。 其中动画画心形的核心代码如下：

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

Petal.prototype = {
    draw: function () {
        var a = this.bloom.garden.ctx;
        var e, d, c, b;
        e = new Vector(0, this.r).rotate(Garden.degrad(this.startAngle));
        d = e.clone().rotate(Garden.degrad(this.angle));
        c = e.clone().mult(this.stretchA);
        b = d.clone().mult(this.stretchB);
        a.strokeStyle = this.bloom.c;
        a.beginPath();
        a.moveTo(e.x, e.y);
        a.bezierCurveTo(c.x, c.y, b.x, b.y, d.x, d.y);
        a.stroke()
    }, render: function () {
        if (this.r <= this.bloom.r) {
            this.r += this.growFactor;
            this.draw()
        } else {
            this.isfinished = true
        }
    }
};

这里最关键的一个部分就是 bezierCurveTo，这里传入的是绘制贝塞尔曲线的参数坐标，那这些坐标怎么生成的呢，这里是利用了数学上的一个桃心线方程，如图所示： 其中心形线的解析方程为： $x = 16(sint)^3 \\ y = 13cost-5cos2t-2cos3t-cos4t$ 这个公式代表了绘制坐标点的 x、y 的解析方程，用代码表示出来就是：

1
2
3
4
5
6

function getHeartPoint(c) {
    var b = c / Math.PI;
    var a = 19.5 * (16 * Math.pow(Math.sin(b), 3));
    var d = -20 * (13 * Math.cos(b) - 5 * Math.cos(2 * b) - 2 * Math.cos(3 * b) - Math.cos(4 * b));
    return new Array(offsetX + a, offsetY + d)
}

这里是生产了心形线方程的 x、y 坐标，然后再以此绘制出带有动画效果的心形。 最终呈现的效果就是现在你看到的样子。 不过这些在改代码的时候实际上不用关心，只需要修改你们在一起的时间就好了，就是代码中的这一行：

1
2

together.setFullYear(2018, 10, 5);
together.setHours(15);

这里修改你们在一起的时间和小时就可以了，然后页面就会自动更新你们在一起多久了，并动态呈现出来了。

域名解析

对于域名解析，这个建议大家可以申请一个域名，比如我的域名就是 cuiqingcai.com，我可以设置一个二级域名解析，叫做 love.cuiqingcai.com。 如果没有域名的话可以现买一个，比如阿里云、腾讯云购买，然后设置解析即可。 如果没有域名，也可以使用一些虚拟云服务器，他们会帮你设置二级域名，当然也可以使用 GitHub Pages，甚至你使用 IP 地址来访问也是没问题的。

项目代码

项目的代码我都放在了：https://github.com/Germey/ValentinesDay，大家可以自行修改成想要的样子送给女朋友，只能帮你到这里啦。 嘿嘿，这就是我今天送给女朋友的礼物，女朋友收到了开心得不得了，开心。

我的礼物

其实我今天也收到了女朋友送的特殊的礼物，可以说她确实花了不少心思啊，她送了我什么呢？令我没想到的是，她居然刚申请了一个微店，然后她微店上架了好多商品，我看到时候惊呆了，店铺如图所示： 里面上架了什么商品？洗水果服务？做饭刷碗服务？捏肩膀服务？还有自动哄老婆机？我惊了。 她把商品发给我，我好奇问她这是干嘛的。 她说：要获得我的洗水果服务，捏肩膀服务，只需要在我的小店里购买使用就好了（作掐腰状）！还有自动哄老婆机，你要惹我生气了，只需要购买一个自动哄老婆机，我就会不生气了！嘿嘿合不合算？ 我说：多少钱？999！这么贵的吗！ 她说：当然不是啦，亲亲我们店里有活动的，使用优惠券满 999 减 998 呢，您是我的 VIP 唯一专属客户，我会给您发优惠券的呀，使用优惠券只需要一块钱就可以购买了。购买之后，您每次使用一张，我就可以给您洗水果、捏肩膀了！这个情人节的话呢，我要送亲亲 10 张！可省着点话，不能累到店长我啊！ 哦哦，卧槽真牛逼啊！于是乎我就快快乐乐领取到了十张优惠券购买了女朋友的这些服务，等着时不时用一张，享受一下帝王级的待遇，美滋滋！哈哈~ 最后，祝大家情人节快乐！幸福！

作为一名程序员，能够利用好工具提高开发和工作效率是非常重要的。我个人使用的都是苹果系列产品，电脑为 MacBook Pro 15 寸，手机 iPhone 7P，另外还有一个 iPad Pro 和一副 Apple Watch。我一直觉得 Mac 是非常适合做程序开发的，它既有比较不错的页面，也有类 Unix 的操作系统，使得日常使用和程序开发都极其便利，另外由于苹果本身自有的 iCloud 机制，使用 Mac、iPhone、iPad 跨平台开发和工作也变得十分便利。

近期我又对自己的一些工具进行了整理，弃用了一些工具，新启用了一些工具。目的也只有一个，就是提高自己的工作和开发效率，让生活变得更美好。如果你也在用 Mac 开发，或者你也有使用 iPad、iPhone，下面我所总结的个人的一些工具或许能给你带来帮助。

快速导航

这是 Mac 上的一个工具，要说到提高效率，首推 Alfred，可以说是 Mac 必备软件，利用它我们可以快速地进行各种操作，大幅提高工作效率，如快速打开某个软件、快速打开某个链接、快速搜索某个文档，快速定位某个文件，快速查看本机 IP，快速定义某个色值，几乎我们能想到的都能对接实现。

其实 Mac 本身已经自带了软件搜索还有 Spotlight，但是其功能还是远远比不上 Alfred，有了它，所有的快捷操作几乎都能实现。

这些快速功能是怎么实现的呢？实际上是 Alfred 对接了很多 Workflow，我们可以使用 Workflow 方便地进行功能扩展，一些比较优秀的 Workflow 已经有人专门做过整理了，可以参见：https://github.com/zenorocha/alfred-workflows，大家可以安装自己所需要的 Workflow，大大提高效率。

复制粘贴

Mac 上默认只有一个粘贴板，当我们新复制了一段文字之后，如果我们想再找寻之前复制的历史记录就找不到了，这其实是很反人类的。

好在 Paste 这款软件帮我们解决了这个问题，它可以保存我们粘贴板的历史记录，等需要粘贴某个内容的时候只需要呼出 Paste 历史粘贴板，然后选择某个特定的内容粘贴就好了，另外它还支持文本格式调整粘贴板分类和搜索，还可以支持快速便捷粘贴。有了它，再也不用担心粘贴板丢失了！

另外使用 Mac 和 iPhone、iPad 之间也可以相互之间复制粘贴，可以在一台 Apple 设备上拷贝文本、图像、照片和视频，然后在另一台 Apple 设备上粘贴该内容。例如，可以拷贝在 Mac 上浏览网页时发现的食谱，然后将其粘贴到附近 iPhone 上“备忘录”中的购物清单。这是在 macOS Sierra 版本之后出来的功能，若要使用需要确保 Mac 的版本是 Sierra 及以后。若要使用，几个设备必须满足“连续互通”系统要求。它们还必须在“系统偏好设置”（在 Mac 上）和“设置”（在 iOS 设备上）中打开 Wi-Fi、蓝牙和 Handoff，另外必须在所有设备上使用同一 Apple ID登录 iCloud。

具体的操作流程可以参见苹果的官网说明：https://support.apple.com/kb/PH25168，有了这个功能，日常的一些操作便可以直接同步了，甚至不再需要 AirDrop，更不需要微信和邮件。

时间管理

现在这个时候，时间比什么都重要，每个人的时间都是公平的，如果我们能够合理规划好自己的时间和工作，这就跨出了成功的一步。

我曾经尝试用手写的方式来记录自己的一些任务，但总感觉它有一些并不方便的地方。比如某时某刻突然想起来，想要添加一件事情或者完成了一件事情，或者想要修改截止时间，或者想要划分优先级，其实都不怎么方便。最好的方式还是通过一些专用的时间管理软件来分配分配和管理自己的时间。

我曾经使用过非常多款时间管理工具，最终我选择的是 Todoist，这个是我感觉体验非常不错的一款。这个软件里面基本的任务添加与勾划功能当然必不可少，它也支持优先级管理，分类管理，时间设置，另外还有几个我觉得非常加分的几个点，比如：

• 添加时间时可以直接通过一句话来添加，比如”每隔两天晚上九点运动”，它会自动识别并设置为循环任务，并能在相应的时刻提醒你。

• 支持全部平台，不论是网页还是 Windows、Mac、Android、iPhone、iPad、Apple Watch、Chrome、Firefox，你能想到的平台，应有尽有。

• 它还支持事件同步，可以在 Mac 或者 iPhone 的日历中添加 Todoist 的同步，这样你所有的事情都会被定时同步到日历软件中，这样日历中就既包含了节日、生日等信息，又可以把每天我们需要做的事同步进来，日程信息一目了然。这样你就可以把日历变成一个提醒器，设置什么时候提醒就好了，现在我就在用 Mac 或者 iPhone 上的日历来提醒我什么时间该做什么事情了。

• 它还支持多人写作，就类似于 Worktile、Teambition、Trello，我曾经使用这款软件完成了多个项目的任务分配和多人协作开发，还是非常方便的。

• 另外它还支持过期智能重新安排任务，比如有一些任务没有完成，它还可以根据优先级来重新进行时间规划和安排，同时也有任务评分和目标评价机制，来反映我们任务完成情况。

另外关于时间管理还有一个非常重要的四象限法则，大家也可以了解一下。有了这个法则，大家可以合理安排优先级，合理分配每个任务的时间。有关于我的时间管理经验我后面还会详细写一篇相关的文章，介绍一下我平时会怎样进行时间规划和学习的。

另外我还尝试过番茄土豆这个软件，这个软件的缺点在于整体的功能还比较简陋，而且不能和我已有的 Todo List 进行同步。好处就是可以自己设置番茄，保持专注工作。但目前我尚未发现满意的产品，如有还希望大家可以留言推荐一下，谢谢。

笔记记录

在学习的时候来进行记录是非常非常重要的，强烈建议一边学习一边把所做所想记录下来，最后做一下整理成文。一方面方便查阅，另一方面加深印象和理解。

Markdown 想必大家都已经很耳熟了，现在我写文章或者笔记几乎全都用 Markdown 来写，现在很多云笔记也慢慢逐步支持 Markdown 的语法了，我的博客后台也自己配置了 Markdown 的支持。不过也有某些平台尚未支持 Markdown，比如知乎，忍不住吐槽一句，知乎的编辑器实在用得是心累，当然可以使用插件来解决，也当然也有所好，我就不再说什么了。不过我还是强烈推荐 Markdown 来进行写作和记录的，用过之后你可能就不再想用 Word 了。

言归正传，既然谈到笔记和写作。我的笔记本是 Mac，之前几乎所有的笔记，包括写书，都几乎是在 Mac 上完成的，但是确实有的时候是不方便的。比如 Mac 不在身边或者想用 iPhone 或者 iPad 来写点东西的时候，一个需要解决的问题就是云同步问题。有了云同步，我们如果在电脑上写了一部分内容，接着切换了另一台台式机，或者切换了手机的时候，照样能够接着在原来的基础上写，非常方便。

这时候可能就有小伙伴推荐有道云笔记、印象笔记等软件，它们支持 Markdown，但这并不是它们的主打支持方向，对 Makrdown 的支持当然没有一些专业的 Makrdown 编辑工具专业。对我个人而言，我不想因为它们自带了云同步而抛弃了纯粹的 Makrdown 写作环境，我只想要一个纯粹的 Makrdown 写作环境，而不想引入比如有道云里面的普通笔记、签到等冗余的功能，也不想看到里面的广告推荐等内容。所以对于云同步，我使用了另外的解决方案。对于写作软件，我也摸索出了自己的一套方案。

对于电脑端的 Markdown 写作软件，推荐两款，一款是 Typora，另一款是 MarkEditor。

对于 Makrdown 编辑器来说，我觉得有几个比较重要的点：

• 不能纯写 Makrdown，要实时地能够看到自己写完 Makrdown 之后最终呈现的效果是怎样的。

• 插入图片要方便，很多编辑器需要先将图片挪到某个文件夹下或者上传图片才可以插入图片，这是很不友好的，如果能够直接通过复制粘贴的形式插入图片，甚至能够自动将图片上传到云端，那就再好不过了。

• 能够打开一整个 Makrdown 文件夹，左侧显示文件列表，右侧进行写作编辑，不能仅仅支持一个 Markdown 文件的编辑。

• 如果需要用到公司，那么编辑器需要对 Markdown 公式支持比较好。

以上介绍的这两款软件都可以做到。

• Typora 是免费的，更加轻量级，而且支持即写即得，界面支持和公式支持都比较好，图片的话可以结合 iPic 软件直接上传到图床，同时也可以直接将复制的图片直接粘贴到编辑器中，非常友好，目前我正在使用。

• MarkEditor 是收费的，功能更为丰富，支持左右分栏模式、阅读模式等，它也支持直接复制和粘贴图片，另外还有强大的导出功能，还可以直接将文件发布为一个网站等等，也十分推荐。

不过目前由于 Typora 更轻量级，并且能和 iPic 而且功能配合使用，粘贴后的图片可以点击直接上传到云端，非常方便，我目前已经由 MarkEditor 切换到 Typora 了。

写作界面如下：

如图这是打开了一个文件夹，这个文件夹里面有好多 Makrdown 文件，都是我在研究和学习过程中所写的笔记。

然后需要解决的就是云同步问题，云同步其实使用网盘就足够了。由于我使用 Mac，所以我选用了 iCloud，开了 200G 的空间，足够了。这样我所记录的内容能够秒级同步到 iCloud Drive 中，这样我再使用 iPhone、iPad 就可以直接看到最新的内容了。当然还有一些推荐的，比如 OneDrive、谷歌云等多种云盘同步工具，哪个方便用哪个。Mac 和 iPhone 的好处就是已经内置了 iCloud Drive，所以不用再去在各个终端上配置了。

接下来就是在其他的电脑以及 iPhone、iPad 上进行写作的解决方案了。由于我的文件都已经存放在了 iCloud Drive，所以就需要一款 Makrdown 编辑软件可以直接读写 iCloud Drive 里面的内容，同时界面还要友好，功能完善一点。在这里我最终选择了 Markdown Pro，它的功能简洁但是又比较完善，打开之后直接选取 iCloud Drive 里面的 Makrdown 文件即可开始编辑，并且它是左右分栏的，即左侧编辑，右侧预览，非常方便简洁，另外它对公式的支持也很好，下图是我在 iPad 上对本文进行编辑的效果预览图。

对于图片的插入，在 iPhone 和 iPad 上我借助了另外一个工具，叫做 SM.MS，这个软件可以直接选取图片，然后上传到云端，点击复制即可得到链接和 Makrdown 图片链接，所以插图也不是什么问题了。

如图所示，上传照片之后，便会出现各种各样的图片链接形式，有纯链接、HTML、Markdown 等等，直接点击复制按钮即可复制，然后粘贴到文档中。

另外如果你用了 Windows 的话，只要下载一个 iCloud 云盘软件即可同步。如果使用的是其他的云盘软件，也只需要配置一下就好了。

有了这套，我们就可以实现随时随地写笔记，Mac、iPhone、iPad 无缝切换。

思维导图

很多时候我们在构思方案或者流程的时候需要对思维做梳理，或者在列方案呈现的时候也需要分门别类地进行呈现。这时候大多数情况下就需要用到一个工具，思维导图。

思维导图工具我个人使用的是 MindNode，在 Mac 上用它可以通过各种快捷键快速的增删思维导图节点，另外界面也非常绚丽多彩。

对于思维导图软件来说，我也希望能全平台同步，其实 MindNode 也有对应的移动端软件，同样是 MindNode，二者可以通过 iCloud Drive 进行同步，同样可以做到无缝衔接。

另外还有很多朋友也在用 XMind，功能同样很强大，大家也可以试试。

远程控制

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

当然除了电脑，当我们出去在外的时候，紧急情况也可能需要使用 SSH 来连接和管理我们的服务器，所以我也在 iPhone 和 iPad 上装了远程管理软件，叫做 Termius，同样功能十分强大，快捷操作十分便捷，有免费的试用期限，我觉得非常好用就订购了，推荐给大家。

代码记录

作为一名程序员，我们会经常写或者使用一些关键代码。

比如有一天我写了一些方法，这些方法可以完成非常重要的功能，后面的项目也会经常遇到，那么怎么办呢？很多情况下我们想把它保存起来，放到某个收藏夹里面备用，等到用的时候重新把它复制出来。或者有一些繁琐的命令，我实在是记不住，或许我们也想把它记录下来。

很多情况下，我们可能简单地使用文本文件，但并不方便同步和查找。或者云笔记保存下来，但这些并不是专门用来保存代码的。更高级一点，我们会联想到使用 GitHub Gists，但每次记录的这个流程也比较麻烦。

这里推荐一个专门用来记录代码片段的软件，叫做 SnippetsLab，适用于 Mac 系统，可以专门用来管理代码片段，还支持多种代码格式。比如我就将代码按照编程语言划分，划分为 Python、JavaScript 等等，分文件夹存储，有不错的代码就随手贴过来，另外它也支持搜索，管理代码非常方便。如果某一天想查某个代码了，直接打开它一搜就有了，可以大大提高开发效率。

以上就暂且总结这么多，其实还有不少好用的用具，后面再一一为大家总结分享。

另外再问下大家，你们买 iPad 了吗？是不是觉得比较鸡肋，或者平时都用不上，那这样就没有发挥 iPad 的最大效用，如果利用好了，它可以进一步方便我们的生活，后面我也会专门写一下 iPad 方面的一些用途。

由于水平和见识有限，如果大家有更好的软件或者方案推荐，欢迎大家留言！也希望我的一些方案对大家有所帮助，谢谢！

爬虫是做什么的？是帮助我们来快速获取有效信息的。然而做过爬虫的人都知道，解析是个麻烦事。 比如一篇新闻吧，链接是这个：https://news.ifeng.com/c/7kQcQG2peWU，页面预览图如下： 我们需要从页面中提取出标题、发布人、发布时间、发布内容、图片等内容。一般情况下我们需要怎么办？写规则。 那么规则都有什么呢？怼正则，怼 CSS 选择器，怼 XPath。我们需要对标题、发布时间、来源等内容做规则匹配，更有甚者再需要正则表达式来辅助一下。我们可能就需要用 re、BeautifulSoup、pyquery 等库来实现内容的提取和解析。 但如果我们有成千上万个不同样式的页面怎么办呢？它们来自成千上万个站点，难道我们还需要对他们一一写规则来匹配吗？这得要多大的工作量啊。另外这些万一弄不好还会解析有问题。比如正则表达式在某些情况下匹配不了了，CSS、XPath 选择器选错位了也会出现问题。 想必大家可能见过现在的浏览器有阅读模式，比如我们把这个页面用 Safari 浏览器打开，然后开启阅读模式，看看什么效果： 页面一下子变得非常清爽，只保留了标题和需要读的内容。原先页面多余的导航栏、侧栏、评论等等的统统都被去除了。它怎么做到的？难道是有人在里面写好规则了？那当然不可能的事。其实，这里面就用到了智能化解析了。 那么本篇文章，我们就来了解一下页面的智能化解析的相关知识。

智能化解析

所谓爬虫的智能化解析，顾名思义就是不再需要我们针对某一些页面来专门写提取规则了，我们可以利用一些算法来计算出来页面特定元素的位置和提取路径。比如一个页面中的一篇文章，我们可以通过算法计算出来，它的标题应该是什么，正文应该是哪部分区域，发布时间是什么等等。 其实智能化解析是非常难的一项任务，比如说你给人看一个网页的一篇文章，人可以迅速找到这篇文章的标题是什么，发布时间是什么，正文是哪一块，或者哪一块是广告位，哪一块是导航栏。但给机器来识别的话，它面临的是什么？仅仅是一系列的 HTML 代码而已。那究竟机器是怎么做到智能化提取的呢？其实这里面融合了多方面的信息。

• 比如标题。一般它的字号是比较大的，而且长度不长，位置一般都在页面上方，而且大部分情况下它应该和 title 标签里的内容是一致的。
• 比如正文。它的内容一般是最多的，而且会包含多个段落 p 或者图片 img 标签，另外它的宽度一般可能会占用到页面的三分之二区域，并且密度（字数除以标签数量）会比较大。
• 比如时间。不同语言的页面可能不同，但时间的格式是有限的，如 2019-02-20 或者 2019/02/20 等等，也有的可能是美式的记法，顺序不同，这些也有特定的模式可以识别。
• 比如广告。它的标签一般可能会带有 ads 这样的字样，另外大多数可能会处于文章底部、页面侧栏，并可能包含一些特定的外链内容。

另外还有一些特点就不再一一赘述了，这其中包含了区块位置、区块大小、区块标签、区块内容、区块疏密度等等多种特征，另外很多情况下还需要借助于视觉的特征，所以说这里面其实结合了算法计算、视觉处理、自然语言处理等各个方面的内容。如果能把这些特征综合运用起来，再经过大量的数据训练，是可以得到一个非常不错的效果的。

业界进展

未来的话，页面也会越来越多，页面的渲染方式也会发生很大的变化，爬虫也会越来越难做，智能化爬虫也将会变得越来越重要。 目前工业界，其实已经有落地的算法应用了。经过我的一番调研，目前发现有这么几种算法或者服务对页面的智能化解析做的比较好：

• Diffbot，国外的一家专门来做智能化解析服务的公司，https://www.diffbot.com
• Boilerpipe，Java 语言编写的一个页面解析算法，https://github.com/kohlschutter/boilerpipe
• Embedly，提供页面解析服务的公司，https://embed.ly/extract
• Readability，是一个页面解析算法，但现在官方的服务已经关闭了，https://www.readability.com/
• Mercury，Readability 的替代品，https://mercury.postlight.com/
• Goose，Java 语音编写的页面解析算法，https://github.com/GravityLabs/goose

那么这几种算法或者服务到底哪些好呢，Driffbot 官方曾做过一个对比评测，使用 Google 新闻的一些文章，使用不同的算法依次摘出其中的标题和文本，然后与真实标注的内容进行比较，比较的指标就是文字的准确率和召回率，以及根据二者计算出的 F1 分数。 其结果对比如下：

Service/Software

Precision

Recall

F1-Score

Diffbot

0.968

0.978

0.971

Boilerpipe

0.893

0.924

0.893

Readability

0.819

0.911

0.854

AlchemyAPI

0.876

0.892

0.850

Embedly

0.786

0.880

0.822

Goose

0.498

0.815

0.608

经过对比我们可以发现，Diffbot 的准确率和召回率都独占鳌头，其中的 F1 值达到了 0.97，可以说准确率非常高了。另外接下来比较厉害的就是 Boilerpipe 和 Readability，Goose 的表现则非常差，F1 跟其他的算法差了一大截。下面是几个算法的 F1 分数对比情况： 有人可能好奇为什么 Diffbot 这么厉害？我也查询了一番。Diffbot 自 2010 年以来就致力于提取 Web 页面数据，并提供许多 API 来自动解析各种页面。其中他们的算法依赖于自然语言技术、机器学习、计算机视觉、标记检查等多种算法，并且所有的页面都会考虑到当前页面的样式以及可视化布局，另外还会分析其中包含的图像内容、CSS 甚至 Ajax 请求。另外在计算一个区块的置信度时还考虑到了和其他区块的关联关系，基于周围的标记来计算每个区块的置信度。 总之，Diffbot 也是一直致力于这一方面的服务，整个 Diffbot 就是页面解析起家的，现在也一直专注于页面解析服务，准确率高也就不足为怪了。 但它们的算法开源了吗？很遗憾，并没有，而且我也没有找到相关的论文介绍它们自己的具体算法。 所以，如果想实现这么好的效果，那就使用它们家的服务就好了。 接下来的内容，我们就来说说如何使用 Diffbot 来进行页面的智能解析。另外还有 Readability 算法也非常值得研究，我会写专门的文章来介绍 Readability 及其与 Python 的对接使用。

Diffbot 页面解析

首先我们需要注册一个账号，它有 15 天的免费试用，注册之后会获得一个 Developer Token，这就是使用 Diffbot 接口服务的凭证。 接下来切换到它的测试页面中，链接为：https://www.diffbot.com/dev/home/，我们来测试一下它的解析效果到底是怎样的。 这里我们选择的测试页面就是上文所述的页面，链接为：https://news.ifeng.com/c/7kQcQG2peWU，API 类型选择 Article API，然后点击 Test Drive 按钮，接下来它就会出现当前页面的解析结果： 这时候我们可以看到，它帮我们提取出来了标题、发布时间、发布机构、发布机构链接、正文内容等等各种结果。而且目前来看都十分正确，时间也自动识别之后做了转码，是一个标准的时间格式。 接下来我们继续下滑，查看还有什么其他的字段，这里我们还可以看到有 html 字段，它和 text 不同的是，它包含了文章内容的真实 HTML 代码，因此图片也会包含在里面，如图所示： 另外最后面还有 images 字段，他以列表形式返回了文章套图及每一张图的链接，另外还有文章的站点名称、页面所用语言等等结果，如图所示： 当然我们也可以选择 JSON 格式的返回结果，其内容会更加丰富，例如图片还返回了其宽度、高度、图片描述等等内容，另外还有各种其他的结果如面包屑导航等等结果，如图所示： 经过手工核对，发现其返回的结果都是完全正确的，准确率相当之高！ 所以说，如果你对准确率要求没有那么非常非常严苛的情况下，使用 Diffbot 的服务可以帮助我们快速地提取页面中所需的结果，省去了我们绝大多数的手工劳动，可以说是非常赞了。 但是，我们也不能总在网页上这么试吧。其实 Diffbot 也提供了官方的 API 文档，让我们来一探究竟。

Diffbot API

Driffbot 提供了多种 API，如 Analyze API、Article API、Disscussion API 等。 下面我们以 Article API 为例来说明一下它的用法，其官方文档地址为：https://www.diffbot.com/dev/docs/article/，API 调用地址为：

1

https://api.diffbot.com/v3/article

我们可以用 GET 方式来进行请求，其中的 Token 和 URL 都可以以参数形式传递给这个 API，其必备的参数有：

• token：即 Developer Token
• url：即要解析的 URL 链接

另外它还有几个可选参数：

• fields：用来指定返回哪些字段，默认已经有了一些固定字段，这个参数可以指定还可以额外返回哪些可选字段
• paging：如果是多页文章的话，如果将这个参数设置为 false 则可以禁止多页内容拼接
• maxTags：可以设置返回的 Tag 最大数量，默认是 10 个
• tagConfidence：设置置信度的阈值，超过这个值的 Tag 才会被返回，默认是 0.5
• discussion：如果将这个参数设置为 false，那么就不会解析评论内容
• timeout：在解析的时候等待的最长时间，默认是 30 秒
• callback：为 JSONP 类型的请求而设计的回调

这里大家可能关注的就是 fields 字段了，在这里我专门做了一下梳理，首先是一些固定字段：

• type：文本的类型，这里就是 article 了
• title：文章的标题
• text：文章的纯文本内容，如果是分段内容，那么其中会以换行符来分隔
• html：提取结果的 HTML 内容
• date：文章的发布时间，其格式为 RFC 1123
• estimatedDate：如果日期时间不太明确，会返回一个预估的时间，如果文章超过两天或者没有发布日期，那么这个字段就不会返回
• author：作者
• authorUrl：作者的链接
• discussion：评论内容，和 Disscussion API 返回结果一样
• humanLanguage：语言类型，如英文还是中文等
• numPages：如果文章是多页的，这个参数会控制最大的翻页拼接数目
• nextPages：如果文章是多页的，这个参数可以指定文章后续链接
• siteName：站点名称
• publisherRegion：文章发布地区
• publisherCountry：文章发布国家
• pageUrl：文章链接
• resolvedPageUrl：如果文章是从 pageUrl 重定向过来的，则返回此内容
• tags：文章的标签或者文章包含的实体，根据自然语言处理技术和 DBpedia 计算生成，是一个列表，里面又包含了子字段：
  • label：标签名
  • count：标签出现的次数
  • score：标签置信度
  • rdfTypes：如果实体可以由多个资源表示，那么则返回相关的 URL
  • type：类型
  • uri：Diffbot Knowledge Graph 中的实体链接
• images：文章中包含的图片
• videos：文章中包含的视频
• breadcrumb：面包屑导航信息
• diffbotUri：Diffbot 内部的 URL 链接

以上的预定字段就是如果可以返回那就会返回的字段，是不能定制化配置的，另外我们还可以通过 fields 参数来指定扩展如下可选字段：

• quotes：引用信息
• sentiment：文章的情感值，-1 到 1 之间
• links：所有超链接的顶级链接
• querystring：请求的参数列表

好，以上便是这个 API 的用法，大家可以申请之后使用这个 API 来做智能化解析了。 下面我们用一个实例来看一下这个 API 的用法，代码如下：

1
2
3
4
5
6
7
8
9
10

import requests, json

url = 'https://api.diffbot.com/v3/article'
params = {
    'token': '77b41f6fbb24496d5113d528306528fa',
    'url': 'https://news.ifeng.com/c/7kQcQG2peWU',
    'fields': 'meta' 
}
response = requests.get(url, params=params)
print(json.dumps(response.json(), indent=2, ensure_ascii=False))

这里首先定义了 API 的链接，然后指定了 params 参数，即 GET 请求参数。 参数中包含了必选的 token、url 字段，也设置了可选的 fields 字段，其中 fields 为可选的扩展字段 meta 标签。 我们来看下运行结果，结果如下：

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

{
  "request": {
    "pageUrl": "https://news.ifeng.com/c/7kQcQG2peWU",
    "api": "article",
    "fields": "sentiment, meta",
    "version": 3
  },
  "objects": [
    {
      "date": "Wed, 20 Feb 2019 02:26:00 GMT",
      "images": [
        {
          "naturalHeight": 460,
          "width": 640,
          "diffbotUri": "image|3|-1139316034",
          "url": "http://e0.ifengimg.com/02/2019/0219/1731DC8A29EB2219C7F2773CF9CF319B3503D0A1_size382_w690_h460.png",
          "naturalWidth": 690,
          "primary": true,
          "height": 426
        },
        // ...
      ],
      "author": "中国新闻网",
      "estimatedDate": "Wed, 20 Feb 2019 06:47:52 GMT",
      "diffbotUri": "article|3|1591137208",
      "siteName": "ifeng.com",
      "type": "article",
      "title": "故宫，你低调点！故宫：不，实力已不允许我继续低调",
      "breadcrumb": [
        {
          "link": "https://news.ifeng.com/",
          "name": "资讯"
        },
        {
          "link": "https://news.ifeng.com/shanklist/3-35197-/",
          "name": "大陆"
        }
      ],
      "humanLanguage": "zh",
      "meta": {
        "og": {
          "og:time ": "2019-02-20 02:26:00",
          "og:image": "https://e0.ifengimg.com/02/2019/0219/1731DC8A29EB2219C7F2773CF9CF319B3503D0A1_size382_w690_h460.png",
          "og:category ": "凤凰资讯",
          "og: webtype": "news",
          "og:title": "故宫，你低调点！故宫：不，实力已不允许我继续低调",
          "og:url": "https://news.ifeng.com/c/7kQcQG2peWU",
          "og:description": "　　“我的名字叫紫禁城，快要600岁了，这上元的夜啊，总是让我沉醉，这么久了却从未停止。” 　　“重"
        },
        "referrer": "always",
        "description": "　　“我的名字叫紫禁城，快要600岁了，这上元的夜啊，总是让我沉醉，这么久了却从未停止。” 　　“重",
        "keywords": "故宫 紫禁城 故宫博物院 灯光 元宵节 博物馆 一票难求 元之 中新社 午门 杜洋 藏品 文化 皇帝 清明上河图 元宵 千里江山图卷 中英北京条约 中法北京条约 天津条约",
        "title": "故宫，你低调点！故宫：不，实力已不允许我继续低调_凤凰资讯"
      },
      "authorUrl": "https://feng.ifeng.com/author/308904",
      "pageUrl": "https://news.ifeng.com/c/7kQcQG2peWU",
      "html": "<p>“我的名字叫紫禁城，快要600岁了，这上元的夜啊，总是让我沉醉，这么久了却从未停止。...</blockquote> </blockquote>",
      "text": "“我的名字叫紫禁城，快要600岁了，这上元的夜啊，总是让我沉醉，这么久了却从未停止。”\\n“...",
      "authors": [
        {
          "name": "中国新闻网",
          "link": "https://feng.ifeng.com/author/308904"
        }
      ]
    }
  ]
}

可见其返回了如上的内容，是一个完整的 JSON 格式，其中包含了标题、正文、发布时间等等各种内容。 可见，不需要我们配置任何提取规则，我们就可以完成页面的分析和抓取，得来全不费功夫。

Diffbot SDK

另外 Diffbot 还提供了几乎所有语言的 SDK 支持，我们也可以使用 SDK 来实现如上功能，链接为：https://www.diffbot.com/dev/docs/libraries/，如果大家使用 Python 的话，可以直接使用 Python 的 SDK 即可，Python 的 SDK 链接为：https://github.com/diffbot/diffbot-python-client。 这个库并没有发布到 PyPi，需要自己下载并导入使用，另外这个库是使用 Python 2 写的，其实本质上就是调用了 requests 库，如果大家感兴趣的话可以看一下。 下面是一个调用示例：

1
2
3
4
5
6
7

from client import DiffbotClient,DiffbotCrawl

diffbot = DiffbotClient()
token = 'your_token'
url = 'http://shichuan.github.io/javascript-patterns/'
api = 'article'
response = diffbot.request(url, token, api)

通过这行代码我们就可以通过调用 Article API 来分析我们想要的 URL 链接了，返回结果是类似的。 具体的用法大家直接看下它的源码注释就一目了然了，还是很清楚的。 好，以上便是对智能化提取页面原理的基本介绍以及对 Diffbot 的用法的讲解，后面我会继续介绍其他的智能化解析方法以及一些相关实战，希望大家可以多多关注。

大家好，我是四毛，欢迎关注我的公众号。

有什么想要交流的可以在后台第一时间私我。

今天的文章内容主要是关于字体反爬。

目前已知的几个字体反爬的网站是猫眼，汽车之家，天眼查，起点中文网等等。 以前也看过这方面的文章，今天跟个老哥在交流的时候，终于实操了一把，弄懂了字体反爬是个啥玩意。下面听我慢慢道来。

本文用到的第三方库

fontTools

1、目标网站

url = “https://su.58.com/qztech/“

2、反爬虫机制

网页上看见的 后台源代码里面的 从上面可以看出，生这个字变成了乱码，请大家特别注意箭头所指的数字。

3、解决

1、确定反爬方法

在看了别人的解析文章之后，确定采取的是字体反爬机制，即网站定义了字体文件，然后进行相应的查找替换，在前端看起来，是没有任何差异的。其实从审查元素的也是可以看到的： 和大众点评的反爬差不多，都是通过 css 搞得。

2、寻找字体文件

以上面方框里的”customfont“为关键词搜了一下，发现就在源代码里面： 而且还有 base64，直接进行解密，但是解密出来的其实是乱码，这个时候其实要做的很简单，把解密后的内容保存为.ttf格式即可。

ttf 文件： *.ttf 是字体文件格式。TTF(TrueTypeFont)是 Apple 公司和 Microsoft 公司共同推出的字体文件格式,随着 windows 的流行,已经变成最常用的一种字体文件表示方式。 @font-face 是 CSS3 中的一个模块，主要是实现将自定义的 Web 字体嵌入到指定网页中去。

因为我们要对字体进行研究，所以必须将它打开，这里我是用的是FontCreator，打开以后是这个样子（其实很多字，在这里为了看的清楚，所以只截了下面的图）： 很明显，每个字可以看到字形和字形编码。 观察现在箭头指的地方和前面箭头指的地方的数字是不是一样啊，没错，就是通过这种方法进行映射的。 所以我们现在的思路似乎就是在源代码里找到箭头指的数字，然后再来字体里找到后替换就行了。 恭喜你，如果你也是这么想的，那你就掉坑里了。 因为每次访问，字体字形是不变的，但字符的编码确是变化的。因此，我们需要根据每次访问，动态解析字体文件。 字体 1： 字体 2： 所以想通过写死的方式也是行不通的。 这个时候我们就要对字体文件进行更深一步的研究了。 3、研究字体文件 刚刚的.ttf 文件我们是看不到内部的东西的，所以这个时候我们要对字体文件进行转换格式，将其转换为 xml 格式，然后来查看： 具体操作如下：

1
2
3

from fontTools.ttLib import TTFont
font_1 = TTFont('58_font_1.ttf')
font_base.saveXML('font_1.xml')

xml 的格式如下： 文件很长，我只截取了一部分。 仔细的观察一下，你会发现~这俩下面的 x,y,on 值都是一毛一样的。所以我们的思路就是以一个已知的字体文件为基本，然后将获取到的新的字体文件的每个文字对应的 x,y,on 值进行比较，如果相同，那么说明新的文字对就 可以在基础字体那里找到对应的文字，有点绕，下面举个小例子。 假设: “我” 在基本字体中的名为 uni1，对应的 x=1,y=1,n=1 新的字体文件中，一个名为 uni2 对应的 x，y, n 分别于上面的相等，那么这个时候就可以确定 uni2 对应的文字为”我”。 查资料的时候，发现在特殊情况下，有时候两个字体中的文字对应的 x,y 不相等，但是差距都是在某一个阈值之内，处理方法差不多，只不过上面是相等，这种情况下就是要比较一下。 其实，如果你用画图工具按照上面的 x 与 y 值把点给连起来，你会发现，就是汉字的字形~ 所以，到此总结一下：

一、将某次请求获取到的字体文件保存到本地[基本字体]； 二、用软件打开后，人工的找出每一个数字对应的编码[ 一定要保证顺序的正确，要不然会出事]； 三、我们以后访问网页时，需要保存新字体文件； 四、用 Fonttools 库对基本字体与新字体进行处理，找 到新的字体与基本字体之间的映射； 五、替换；

4、上代码

微信里上代码真的太丑了， 还是算了吧，微信后台关键词“字体加密” 即可获取 github 地址。 看一下成果

总结

其实这个流程最大的问题就是我们人工录入的基本字体的字典数据有可能是会发生变化的，这就导致我们后面还要手动去改。 现在，如果你已经看懂了本文，那么还不快去其他几个网站试试？ 如果有任何问题，欢迎交流。

大家好，我是四毛，欢迎大家关注我的公众号。

今天在工作中，碰到了第一次碰见的反爬虫机制，感觉很有意思，在这里记录一下，希望对大家有帮助。

今天用到的库：

requests [请求] lzstring [解压数据] pyexecjs [执行 JS]

简单粗暴，直接上网站部分源代码，因为这个网站应该不太希望别人来爬，所以就不上网站了。为什么这么说，因为刚开始请求的时候，老是给我返回 GO TO HELL ，哈哈。 这个网站点击鼠标右键审查元素，查看网页源代码是无法用的，但是这个好像只能防住小白啊，简单的按 F12 审查元素，CTRL+u 直接查看源代码（谷歌浏览器）。 这次的目的主要是为了获取下面的链接（重度打码）

xxxxxxxxxxx/xxxxx-003-a5f7xxxxxx?cid=xxxxx&xxx=siOE_q4XxBtwdoXqD0xxxx

其中，红色加粗的就是我们要找的变量了。

一、观察与抓包

首先，我观察到了网页源代码中的一部分 js 代码：

type=”text/javascript”>window“\x65\x76\x61\x6c”{e=function(c){return(c35?String.fromCharCode(c+29):c.toString(36))};if(!’’.replace(/^/,String)){while(c—)d[e(c)]=k[c]||e(c);k=[function(e){return d[e]}];e=function(){return’\\w+’};c=1;};while(c—)if(k[c])p=p.replace(new RegExp(‘\\b’+e(c)+’\\b’,’g’),k[c]);return p;}(‘29.2a({“2c”:1k,”26”:”21”,”22”:”1k.24”,”2o”:2n,”2s”:”2r”,”2l”:[“0-2f-2e.3.2”,”0-2j-2i.3.2”,”0-1r-1L.3.2”,”0-1r-1K.3.2”,”0-1e-1X.3.2”,”0-1e-1Q.3.2”,”0-1x-1W.3.2”,”0-1x-1M.3.2”,”0-1B-33.3.2”,”0-1B-36.3.2”,”0-1F-30.3.2”,”0-1F-2U.3.2”,”0-1g-2Y.3.2”,”0-1g-3e.3.2”,”0-1q-3i.3.2”,”0-1q-38.3.2”,”0-1o-37.3.2”,”0-1o-3a.3.2”,”0-1s-2B.3.2”,”0-1s-2E.3.2”,”0-1i-2v.3.2”,”0-1i-2y.3.2”,”0-1G-2P.3.2”,”0-1G-2S.3.2”,”0-1E-2R.3.2”,”0-1E-2H.3.2”,”0-1I-2L.3.2”,”0-1I-2J.3.2”,”0-t-2K.3.2”,”0-t-2G.3.2”,”0-p-2I.3.2”,”0-p-2M.3.2”,”0-o-2Q.3.2”,”0-o-2N.3.2”,”0-u-2O.3.2”,”0-u-2w.3.2”,”0-D-2x.3.2”,”0-D-2t.3.2”,”0-z-2u.3.2”,”0-z-2z.3.2”,”0-y-2D.3.2”,”0-y-2F.3.2”,”0-7-2A.3.2”,”0-7-2C.3.2”,”0-5-2T.3.2”,”0-5-3b.3.2”,”0-4-3c.3.2”,”0-4-39.3.2”,”0-g-3d.3.2”,”0-g-3h.3.2”,”0-i-3j.3.2”,”0-i-3f.3.2”,”0-b-3g.3.2”,”0-b-2X.3.2”,”0-d-2Z.3.2”,”0-d-2V.3.2”,”0-11-2W.3.2”,”0-11-34.3.2”,”0-13-35.3.2”,”0-13-31.3.2”,”0-10-32.3.2”,”0-10-1J.3.2”,”0-15-1O.3.2”,”0-15-1P.3.2”,”0-1d-1R.3.2”,……………………………………,’M4UxFsAsB9odxAIwA7WQOwObQAwCYBWXPAFlwHYBmY6ncousuvYgDlwDZ38BOT8zn3wcKARmICKOXK1qsmrFjlHdRAnKxEb1rBqK2ih5dSSbkteJXnEbpGm+SF47HLZSEElBOwRsEmlOqU3AS0JHYkWiRKJAwkYTYkQiQmIQwcShy0HDaUSpQuDJQ2HAG0BEFFWgTVQhw+3JRMOEw8Shq4PK……………………………………..GHXTzLjxjzN5CziB+3ODSAhicwuCyeBJ3YJD+eKhEi83fHm76PmK3Y/htPJFzw8LzOCqKTMcXGHr7Jm/nlPtuSUfPBAA===’‘\x73\x70\x6c\x69\x63’,0,{})) </script>

为了节省篇幅，我把一些替换成…….了。如果你对这些数据的解压有兴趣，请后台联系我。 我第一眼看见时，做了 2 件事： 1、把[\x65\x76\x61\x6c]，[ \x73\x70\x6c\x69\x63]，[\x7c]分别解码，解码出的结果为 eval 和 splic，| ； 注：其实这里看到 eval 时就应该想到可以试试直接用 pyexecjs 执行后面的那段 js 匿名函数，但是当时确实啥都没有想起来，很惭愧，后来复盘时才发现这一点。虽然执行了也会报错。 2、把那一长串的字母试着用 base64 解码了，但是解不出来； 然后，就只能再去其他 js 文件里找了，也找到了 js 代码，打了断点，但是看着还是很烦，于是这个时候我就没有在 js 上面死抠。 接着，我调转了方向，在 GITHUB，Google 运用了我祖传的高级搜索技巧，Finally，终于可以盘它了。

二、解密

下面开始解密： 1、数据解压 包含 A===的字符串到底时啥呢，其实这个是 js 的一种数据的压缩方式，知道了这种方式你就可以立即破解这种反爬虫机制了，反正我以前是不知道的，第一次见到，学习了。 在这里，lzstring 闪亮登场，运用这个库，执行下面的代码：

lzstring.LZString().decompressFromBase64(string)

这样就可以把上面的那串字符给解码了，解出来的数据像下面这样：

webp|png|025|024|073

没错，数据解压就是这么的简单； 2、看懂 JS 我们在上面解码出来了一个 splic 和一个[ | ]，再看看我们上面解压出来的数据，是不是很有感觉；但是，查了好一会资料，也没有发现 js 里面有这个方法，可能是在别的地方定义了；在我找到的资料里面，那个作者是直接用了 split，最后的结果是对的，走逻辑上也说得过去，不知道为什么这么设置成 splic，还希望有大神可以指教； 3、执行 JS 所以，到这里就很明显了，把解码以后以及解压以后的数据在替换会原 js 数据中，我们前面解码出来的 eval 就有用了，我找到的资料里面作者使用 node 做的，我没有安装 node 环境，所以我就直接用了 pyexecjs.eval 直接执行了，结果也正确； 4、梳理流程： 匹配长字符串==>lzstring 解压+解码后的字段==>拼凑成新的 js 代码==>pyexecjs 执行==>出结果 5、部分代码 执行的主要步骤和结果

execjs.eval(res)

没错，就是这么简单，res 就是替换后的 js，然后就可以直接出来我们上面网址中需要的两个字段了。 截个图吧

三、结语

到这里，今天的文章就结束了，总结一下就是知道了一种 JS 数据的压缩方式，并且学习了解压的方式，JS 的执行，同时写代码的时候**多观察，多想，多试**。 如果觉得还不错，欢迎动动手指关注我。

大家好，我是四毛，好久没有写东西了，欢迎大家关注我的公众号。

今天的文章是关于如何使用 requests 来爬取大众点评的数据。 看完本文，你可以：

1、了解大众点评的 CSS 反爬虫机制 2、破解反爬虫机制 3、使用 requests 即可正确获取到评论数，平均价格，服务，味道，环境数据，评论文本数据；

如果你想跟我继续交流的话，欢迎加我的个人微信，二维码在最后。 如果你想获取更多的代码，请关注我的公众号，并发送 “大众点评”即可。 同时，代码我并没有做太多的优化，因为没有大量的代理，爬不了太多的内容。 这里只是跟大家分享一下处理的流程。欢迎来公众号留言探讨。

正文开始。

1.前言

在工作生活中，发现越来越多的人对大众点评的数据感兴趣，而大众点评的反爬又是比较严格的。采取的策略差不多是宁可错杀一万，也不放过一个。有的时候正常浏览都会跳出验证码。 另外，在 PC 端的展示数据是通过 CSS 来控制的，从网页上看不出来太大的区别，但是用普通的脚本取获取时，会发现数据是获取不到的，具体的源代码是下面这样的： 然，在搜资料的时候，你会发现，很多教程都是用的 selenium 之类的方法，效率太低，没有啥技术含量。 所以，这篇文章的面向的对象就是 PC 端的大众点评；目标是解决这种反爬虫措施，使用 requests 获取到干净正确的数据； 跟着我，绝不会让你失望。

2.正文开始

相信搞过大众点评网站的同学都应该知道上面的这种是一个 css 反爬的方法，具体的解析操作，即将开始。

找到藏着秘密的 css

当我们的鼠标在上面框框内的 span 上面点击时，会发现右边部分会相应的发生变化： 这张图片很重要，很重要，很重要，我们要的值，几乎都从这里匹配出来。 这里我们看到了“vxt20”这个变量对应的两个像素值，前面的是控制用哪个数字，后面的是控制用哪一段的数字集合，先记下，后面要用，同时这里的值应该是 6； 这里其实就是整个破解流程最关键的一步了。在这里我们看到了一个链接。 瞎猫当死耗子吧，点进去看看。 https://s3plus.meituan.net/v1/mss_0a06a471f9514fc79c981b5466f56b91/svgtextcss/f556c0559161832a4c6192e097db3dc2.svg 你会发现，返回的是一些数字，我一开始是不知道这是啥玩意的，看过一些大神的解析才知道，其实这里就是我们看到的数字的来源，也就是整个破解的源头，知道了这些数字的含义，也就可以直接破解了整个反爬的流程。 现在直接看源代码： 可以看到这里面的几个关键数字：font-size：字体大小；还有几个 y 的值，我到后面才知道原来这个 y 是个阈值，起的是个控制的作用。 所以，这一反爬的原理就是：

获取属性值与偏移量和阈值映射，然后从 svg 文件中找到真数据。

现在我们就要用到上面的像素值了。

1.把所有的值取绝对值； 2.用后面的值来选择用哪个段的数字，这里的值是 103，所以使用第三个段的数字集合； 3.因为每个字体是 12 个像素，所以用 163/12=13.58，约等于 14，那么我们数一下第 14 个数字是啥，没错，是 6，和预期一样。你可以多试验几次。

以上，就是整个破解的逻辑过程。 画个流程图，装个逼：

3.Show Code

下面开始晒代码，俗话说得好，天下代码一大抄。 这里对主要的步骤代码进行解释， 如果你想获取更多的代码，请关注我的公众号，并发送 “大众点评”即可。。 1.获取 css_url 及 span 对应的 TAG 值；

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

def get_tag(_list, offset=1):
    # 从第一个开始查
    _new_list = [data[0:offset] for data in _list]

    if len(set(_new_list)) == 1:
        # 如果set后只有一个值，说明全部重复，这个时候就把offset加1
        offset += 1
        return get_tag(_list, offset)
    else:
        _return_data = [data[0:offset - 1] for data in _list][0]

        return _return_data

def get_css_and_tag(content):
    """
    :param url: 待爬链接
    :return: css链接，该span对应的tag
    """
    find_css_url = re.search(r'href="([^"]+svgtextcss[^"]+)"', content, re.M)
    if not find_css_url:
        raise Exception("cannot find css_url ,check")
    css_url = find_css_url.group(1)

    css_url = "https:" + css_url
    # 这个网页上不同的字段是由不同的css段来进行控制的，所以要找到这个评论数据对应的tag，在这里返回的值为vx；而在获取评论数据时，tag就是fu-;
    # 具体可以观察上面截图的3个span对应的属性值，相等的最长部分为vx
    class_tag = re.findall("<b class=\"(.*?)\"></b>", content)
    _tag = get_tag(class_tag)

    return css_url, _tag

2.获取属性与像素值的对应关系

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

def get_css_and_px_dict(css_url):
    con = requests.get(css_url, headers=headers).content.decode("utf-8")
    find_datas = re.findall(r'(\.[a-zA-Z0-9-]+)\{background:(\-\d+\.\d+)px (\-\d+\.\d+)px', con)
    css_name_and_px = {}
    for data in find_datas:
        # 属性对应的值
        span_class_attr_name= data[0][1:]
        # 偏移量
        offset = data[1]
        # 阈值
        position = data[2]
        css_name_and_px[span_class_attr_name] = [offset, position]
    return css_name_and_px

3.获取 svg 文件的 url

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

def get_svg_threshold_and_int_dict(css_url, _tag):
    con = requests.get(css_url, headers=headers).content.decode("utf-8")
    index_and_word_dict = {}
    # 根据tag值匹配到相应的svg的网址

    find_svg_url = re.search(r'span[class\^="%s"].*?background\-image: url\((.*?)\);' % _tag, con)
    if not find_svg_url:
        raise Exception("cannot find svg file, check")
    svg_url = find_svg_url.group(1)
    svg_url = "https:" + svg_url
    svg_content = requests.get(svg_url, headers=headers).content
    root = H.document_fromstring(svg_content)
    datas = root.xpath("//text")
    # 把阈值和对应的数字集合放入一个字典中
    last = 0
    for index, data in enumerate(datas):
        y = int(data.xpath('@y')[0])
        int_data = data.xpath('text()')[0]
        index_and_word_dict[int_data] = range(last, y+1)
        last = y
    return index_and_word_dict

4. 获取最终的值

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

def get_data(url ):
    """
    :param page_url: 待获取url
    :return:
    """
    con = requests.get(url, headers=headers).content.decode("utf-8")
    # 获取css url，及tag
    css_url, _tag = get_css(con)
    # 获取css对应名与像素的映射
    css_and_px_dict = get_css_and_px_dict(css_url)
    # 获取svg的阈值与数字集合的映射
    svg_threshold_and_int_dict = get_svg_threshold_and_int_dict(css_url, _tag)

    doc = etree.HTML(con)
    shops = doc.xpath('//div[@id="shop-all-list"]/ul/li')
    for shop in shops:
        # 店名
        name = shop.xpath('.//div[@class="tit"]/a')[0].attrib["title"]
        print name
        comment_num = 0

        comment_and_price_datas = shop.xpath('.//div[@class="comment"]')
        for comment_and_price_data in comment_and_price_datas:
            _comment_data = comment_and_price_data.xpath('a[@class="review-num"]/b/node()')
            # 遍历每一个node，这里node的类型不同，分别有etree._ElementStringResult(字符)，etree._Element（元素），etree._ElementUnicodeResult（字符）
            for _node in _comment_data:
                # 如果是字符，则直接取出
                if isinstance(_node, etree._ElementStringResult):
                    comment_num = comment_num * 10 + int(_node)
                else:
                    # 如果是span类型，则要去找数据
                    # span class的attr
                    span_class_attr_name = _node.attrib["class"]
                    # 偏移量，以及所处的段
                    offset, position = css_and_px_dict[span_class_attr_name]
                    index = abs(int(float(offset) ))
                    position = abs(int(float(position)))
                    # 判断
                    for key, value in svg_threshold_and_int_dict.iteritems():
                        if position in value:
                            threshold = int(math.ceil(index/12))
                            number = int(key[threshold])
                            comment_num = comment_num * 10 + number
            print comment_num

4.结果展示

评论条数数据

其实，其他的我都写好了，就不贴了

评论具体数据

5.结语

以上就是大众点评 Css 反爬破解的全部步骤和部分代码。 如果你想获取更多的代码，请关注我的公众号，并发送 “大众点评”即可。

最近一段时间没有更新原创文章了，主要是因为最近整个在忙硕士毕业的各种事情，毕业答辩完了以后休假了一小段时间，整个十二月就这么过去了。 转眼已经 2019 年了，其实去年我并没有写年终总结，现在到头来还是蛮后悔的，说实话总结其实还是蛮有必要的，现在就趁着这个时间来对自己的 2018 做一下总结，并立一下 2019 的一些 Flag，再等到 2020 年翻出来打脸吧。 世界上最了解自己的人当然是自己，一句话总结我的 2018 可以说是： 成就不算少，进步不算多 的一年。为什么成就不算少呢？因为今年可能发生的事相比我之前几年，自己取得了一些从未有的成就，或者完成了一些比较重要的事情。下面就先总结一下自己取得的一些成就吧： 1. 2018 年中出版了自己人生中第一本书籍作品《Python3网络爬虫开发实战》，半年多时间现在已经累计印刷九次，共计 45000 册，上市初长期处在京东科技新书榜第一位的位置，豆瓣评分 9.2。 2. 2018 年 1 月 20 日正式开始运营自己的个人公众号“进击的Coder”，发布了两百多篇文章，其中大约一半为原创，粉丝现在是 25000 多人。 3. 发布了自己开发的一款分布式网络爬虫管理框架 Gerapy，可以完成爬虫项目的配置、部署、管理、监控等功能，目前 GitHub 上 Star 数目将近 1000。 4. 在 GitHub 上创建和贡献了近 100 个项目，目前个人 Followers 达到 3000 人，收获 Star 数目在 2000 左右。 5. 开始从事机器学习、深度学习方向的研究和开发，并发布了自己开发的一套深度学习脚手架 ModelZoo，并不断对接各种模型，持续完善中。 6. 比较顺利地完成秋招，并最终拿到了微软的 Offer，达成理想的结果。 7. 完成了多次大型公开演讲并结识了许多优秀的业界大佬。 8. 顺利地完成了毕业论文和毕业答辩，成功取得北航硕士学位。 9. 凭借自己赚得人生第二桶金，实现收入翻番。 10. Last but not least，她。 当然还有一些其他的就不再一一列举了。这些可能有的跟一些大佬比起来可能真的是小巫见大巫，不过对我来说，这些成就我总体还是比较满意的。 在这些成就里，有些是真的改变我人生轨迹的事情，有些可能只是我人生路顺理成章踏过去的事情，有的可能只是昙花一现几年后毫无价值的东西。但拿掉其中一个，不管是看似有用或者没用的，也可能会产生意想不到的影响，他们确实是我真实经历过，并出现在我生命旅途中的一部分。 本来把成就一个个地展开来说，但后来想想没这个必要。昨日取得的成就就让它过去吧，不要念过去，把更多的精力着眼在未来吧。重要的在于，我在这一年里收获了多少，这些收获的东西能够为我未来的成长带来多少价值。以及另外重要的是，对过去的反思，我还有哪些做的不好的地方，我需要在未来做怎样的调整。 所以为什么说进步不算多呢？虽然自己达成了某些目标，但我真的没怎么感觉到自己相比去年年初的自己有特别大的成长，或许一切都是潜移默化的，或许真的把我现在放回到 2018年初，和现在的自己相比，我才会感觉到差别，但现在自己仿佛真的感觉自己本身和之前没有太多不同。但总的来说，我还有非常多需要反思和改进的地方。 下面再好好反思下自己吧，我总觉得自己的这一年，自己的有些方面做得不够好，总体体现在这么几个方面吧： 1. 拖延症。还是觉得自己的拖延症太严重，执行力还不够好。有些事总是会拖个好几天才完成，没太有恒心。或者有的时候这件事到了要做的时间，却又不想做。之前也会有，但是感觉今年犯的很严重。其实我挺佩服那些持之以恒的人的，自制力和执行力真的很重要。 2. 记录少。挺多自己觉得会的东西，由于懒或者忙，没有记下来，其实还是因为懒。到头来发现真正学会的其实仅仅就是自己记录的部分，因为当时没做记录的，又忘得一干二净了。所以我总体感觉，今年输出的文章并不多。 3. 白忙活。这一年来，其实回想起来，感觉做的无用功是很多了。许多事情感觉做完了之后，真正的价值并不大，所以这个真的需要我来好好权衡。 4. 虎头蛇尾。由于自己的很多事情安排的满满当当，所以有的项目可能就容易被搁置了，导致有一些项目做得虎头蛇尾，草草收场，想想还是很可惜的，但有时候就是缺乏那重新捡起来的一步动力，这个必须得改。 5. 时间规划。我使用 Todoist 已经好多年了，感谢它帮我完成了大部分的时间规划，但有些时候发现还是有些不够好。我多少还会有一些小事优先，大事拖延的倾向，但总体来说已经把握得还算可以了，还得继续加油。 6. 缺乏锻炼。平时事情安排的挺多，有时候也懒得去健身房锻炼，唯一锻炼的时间就是睡前的几分钟了，但是效果不大。可能偶尔一时兴起会去几次健身房，但是还是难以坚持下来。虽然还没感觉到身体有啥不适，但也得加强锻炼了。 所以总体感觉下来，感觉到自己做的不够好的地方还有很多，或许真的要改正对我来说真的挺难，但我也要尽力去做的更好。 这一年中，领悟或贯彻的一些理念也不少，其实太多太多，在这里也不能一一列举了，这里就把现在想到的一些说一下吧： 1. 做一件事前，想想这件事的意义和成本有多大，别把时间浪费在无意义的事情上面。 2. 记录和总结真的很重要。别以为自己当时记住了，等回过头来，你有时候会发现自己的收获就是你所记录的那一部分，没有记录的你想也想不起来了。 3. 如果自己没本事，认识很多牛人，没什么太大意义，重要的还是自己要牛逼，多投资自己。自己牛逼了，别人就都会看到你了。 4. 成年人、社会人的世界，有太多大家都已经默认的规矩，自己要去懂，没几个人会教你。 5. 钱，不能保证能买到所有东西，但是它的确可以提供便利或者免去不必要的麻烦。它是可以增加幸福感的。 6. 如果想要赚钱，最好不要选和时间或精力成正比的事情，多考虑复利。 7. 如果一件东西，花了钱，买到的又不是达到自己预期的，这是双亏。如果买到的是自己所满意或喜欢的的，这就是值的。 8. 选择比努力很重要，眼界比本事更重要。 9. 所有的一切，如果有能力，就不要将就，可能一时由于自己的能力还无法改变，但一定不要丢了改变下去的动力。 10. 如果一件事是自己不喜欢的但是非要做，那就用最短的时间去完成。 11. 健康第一。 还有很多，就暂且写这些吧。这是我现阶段所领悟到的一些东西，也是我成长路上的一种认知转变过程吧。也可能再过几年我就不会这么想了。不过现阶段我会秉承这些理念继续前行。 最后就立几个 2019 年的 Flag 吧（等明年翻出来打脸： 1. 踏入社会和职场的第一年，好好工作，把握好节奏。 2. 完成《Python3网络爬虫开发实战（第二版）》以及现在初步规划的另外的两部作品（名称尚未完全确定暂不透露。 3. 微信公众号读者粉丝在 2019 年底达到 10 万。 4. 自己的 Gerapy、ModelZoo 两个项目持续运营维护，力求完善。 5. 坚持记录，持续输出（内容规划了挺多），达到自己内心中设定的基本目标。 6. 2019 年年收入比 2018 年继续翻番。 7. 结识更多的人，扩展更广的人脉。 8. Last but not least，和她好好地在一起，过我们的向往的生活，做喜欢的事情。 好啦，感谢大家一直以来的支持！新的一年，继续努力！愿我们都成为更好的自己！

Hello 各位小伙伴 雷门吼！

在教程之前首先申明！此教程适合土豪不缺钱的玩家

潜水了许久了，今天来更新点东西~ 今天说点啥呢？ 那就是代理！！ 代理在爬虫界的重要作用相信各位应该清楚吧！毕竟绝大部分反爬可以靠代理解决；不能被代理解决的也得要代理配合解决。 市面上各种代理也是琳琅满目的说··· 相信大家最喜欢用的之一应该就是 某布云。 根据官网的显示他他家的代理是这个样子的：

• 无须切换 IP，每一个请求一个随机 IP。

哇！感觉很爽的样子今天我们就来实现一个类似的代理！ 其实 So Easy！ 我们需要借助 公有云 来实现。 下面我以 AWS 举例(其它公有云操作类似，唯一的区别的就是：各个服务的名字不同而已)

1. 首先我们需要需要使用 EC2 来建立一个代理（Google Could 叫 GCE）
   1. 安装 Squid（当然你可以使用其它的代理）
      1. 无认证安装参考这儿(点我)设置代理服务器那一段
      2. MySQL 认证安装(点我)
      3. Note: 请注意检查！！！务必设置 Ipv4 转发
2. 安装完成之后我们制作启动模板（毕竟一个 EC2 一个 IP 你总不能安装很多很多台吧！会死人的）
   1. 注意设置你的安全组！正常情况下 入站规则只应该有你需要的端口（squid 使用的端口一定要放心！嫌麻烦的小伙伴儿 可以进出都放行全部流量！）出站则是全部流量！
   2. 启动 EC2 的时候选择安全组一定要看清是否是设置过放行的规则！ 不要选错了！
   3. 
   4. 
   5. 
   6. 好了现在就可以批量启动了！
   7. 实例数量就是需要同时有多少个 IP 就启动多少个了。
   8. 
3. 设置前端负载均衡（提供一个固定地址，这个地址负责随机将请求转发到后端代理服务器上）
   1. 
   2. 必须使用 TCP 四层负载！原因为啥大家自己百度一哈
   3. 
   4. 
   5. 
   6. 等待负载均衡器启动完成！
   7. 启动完成后获取负载地址
4. 下面来测试一下效果！
   1. 

以上完毕！你可以不停的重启 Ec2 实例！你就有百万 IP 池啦！！（前提是你有钱啊） 下面是重启 Ec2 的示例：

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

import boto3
from boto3 import setup_default_session


setup_default_session(aws_access_key_id='XXXXXX',
                      aws_secret_access_key='XXXXXX',
                      region_name='区域')

ec2 = boto3.client('ec2')


def get_public_ip_address():
    """
    获取IP和实例ID
    :return: {实例ID: ip}
    """
    response = ec2.describe_instances()
    reservations = response.get('Reservations')
    instances = [i.get('Instances')[0] for i in reservations]
    instance_id_public_ip_address = {i.get('InstanceId'): i.get('PublicIpAddress') for i in instances}
    return instance_id_public_ip_address


def reboot_ec2(ip):
    """重启实例
    :param ip:
    :return:
    """
    instance_id_public_ip_address = get_public_ip_address()
    instance_id = instance_id_public_ip_address.get(ip)
    try:
        ec2.reboot_instances(InstanceIds=[instance_id], DryRun=True)
    except ClientError as e:
        if 'DryRunOperation' not in str(e):
            print("You don't have permission to reboot instances.")
            raise

    try:
        response = ec2.reboot_instances(InstanceIds=[instance_id], DryRun=False)
        print('Success', response)
    except ClientError as e:
        print('Error', e)

前言

随着大数据时代的到来，爬虫已经成了获取数据的必不可少的方式，做过爬虫的想必都深有体会，爬取的时候莫名其妙 IP 就被网站封掉了，毕竟各大网站也不想自己的数据被轻易地爬走。 对于爬虫来说，为了解决封禁 IP 的问题，一个有效的方式就是使用代理，使用代理之后可以让爬虫伪装自己的真实 IP，如果使用大量的随机的代理进行爬取，那么网站就不知道是我们的爬虫一直在爬取了，这样就有效地解决了反爬的问题。 那么问题来了，使用什么代理好呢？这里指的代理一般是 HTTP 代理，主要用于数据爬取。现在打开搜索引擎一搜 HTTP 代理，免费的、付费的太多太多品牌，我们该如何选择呢？看完这一篇文章，想必你心中就有了答案。 对于免费代理，其实想都不用想了，可用率能超过 10% 就已经是谢天谢地了。真正靠谱的代理还是需要花钱买的，那这么多家到底哪家可用率高？哪家响应速度快？哪家比较稳定？哪家性价比比较高？为此，我对市面上比较流行的多家付费代理针对可用率、爬取速度、爬取稳定性、价格、安全性、请求限制等做了详细的评测，让我们来一起看一下到底哪家更强！

测评范围

免费代理

在这里我主要测试的是付费代理，免费代理可用率太低，几乎不会超过 10%，但为了作为对比，我选取了西刺免费代理进行了测试。

付费代理

付费代理我选取了站大爷、芝麻 HTTP 代理、太阳 HTTP 代理、讯代理、快代理、蘑菇代理、阿布云代理、全网代理、云代理、大象代理、多贝云进行了对比评测，购买了他们的各个不同级别的套餐使用同样的网络环境进行了测评，详情如下：

注：其中蘑菇代理、太阳 HTTP 代理、芝麻 HTTP 代理的默认版表示此网站只有这一种代理，不同套餐仅是时长区别，代理质量没有差别。 嗯，我把上面的套餐全部买了一遍，以供下面的评测使用。

测评目标

本次测评主要分析代理的可用率、响应速度、稳定性、价格、安全性、使用频率等因素，下面我们来一一进行说明。

可用率

可用率就是提取的这些代理中可以正常使用的比率。假如我们无法使用这个代理请求某个网站或者访问超时，那么就代表这个代理不可用，在这里我的测试样本大小为 500，即提取 500 个代理，看看里面可用的比率多少。

响应速度

响应速度可以用耗费时间来衡量，即计算使用这个代理请求网站一直到得到响应所耗费的时间。时间越短，证明代理的响应速度越快，这里同样是 500 个样本，计算时只对正常可用的代理做统计，计算耗费时间的平均值。

稳定性

由于爬虫时我们需要使用大量代理，如果一个代理响应速度特别快，很快就能得到响应，而下一次请求使用的代理响应速度特别慢，等了三十秒才得到响应，那势必会影响爬取效率，所以我们需要看下商家提供的这些代理稳定性怎样，总不能这一个特别快，下一个又慢的不行。所以这里我们需要统计一下耗费时间的方差，方差越大，证明稳定性越差。

价格

价格，这个当然是需要考虑的内容，如果一个代理不论是响应速度还是稳定性都特别不错，但是价格非常非常高，这也是不可接受的。

安全性

这的确也是需要考虑的因素，比如一旦不小心把代理提取的 API 泄露出去了，别人就肆意使用我们的 API 提取代理使用，而一直耗费的是我们的套餐。另外一旦别人通过某些手段获取了我们的代理列表，而这些代理是没有安全验证的，这也会导致别人偷偷使用我们的代理。在生产环境上，这方面尤其需要注意。

使用频率

有些代理套餐在 API 调用提取代理时有频率限制，有的代理套餐则会限制请求频率，这些因素都会或多或少影响爬虫的效率，这部分因素我们也需要考虑进来。

测评标准

要做标准的测评，那就必须在标准的测评环境下进行，且尽可能排除一些杂项的干扰，如网络波动、传输延迟等一系列的影响。

主机选取

由于我的个人笔记本是使用 WiFi 上网的，所以可能会有网络波动，而且实际带宽其实并不太好把控，因此它并不适合来做标准评测使用。评测需要在一个网络稳定的条件下进行，而且多个代理的评测环境必须相同，在此我选择了一台腾讯云主机作为测试，主机配置如下：

这样我们就可以保证一个标准统一的测试环境了。

现取现测

另外在评测时还需要遵循一个原则，那就是现取现测，即取一个测一个。现在很多付费代理网站都提供了 API 接口，我们可以一次性提取多个代理，但是这样会导致一个问题，每个代理在提取出来的时候，商家是会尽量保证它的可用性的，但过一段时间，这个代理可能就不好用了，所以假如我们一次性提取出来了 100 个代理，但是这 100 个代理并没有同时参与测试，后面的代理就会经历一个的等待期，过一段时间再测这些代理的话，肯定会影响后半部分代理的有效性，所以这里我们将提取的数量统一设置成 1，即请求一次接口获取一个代理，然后立即进行测试，这样可以保证测试的公平性，排除了不同代理有效期的干扰。

时间计算

由于我们有一项是测试代理的响应速度，所以我们需要计算程序请求之前和得到响应之后的时间差，这里我们使用的测试 Python 库是 requests，所以我们就计算发起请求和得到响应之间的时间差即可，时间计算方法如下所示：

1
2
3
4

start_time = time.time()
requests.get(test_url, timeout=timeout, proxies=proxies)
end_time = time.time()
used_time = end_time - start_time

这里 used_time 就是使用代理请求的耗时，这样测试的就仅仅是发起请求到得到响应的时间。

测试链接

测试时我们也需要使用一个稳定的且没有反爬虫的链接，这样可以排除服务器的干扰，这里我们使用百度来作为测试目标。

超时限制

在测试时免不了的会遇到代理请求超时的问题，所以这里我们也需要统一一个超时时间，这里设置为 60 秒，如果使用代理请求百度，60 秒还没有得到响应，那就视为该代理无效。

测试数量

要做测评，那么样本不能太小，如只有十几次测试是不能轻易下结论的，这里我选取了一个适中的测评数量 500，即每个套餐获取 500 个代理进行测试。

测评过程

嗯，测评过程这边主要说一下测评的代码逻辑，首先测的时候是取一个测一个的，所以这里定义了一个 test_proxy() 方法：

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

test_url = 'https://www.baidu.com/'
timeout = 60

def test_proxy(proxy):
    try:
        proxies = {
            'https': 'http://' + proxy
        }
        start_time = time.time()
        requests.get(test_url, timeout=timeout, proxies=proxies)
        end_time = time.time()
        used_time = end_time - start_time
        print('Proxy Valid', 'Used Time:', used_time)
        return True, used_time
    except (ProxyError, ConnectTimeout, SSLError, ReadTimeout, ConnectionError):
        print('Proxy Invalid:', proxy)
        return False, None

这里需要传入一个参数 proxy，代表一个代理，即 IP 加端口组成的代理，然后这里使用了 requests 的 proxies 参数传递给 get() 方法。对于代理无效的检测，这里判断了 | ProxyError, ConnectTimeout, SSLError, ReadTimeout, ConnectionError 这几种异常，如果发生了这些异常统统视为代理无效，返回错误。如果在 timeout 60 秒内得到了响应，那么就计算其耗费时间并返回。 在主程序里，就是获取 API 然后统计结果了，代码如下：

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

max = 500

def main():
    print('Testing')
    used_time_list = []
    valid_count = 0
    total_count = 0
    while True:
        flag, result = get_page(api_url)
        if flag:
            proxy = result.strip()
            if is_proxy(proxy):
                total_count += 1
                print('Testing proxy', proxy)
                test_flag, test_result = test_proxy(proxy=proxy)
                if test_flag:
                    valid_count += 1
                    used_time_list.append(test_result)
                stats_result(used_time_list, valid_count, total_count)
        time.sleep(wait)
        if total_count == max:
            break

这里加了一些判断，如 is_proxy() 方法判断了获取的是不是符合有效的代理规则，即判断它是不是 IP 加端口的形式，这样可以排除 API 返回一些错误信息的干扰。另外这里设置了 total_count 和 valid_count 变量，只有符合代理规则的代理参与了测试，这样才算一次有效测试，total_count 加一，如果测试可用，那么 valid_count 加一并记录耗费时间。最后调用了 stats_results 方法进行了统计：

1
2
3
4
5
6
7
8
9
10
11

import numpy as np

def stats_result(used_time_list, valid_count, total_count):
    if not used_time_list or not total_count:
        return
    used_time_array = np.asarray(used_time_list, np.float32)
    print('Total Count:', total_count,
          'Valid Count:', valid_count,
          'Valid Percent: %.2f%%' % (valid_count * 100.0 / total_count),
          'Used Time Mean:', used_time_array.mean(),
          'Used Time Var', used_time_array.var())

这里使用了 Numpy 来统计了耗费时间的均值和方差，分别反映代理的响应速度和稳定性。 嗯，就这样，利用这个方法我对各个不同的代理套餐逐一进行了测试。

测评结果

经过测评，初步得到如下统计结果：

注：

• 表中的响应时间方差越大，代表稳定性越低。
• 阿布云代理经典版方差较小是因为它是长时间锁定了同一个 IP，因此极其稳定，但每秒最大请求默认 5 次。
• 多贝云代理套餐一二方差较小是因为它是长时间锁定了同一个 IP，因此极其稳定，但每秒最大请求默认 20 次。

测评分析

下面我们将从各个方面分析一下各个套餐的优劣。

可用率

通过可用率统计，我们可以发现可用率较高的代理套餐有：

响应速度

通过平均响应速度判别，我们可以发现响应速度较快的代理套餐有：

稳定性

通过平均响应速度方差分析，我们可以发现稳定性较高的代理套餐有：

价格

我们可以看一下各个套餐的价格：

安全性

对于安全性，此处主要考虑提取 API 是否有访问验证，使用代理时是否有访问验证，即可以通过设置白名单来控制哪些可以使用。 其中只有芝麻 HTTP 代理、太阳 HTTP 代理默认使用了白名单限制，即只有将使用 IP 添加到白名单才可以使用，可以有效控制使用权限。 另外阿布云代理提供了隧道代理验证，只有成功配置了用户名和密码才可以正常使用。 所以在此归纳如下：

调取频率

不同的接口具有不同的 API 调用频率限制，归纳如下：

在此可以简单总结如下：

级别

特色功能

除了常规的测试之外，我这边还选取了某些套餐的与众不同之处进行说明，这些特点有的算是缺点，有的算是优点，现列举如下：

测评综合

分项了解了各个代理套餐的可用率、响应速度、稳定性、性价比、安全性等内容之后，最后做一下总结：

所以在综合来看比较推荐的有：芝麻代理、快代理、讯代理、阿布云、多贝云代理，详细的对比结果可以参照表格。 以上便是各家代理的详细对比测评情况，希望此文能够在大家选购代理的时候有所帮助。

大家好，我是四毛，下面的是我的公众号，欢迎关注。

今天的内容主要讲的是破解一个网站的 rsa 加密，当然肯定不是破解这个算法，而是找到加密的参数，正确模拟这个算法即可。

1. 什么是 rsa 算法

下面的资料摘抄自阮一峰老师的文章， 点这里了解更多 1976 年，两位美国计算机学家 Whitfield Diffie 和 Martin Hellman，提出了一种崭新构思，可以在不直接传递密钥的情况下，完成解密。这被称为“Diffie-Hellman 密钥交换算法”。这个算法启发了其他科学家。人们认识到，加密和解密可以使用不同的规则，只要这两种规则之间存在某种对应关系即可，这样就避免了直接传递密钥。 这种新的加密模式被称为”非对称加密算法”。

（1）乙方生成两把密钥（公钥和私钥）。公钥是公开的，任何人都可以获得，私钥则是保密的。 （2）甲方获取乙方的公钥，然后用它对信息加密。 （3）乙方得到加密后的信息，用私钥解密。

如果公钥加密的信息只有私钥解得开，那么只要私钥不泄漏，通信就是安全的。

2. 研究目标

从我要研究的网站来说，就是根据参数得到正确的公钥，加密以后返回给服务器，让服务器使用私钥可以解密出正确的数据即可。 同时，本文不会将具体的网站说出来，只是给大家提供一个解决问题的思路。

3. 开始

3.1 抓包找参数

首先，打开某个网站的登录页面，输入用户名，密码，验证码之类的参数， 抓包看到了下面这个页面： 我实际输入的值全是 1, 然后都被加密了， 没办法，只能去找加密的方法了。 经过一番搜索过后，才发现，原来加密的算法就在源代码里面，这里截个图： 从这里就可以看到具体的算法名以及相关的参数了，你会说，这是什么算法我都不知道啊？搜啊，用关键词搜一下就能知道了。 同时，是不是觉得这个网站好傻逼，这不太简单了吗？ 肯定不是！！！ 这么简单，说明此处也是必有玄机！！！ 至于什么玄机，到后面说，都是泪。

3.2 分析加密流程

首先， 我们知道了公钥以后，解析这个公钥，就可以得到相关的参数，给大家找了示例代码

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

# /usr/bin/python
# encoding: utf-8

import base64

def str2key(s):
    # 对字符串解码
    b_str = base64.b64decode(s)

    if len(b_str) < 162:
        return False

    hex_str = ''

    # 按位转换成16进制
    for x in b_str:
        h = hex(ord(x))[2:]
        h = h.rjust(2, '0')
        hex_str += h

    # 找到模数和指数的开头结束位置
    m_start = 29 * 2
    e_start = 159 * 2
    m_len = 128 * 2
    e_len = 3 * 2

    modulus = hex_str[m_start:m_start + m_len]
    exponent = hex_str[e_start:e_start + e_len]

    return modulus,exponent

if __name__ == "__main__":

    pubkey = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDC7kw8r6tq43pwApYvkJ5laljaN9BZb21TAIfT/vexbobzH7Q8SUdP5uDPXEBKzOjx2L28y7Xs1d9v3tdPfKI2LR7PAzWBmDMn8riHrDDNpUpJnlAGUqJG9ooPn8j7YNpcxCa1iybOlc2kEhmJn5uwoanQq+CA6agNkqly2H4j6wIDAQAB"
    key = str2key(pubkey)
    print key

相应的输出

1
2

('c2ee4c3cafab6ae37a7002962f909e656a58da37d0596f6d530087d3fef7b16e86f31fb43c49474fe6e0cf5c404acce8f1d8bdbccbb5ecd5df6fded74f7ca2362d1ecf033581983327f2b887ac30cda54a499e500652a246f68a0f9fc8fb60da5cc426b58b26ce95cda41219899f9bb0a1a9d0abe080e9a80d92a972d87e23eb',
'010001')

从代码中可以看出，解析了公钥之后得到了两个值，一个就是 010001，和我们在网站源代码里面找到的值是一样的。所以，源代码里面的参数我们应该就是可以直接使用的，是不是有种找到组织的赶脚。 接下来，利用下面的代码，来对数据进行加密

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

import rsa
import binascii
def en_test():
    param_1 = "010001"
    # 某次我找到的
    param_2 = "955120AB9334B7CD52FCDB422DBF564AFD46DEBDC706F33502BBFAD9DD216A22E4D5012CB70F28473B46FB7190D08C31B4B8E76B5112ACE1C5552408961530B1C932DEEA8FC38A9A624AD22073F56F02BF453DD2C1FEA0164106D6B099CC9E5EC88C356FC164FCA47C766DD565D3D11048D27F2DD4221A0B26AB59BD7D09841F"
    message = 'nihao'
    modulus = int(param_2, 16)
    exponent = int(param_1, 16)
    rsa_pubkey = rsa.PublicKey(modulus, exponent)
    crypto = rsa.encrypt(message, rsa_pubkey)
    data = binascii.b2a_hex(crypto)

    print data

if __name__ == '__main__':
    en_test()

但是当我这样做完，进行模拟登录，还以为自己很牛逼的时候，服务器却给我返回了这样的结果， 目瞪狗呆啊：

1

{"Status":false,"ResultValue":"","StatusCode":"REFRESH","StatusMessage":"请尝试重新登录","RecordCount":0,"Data":null}

可以看到信息提示要刷新，但是当时是百思不得其解，为毛线要刷新？ 困惑了一会之后，我再次从头走了一遍流程，这下我才发现，原来源代码里面的那个长长的数据是会改变的，直到这个时候，我才意识到为什么要我刷新。。。。。。 服务器啊，你就不能直接说参数错误吗？刷新你大爷啊。 果然，我还是太年轻啊。

果然，天上掉下的绝不是馅饼，绝逼是个陷阱。

知道这个坑以后就好办了，用个正则匹配一下就行了，而结果也是对的：

1

{"Status":true,"ResultValue":"","StatusCode":"OK","StatusMessage":"成功","RecordCount":0,"Data":{"LoginUrl":"/System/Welcome"}}

4 总结

到这里这篇文章就结束了，这个案例相对于来说很简单，而且为了保护网站的隐私，所以没办法展开说。 有些网站的加密方式是很变态的，比如网易云音乐，知晓常见的加密方法，就可以处理大部分的情况了。 其实，网易云音乐并不是一定要加密， 有想知道非加密的方法的，可以关注我，私聊我。有点敏感，就不写文章了。 反正，我爬了 1000W+的网易云音乐都是不加密的～～ 如果你有类似的问题待解决或者想了解的更清楚的细节的，欢迎关注我的公众号以后，后台私我一下。

最近和几个朋友开发项目，期间使用了一台服务器跑模型，这台服务器是多人公用的，很多人都在上面有自己的账号，互不干涉内政，一切看起来十分井然有序。近期，这个服务器上刚挂载了一块新硬盘，是一位朋友使用 root 账号挂载的，然后将磁盘映射到某个文件夹下。然而挂载好了之后发现使用普通账号没有权限在文件夹下操作，无法创建文件，于是他干脆就直接把文件夹权限改成 777 了。我心想，这还了得，改成 777 了，其他人在里面乱改咋办？会出人命的！所以，我就这件事详细梳理了一下 Linux 下的用户、用户组、文件权限等基本知识，看完这些，以后不要动不动就把文件夹改成 777 权限了。

基本操作

首选我们梳理一下 Linux 下的用户、用户组、文件权限等基本知识，然后后面通过一个案例来实际演示一下权限设置的一些操作。 首先 Linux 系统中，是有用户和用户组的概念的，用户就是身份的象征，我们必须以某一个用户身份来操作一个系统，实际上这就对应着我们登录系统时的账号。而用户组就是一些用户的集合，我们可以通过用户组来划分和统一管理某些用户。 比如我要在微信发一条朋友圈，我只想给我的亲人们看，难道我发的时候还要一个个去勾选所有的人？这未免太麻烦了。为了解决这问题，微信里面就有了标签的概念，我们可以提前给好友以标签的方式分类，发的时候直接勾选某个标签就好了，简单高效。实际上这就是用户组的概念，我们可以将某些人进行分组和归类，到时候只需要指定类别或组别就可以了，而不用一个个人去对号入座，从而节省了大量时间。 在 Linux 中，一个用户是可以属于多个组的，一个组也是可以包含多个用户的，下面我以一台 Ubuntu Linux 为例来演示一下相关的命令和操作。

用户和用户组

首先查看所有用户，命令如下：

1

cut -d':' -f 1 /etc/passwd

结果：

1
2
3
4
5
6
7

root
daemon
bin
sys
...
ubuntu
mysql

这里一行就是一个用户名，由于太多，部分就省略了，实际上这个命令就是从密码文件中把用户名单独列出来了。 然后查看所有用户组，命令也是类似的：

1

cut -d':' -f 1 /etc/group

结果：

1
2
3
4
5
6
7

root
daemon
bin
sys
...
ubuntu
mysql

结果基本是类似的，因为每个用户在被创建的时候都会自动创建一个同名的组作为其默认的用户组。 这里我是使用 ubuntu 这个账号来登录的，下面我来看下 ubuntu 这个账号是属于哪些组。 查看一个用户所属组的命令格式如下：

1

gorups <username>

这里就是 groups 命令加上用户名就能查看该用户名所属的组了，如果不加用户名的话就默认是当前用户。 例如查看 ubuntu 这个用户所属于的组，命令如下：

1

groups ubuntu

结果：

1

ubuntu : ubuntu adm cdrom sudo dip plugdev lxd lpadmin sambashare

还不少，这个用户被分配到了很多组下，比如同名的组 ubuntu，还有 sudo 组，另外还有一些其他的组。 其中 sudo 组比较特殊，如果被分到了这个组里面就代表该账号拥有 root 权限，可以使用 sudo 命令。 了解了怎样查看用户所属的组，我们也应该反过来了解如何查看一个用户组里面包含哪些用户啊。 查看某个用户组下所有用户命令如下：

1

members <group>

不过这个命令不是自带的，需要额外安装 members 包，命令如下：

1

sudo apt-get install members

例如查看 sudo 用户组下的所有用户，即拥有 root 权限的用户：

1

members sudo

结果：

1

ubuntu hadoop

可以看到拥有 root 权限的用户有两个，ubuntu 和 hadoop，当然不同的机器结果肯定是不一样的。 接下来介绍一个比较有用的命令，就是 id 命令，它可以用来查看用户的所属组别，格式如下：

1

id <username>

例如查看 ubuntu 用户的信息，就是这样：

1

id ubuntu

结果：

1

uid=500(ubuntu) gid=500(ubuntu) groups=500(ubuntu),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),110(lxd),115(lpadmin),116(sambashare)

这里有一个 gid，作为主工作组，后面还有个 groups，它列出了用户所在的所有组。主工作组只有一个，而后者的数量则不限。可以看到用户组的结果和使用 groups 命令看到的结果是一致的。 接下来我们再来了解一下如何创建一个用户和怎样为用户分配组别。 添加一个用户命令格式如下：

1

sudo adduser <username>

比如我要添加一个用户 cqc，命令就可以这么写：

1

sudo adduser cqc

这里使用的命令前面都带有 sudo，因为毕竟是系统级别的操作。 添加一个组的命令格式如下：

1

sudo groupadd <group>

格式是类似的，后面跟一个组的名称就可以了，例如我要为我的实验室创建一个用户组，那么就可以使用如下命令：

1

sudo groupadd lab

创建完了用户和组，那得把它们关联起来吧，关联的意思就是把某个用户加入到某个组里面，命令格式如下：

1

sudo adduser <username> <group>

或者使用 usermod 命令：

1

sudo usermod -G <group> <username>

如果要添加多个组的话，可以通过 -a 选项指定多个名称：

1

sudo usermod -aG <group1,group2,group3..> <username>

例如我要将 cqc 用户添加到 sudo 用户组中，命令就是：

1

sudo adduser cqc sudo

或：

1

sudo usermod -G sudo cqc

这样就为用户和用户组做好关联了。

文件权限管理

了解了这些之后，我们再来了解一下文件权限的相关知识，下面我们先随便找一个目录，查看一下文件的列表。 列出某个目录下文件详细信息的命令如下：

1

ll

或者使用：

1

ls -l

比如我这里列出了 /etc/nginx 目录下的文件列表：

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

total 80
drwxr-xr-x   7 root root  4096 Jun 21 22:16 ./
drwxr-xr-x 103 root root  4096 Sep  4 18:04 ../
drwxr-xr-x   2 root root  4096 Jul 12  2017 conf.d/
-rw-r--r--   1 root root  1077 Feb 12  2017 fastcgi.conf
-rw-r--r--   1 root root  1007 Feb 12  2017 fastcgi_params
-rw-r--r--   1 root root  2837 Feb 12  2017 koi-utf
-rw-r--r--   1 root root  2223 Feb 12  2017 koi-win
-rw-r--r--   1 root root  3957 Feb 12  2017 mime.types
-rw-r--r--   1 root root  1505 Jun 21 20:24 nginx.conf
-rw-r--r--   1 root root 12288 Jun 21 20:44 .nginx.conf.swp
-rw-r--r--   1 root root   180 Feb 12  2017 proxy_params
-rw-r--r--   1 root root   636 Feb 12  2017 scgi_params
drwxr-xr-x   2 root root  4096 Jun 21 22:42 sites-available/
drwxr-xr-x   2 root root  4096 Jun 21 19:08 sites-enabled/
drwxr-xr-x   2 root root  4096 Jun 21 19:08 snippets/
-rw-r--r--   1 root root   664 Feb 12  2017 uwsgi_params
drwxr-xr-x   2 root root  4096 Jun 22 02:44 vhosts/
-rw-r--r--   1 root root  3071 Feb 12  2017 win-utf