如果大家对 Python 爬虫有所了解的话，想必你应该听说过 Selenium 这个库，这实际上是一个自动化测试工具，现在已经被广泛用于网络爬虫中来应对 JavaScript 渲染的页面的抓取。 但 Selenium 用的时候有个麻烦事，就是环境的相关配置，得安装好相关浏览器，比如 Chrome、Firefox 等等，然后还要到官方网站去下载对应的驱动，最重要的还需要安装对应的 Python Selenium 库，确实是不是很方便，另外如果要做大规模部署的话，环境配置的一些问题也是个头疼的事情。 那么本节就介绍另一个类似的替代品，叫做 Pyppeteer。注意，是叫做 Pyppeteer，不是 Puppeteer。Puppeteer 是 Google 基于 Node.js 开发的一个工具，有了它我们可以通过 JavaScript 来控制 Chrome 浏览器的一些操作，当然也可以用作网络爬虫上，其 API 极其完善，功能非常强大。 而 Pyppeteer 又是什么呢？它实际上是 Puppeteer 的 Python 版本的实现，但他不是 Google 开发的，是一位来自于日本的工程师依据 Puppeteer 的一些功能开发出来的非官方版本。 在 Pyppetter 中，实际上它背后也是有一个类似 Chrome 浏览器的 Chromium 浏览器在执行一些动作进行网页渲染，首先说下 Chrome 浏览器和 Chromium 浏览器的渊源。

Chromium 是谷歌为了研发 Chrome 而启动的项目，是完全开源的。二者基于相同的源代码构建，Chrome 所有的新功能都会先在 Chromium 上实现，待验证稳定后才会移植，因此 Chromium 的版本更新频率更高，也会包含很多新的功能，但作为一款独立的浏览器，Chromium 的用户群体要小众得多。两款浏览器“同根同源”，它们有着同样的 Logo，但配色不同，Chrome 由蓝红绿黄四种颜色组成，而 Chromium 由不同深度的蓝色构成。

总的来说，两款浏览器的内核是一样的，实现方式也是一样的，可以认为是开发版和正式版的区别，功能上基本是没有太大区别的。 Pyppeteer 就是依赖于 Chromium 这个浏览器来运行的。那么有了 Pyppeteer 之后，我们就可以免去那些繁琐的环境配置等问题。如果第一次运行的时候，Chromium 浏览器没有安全，那么程序会帮我们自动安装和配置，就免去了繁琐的环境配置等工作。另外 Pyppeteer 是基于 Python 的新特性 async 实现的，所以它的一些执行也支持异步操作，效率相对于 Selenium 来说也提高了。 那么下面就让我们来一起了解下 Pyppeteer 的相关用法吧。

安装

首先就是安装问题了，由于 Pyppeteer 采用了 Python 的 async 机制，所以其运行要求的 Python 版本为 3.5 及以上。 安装方式非常简单：

1

pip3 install pyppeteer

好了，安装完成之后我们命令行下测试下：

1

\>>> import pyppeteer

如果没有报错，那么就证明安装成功了。

快速上手

接下来我们测试下基本的页面渲染操作，这里我们选用的网址为：http://quotes.toscrape.com/js/，这个页面是 JavaScript 渲染而成的，用基本的 requests 库请求得到的 HTML 结果里面是不包含页面中所见的条目内容的。 为了证明 requests 无法完成正常的抓取，我们可以先用如下代码来测试一下：

1
2
3
4
5
6
7

import requests
from pyquery import PyQuery as pq

url = 'http://quotes.toscrape.com/js/'
response = requests.get(url)
doc = pq(response.text)
print('Quotes:', doc('.quote').length)

这里首先使用 requests 来请求网页内容，然后使用 pyquery 来解析页面中的每一个条目。观察源码之后我们发现每个条目的 class 名为 quote，所以这里选用了 .quote 这个 CSS 选择器来选择，最后输出条目数量。 运行结果：

1

Quotes: 0

结果是 0，这就证明使用 requests 是无法正常抓取到相关数据的。因为什么？因为这个页面是 JavaScript 渲染而成的，我们所看到的内容都是网页加载后又执行了 JavaScript 之后才呈现出来的，因此这些条目数据并不存在于原始 HTML 代码中，而 requests 仅仅抓取的是原始 HTML 代码。 好的，所以遇到这种类型的网站我们应该怎么办呢？ 其实答案有很多：

• 分析网页源代码数据，如果数据是隐藏在 HTML 中的其他地方，以 JavaScript 变量的形式存在，直接提取就好了。
• 分析 Ajax，很多数据可能是经过 Ajax 请求时候获取的，所以可以分析其接口。
• 模拟 JavaScript 渲染过程，直接抓取渲染后的结果。

而 Pyppeteer 和 Selenium 就是用的第三种方法，下面我们再用 Pyppeteer 来试试，如果用 Pyppeteer 实现如上页面的抓取的话，代码就可以写为如下形式：

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

import asyncio
from pyppeteer import launch
from pyquery import PyQuery as pq

async def main():
    browser = await launch()
    page = await browser.newPage()
    await page.goto('http://quotes.toscrape.com/js/')
    doc = pq(await page.content())
    print('Quotes:', doc('.quote').length)
    await browser.close()

asyncio.get_event_loop().run_until_complete(main())

运行结果：

1

Quotes: 10

看运行结果，这说明我们就成功匹配出来了 class 为 quote 的条目，总数为 10 条，具体的内容可以进一步使用 pyquery 解析查看。 那么这里面的过程发生了什么？ 实际上，Pyppeteer 整个流程就完成了浏览器的开启、新建页面、页面加载等操作。另外 Pyppeteer 里面进行了异步操作，所以需要配合 async/await 关键词来实现。 首先， launch 方法会新建一个 Browser 对象，然后赋值给 browser，然后调用 newPage 方法相当于浏览器中新建了一个选项卡，同时新建了一个 Page 对象。然后 Page 对象调用了 goto 方法就相当于在浏览器中输入了这个 URL，浏览器跳转到了对应的页面进行加载，加载完成之后再调用 content 方法，返回当前浏览器页面的源代码。然后进一步地，我们用 pyquery 进行同样地解析，就可以得到 JavaScript 渲染的结果了。 另外其他的一些方法如调用 asyncio 的 get_event_loop 等方法的相关操作则属于 Python 异步 async 相关的内容了，大家如果不熟悉可以了解下 Python 的 async/await 的相关知识。 好，通过上面的代码，我们就可以完成 JavaScript 渲染页面的爬取了。 在这个过程中，我们没有配置 Chrome 浏览器，没有配置浏览器驱动，免去了一些繁琐的步骤，同样达到了 Selenium 的效果，还实现了异步抓取，爽歪歪！ 接下来我们再看看另外一个例子，这个例子可以模拟网页截图，保存 PDF，另外还可以执行自定义的 JavaScript 获得特定的内容，代码如下：

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

import asyncio
from pyppeteer import launch

async def main():
    browser = await launch()
    page = await browser.newPage()
    await page.goto('http://quotes.toscrape.com/js/')
    await page.screenshot(path='example.png')
    await page.pdf(path='example.pdf')
    dimensions = await page.evaluate('''() => {
        return {
            width: document.documentElement.clientWidth,
            height: document.documentElement.clientHeight,
            deviceScaleFactor: window.devicePixelRatio,
        }
    }''')

    print(dimensions)
    # >>> {'width': 800, 'height': 600, 'deviceScaleFactor': 1}
    await browser.close()

asyncio.get_event_loop().run_until_complete(main())

这里我们又用到了几个新的 API，完成了网页截图保存、网页导出 PDF 保存、执行 JavaScript 并返回对应数据。 首先 screenshot 方法可以传入保存的图片路径，另外还可以指定保存格式 type、清晰度 quality、是否全屏 fullPage、裁切 clip 等各个参数实现截图。 截图的样例如下： 可以看到它返回的就是 JavaScript 渲染后的页面。 pdf 方法也是类似的，只不过页面保存格式不一样，最后得到一个多页的 pdf 文件，样例如下： 可见其内容也是 JavaScript 渲染后的内容，另外这个方法还可以指定放缩大小 scale、页码范围 pageRanges、宽高 width 和 height、方向 landscape 等等参数，导出定制化的 pdf 用这个方法就十分方便。 最后我们又调用了 evaluate 方法执行了一些 JavaScript，JavaScript 传入的是一个函数，使用 return 方法返回了网页的宽高、像素大小比率三个值，最后得到的是一个 JSON 格式的对象，内容如下：

1

{'width': 800, 'height': 600, 'deviceScaleFactor': 1}

OK，实例就先感受到这里，还有太多太多的功能还没提及。 总之利用 Pyppeteer 我们可以控制浏览器执行几乎所有动作，想要的操作和功能基本都可以实现，用它来自由地控制爬虫当然就不在话下了。

详细用法

了解了基本的实例之后，我们再来梳理一下 Pyppeteer 的一些基本和常用操作。Pyppeteer 的几乎所有功能都能在其官方文档的 API Reference 里面找到，链接为：https://miyakogi.github.io/pyppeteer/reference.html，用到哪个方法就来这里查询就好了，参数不必死记硬背，即用即查就好。

开启浏览器

使用 Pyppeteer 的第一步便是启动浏览器，首先我们看下怎样启动一个浏览器，其实就相当于我们点击桌面上的浏览器图标一样，把它开起来。用 Pyppeteer 完成同样的操作，只需要调用 launch 方法即可。 我们先看下 launch 方法的 API，链接为：https://miyakogi.github.io/pyppeteer/reference.html#pyppeteer.launcher.launch，其方法定义如下：

1

pyppeteer.launcher.launch(options: dict = None, **kwargs) → pyppeteer.browser.Browser

可以看到它处于 launcher 模块中，参数没有在声明中特别指定，返回类型是 browser 模块中的 Browser 对象，另外观察源码发现这是一个 async 修饰的方法，所以调用它的时候需要使用 await。 接下来看看它的参数：

• ignoreHTTPSErrors (bool): 是否要忽略 HTTPS 的错误，默认是 False。
• headless (bool): 是否启用 Headless 模式，即无界面模式，如果 devtools 这个参数是 True 的话，那么该参数就会被设置为 False，否则为 True，即默认是开启无界面模式的。
• executablePath (str): 可执行文件的路径，如果指定之后就不需要使用默认的 Chromium 了，可以指定为已有的 Chrome 或 Chromium。
• slowMo (int|float): 通过传入指定的时间，可以减缓 Pyppeteer 的一些模拟操作。
• args (List[str]): 在执行过程中可以传入的额外参数。
• ignoreDefaultArgs (bool): 不使用 Pyppeteer 的默认参数，如果使用了这个参数，那么最好通过 args 参数来设定一些参数，否则可能会出现一些意想不到的问题。这个参数相对比较危险，慎用。
• handleSIGINT (bool): 是否响应 SIGINT 信号，也就是可以使用 Ctrl + C 来终止浏览器程序，默认是 True。
• handleSIGTERM (bool): 是否响应 SIGTERM 信号，一般是 kill 命令，默认是 True。
• handleSIGHUP (bool): 是否响应 SIGHUP 信号，即挂起信号，比如终端退出操作，默认是 True。
• dumpio (bool): 是否将 Pyppeteer 的输出内容传给 process.stdout 和 process.stderr 对象，默认是 False。
• userDataDir (str): 即用户数据文件夹，即可以保留一些个性化配置和操作记录。
• env (dict): 环境变量，可以通过字典形式传入。
• devtools (bool): 是否为每一个页面自动开启调试工具，默认是 False。如果这个参数设置为 True，那么 headless 参数就会无效，会被强制设置为 False。
• logLevel (int|str): 日志级别，默认和 root logger 对象的级别相同。
• autoClose (bool): 当一些命令执行完之后，是否自动关闭浏览器，默认是 True。
• loop (asyncio.AbstractEventLoop): 时间循环对象。

好了，知道这些参数之后，我们可以先试试看。 首先可以试用下最常用的参数 headless，如果我们将它设置为 True 或者默认不设置它，在启动的时候我们是看不到任何界面的，如果把它设置为 False，那么在启动的时候就可以看到界面了，一般我们在调试的时候会把它设置为 False，在生产环境上就可以设置为 True，我们先尝试一下关闭 headless 模式：

1
2
3
4
5
6
7
8

import asyncio
from pyppeteer import launch

async def main():
    await launch(headless=False)
    await asyncio.sleep(100)

asyncio.get_event_loop().run_until_complete(main())

运行之后看不到任何控制台输出，但是这时候就会出现一个空白的 Chromium 界面了： 但是可以看到这就是一个光秃秃的浏览器而已，看一下相关信息： 看到了，这就是 Chromium，上面还写了开发者内部版本，可以认为是开发版的 Chrome 浏览器就好。 另外我们还可以开启调试模式，比如在写爬虫的时候会经常需要分析网页结构还有网络请求，所以开启调试工具还是很有必要的，我们可以将 devtools 参数设置为 True，这样每开启一个界面就会弹出一个调试窗口，非常方便，示例如下：

1
2
3
4
5
6
7
8
9
10

import asyncio
from pyppeteer import launch

async def main():
    browser = await launch(devtools=True)
    page = await browser.newPage()
    await page.goto('https://www.baidu.com')
    await asyncio.sleep(100)

asyncio.get_event_loop().run_until_complete(main())

刚才说过 devtools 这个参数如果设置为了 True，那么 headless 就会被关闭了，界面始终会显现出来。在这里我们新建了一个页面，打开了百度，界面运行效果如下： 这时候我们可以看到上面的一条提示：”Chrome 正受到自动测试软件的控制”，这个提示条有点烦，那咋关闭呢？这时候就需要用到 args 参数了，禁用操作如下：

1

browser = await launch(headless=False, args=['--disable-infobars'])

这里就不再写完整代码了，就是在 launch 方法中，args 参数通过 list 形式传入即可，这里使用的是 —disable-infobars 的参数。 另外有人就说了，这里你只是把提示关闭了，有些网站还是会检测到是 webdriver 吧，比如淘宝检测到是 webdriver 就会禁止登录了，我们可以试试：

1
2
3
4
5
6
7
8
9
10

import asyncio
from pyppeteer import launch

async def main():
    browser = await launch(headless=False)
    page = await browser.newPage()
    await page.goto('https://www.taobao.com')
    await asyncio.sleep(100)

asyncio.get_event_loop().run_until_complete(main())

运行时候进行一下登录，然后就会弹出滑块，自己手动拖动一下，然后就报错了，界面如下： 爬虫的时候看到这界面是很让人崩溃的吧，而且这时候我们还发现了页面的 bug，整个浏览器窗口比显示的内容窗口要大，这个是某些页面会出现的情况，让人看起来很不爽。 我们可以先解决一下这个显示的 bug，需要设置下 window-size 还有 viewport，代码如下：

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

import asyncio
from pyppeteer import launch

width, height = 1366, 768

async def main():
    browser = await launch(headless=False,
                           args=[f'--window-size={width},{height}'])
    page = await browser.newPage()
    await page.setViewport({'width': width, 'height': height})
    await page.goto('https://www.taobao.com')
    await asyncio.sleep(100)

asyncio.get_event_loop().run_until_complete(main())

这样整个界面就正常了： OK，那刚才所说的 webdriver 检测问题怎样来解决呢？其实淘宝主要通过 window.navigator.webdriver 来对 webdriver 进行检测，所以我们只需要使用 JavaScript 将它设置为 false 即可，代码如下：

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

import asyncio
from pyppeteer import launch

async def main():
    browser = await launch(headless=False, args=['--disable-infobars'])
    page = await browser.newPage()
    await page.goto('https://login.taobao.com/member/login.jhtml?redirectURL=https://www.taobao.com/')
    await page.evaluate(
        '''() =>{ Object.defineProperties(navigator,{ webdriver:{ get: () => false } }) }''')
    await asyncio.sleep(100)

asyncio.get_event_loop().run_until_complete(main())

这里没加输入用户名密码的代码，当然后面可以自行添加，下面打开之后，我们点击输入用户名密码，然后这时候会出现一个滑动条，这里滑动的话，就可以通过了，如图所示： OK，这样的话我们就成功规避了 webdriver 的检测，使用鼠标拖动模拟就可以完成淘宝的登录了。 还有另一种方法可以进一步免去淘宝登录的烦恼，那就是设置用户目录。平时我们已经注意到，当我们登录淘宝之后，如果下次再次打开浏览器发现还是登录的状态。这是因为淘宝的一些关键 Cookies 已经保存到本地了，下次登录的时候可以直接读取并保持登录状态。 那么这些信息保存在哪里了呢？其实就是保存在用户目录下了，里面不仅包含了浏览器的基本配置信息，还有一些 Cache、Cookies 等各种信息都在里面，如果我们能在浏览器启动的时候读取这些信息，那么启动的时候就可以恢复一些历史记录甚至一些登录状态信息了。 这也就解决了一个问题：很多朋友在每次启动 Selenium 或 Pyppeteer 的时候总是是一个全新的浏览器，那就是没有设置用户目录，如果设置了它，每次打开就不再是一个全新的浏览器了，它可以恢复之前的历史记录，也可以恢复很多网站的登录信息。 那么这个怎么来做呢？很简单，在启动的时候设置 userDataDir 就好了，示例如下：

1
2
3
4
5
6
7
8
9
10

import asyncio
from pyppeteer import launch

async def main():
    browser = await launch(headless=False, userDataDir='./userdata', args=['--disable-infobars'])
    page = await browser.newPage()
    await page.goto('https://www.taobao.com')
    await asyncio.sleep(100)

asyncio.get_event_loop().run_until_complete(main())

好，这里就是加了一个 userDataDir 的属性，值为 userdata，即当前目录的 userdata 文件夹。我们可以首先运行一下，然后登录一次淘宝，这时候我们同时可以观察到在当前运行目录下又多了一个 userdata 的文件夹，里面的结构是这样子的： 具体的介绍可以看官方的一些说明，如：https://chromium.googlesource.com/chromium/src/+/master/docs/user_data_dir.md，这里面介绍了 userdatadir 的相关内容。 再次运行上面的代码，这时候可以发现现在就已经是登录状态了，不需要再次登录了，这样就成功跳过了登录的流程。当然可能时间太久了，Cookies 都过期了，那还是需要登录的。 好了，本想把 Pyppeteer 的用法详细介绍完的，结果只 launch 的方法就介绍这么多了，后面的内容放到其他文章来介绍了，其他的内容后续文章会陆续放出，谢谢。

本节代码获取

公众号”进击的 Coder”回复”Pyppeteer”即可获取本节全部代码。

正则表达式 30 分钟入门教程（https://deerchao.net/tutorials/regex/regex.htm）

本教程目标：30 分钟内让你明白正则表达式是什么，并对它有一些基本的了解，让你可以在自己的程序或网页里使用它。

正则表达式 必知必会（https://www.zybuluo.com/Yano/note/475174）

Zjmainstay 学习笔记 | 正则表达式（http://www.zjmainstay.cn/regexp）

《精通正则表达式 第三版》

1. 最后，推荐一本动物书《精通正则表达式 第三版》

【顺手提供】精通正则表达式：第三版 PDF (高清-中文-带标签)

关注本公众号【离不开的网】，后台回复 “ 正则 pdf ” 即可。

相关好文推荐

1. 想精通正则表达式 这几个正则表达式学习资料及工具你必须有 ：https://www.cnblogs.com/3rocks/p/11212724.html
2. 菜鸟教程-正则表达式 ：https://www.runoob.com/regexp/regexp-tutorial.html
3. 正则表达式速查表 ：https://www.jb51.net/article/67634.htm
4. 细说 python 正则表达式 ：https://www.jianshu.com/p/147fab022566
5. 路人甲的关于正则表达式 ：https://zhuanlan.zhihu.com/p/21341872?refer=passer
6. 最全的常用正则表达式大全——包括校验数字、字符、一些特殊的需求等等 ：http://www.cnblogs.com/zxin/archive/2013/01/26/2877765.html
7. 深入理解正则表达式 ：https://www.cnblogs.com/China3S/archive/2013/11/30/3451971.html

原文链接：https://mp.weixin.qq.com/s/CGSUJntKtvOrV1o-R2GrRw 来源公众号：离不开的网

日志概述

百度百科的日志概述： Windows网络操作系统都设计有各种各样的日志文件，如应用程序日志，安全日志、系统日志、Scheduler服务日志、FTP日志、WWW日志、DNS服务器日志等等，这些根据你的系统开启的服务的不同而有所不同。我们在系统上进行一些操作时，这些日志文件通常会记录下我们操作的一些相关内容，这些内容对系统安全工作人员相当有用。比如说有人对系统进行了IPC探测，系统就会在安全日志里迅速地记下探测者探测时所用的IP、时间、用户名等，用FTP探测后，就会在FTP日志中记下IP、时间、探测所用的用户名等。 我映像中的日志： 查看日志是开发人员日常获取信息、排查异常、发现问题的最好途径，日志记录中通常会标记有异常产生的原因、发生时间、具体错误行数等信息，这极大的节省了我们的排查时间，无形中提高了编码效率。

日志分类

我们可以按照输出终端进行分类，也可以按照日志级别进行分类。输出终端指的是将日志在控制台输出显示和将日志存入文件；日志级别指的是 Debug、Info、WARNING、ERROR以及CRITICAL等严重等级进行划分。

Python 的 logging

logging提供了一组便利的日志函数，它们分别是：debug()、 info()、 warning()、 error() 和 critical()。logging函数根据它们用来跟踪的事件的级别或严重程度来命名。标准级别及其适用性描述如下（以严重程度递增排序）： 每个级别对应的数字值为 CRITICAL：50，ERROR：40，WARNING：30，INFO：20，DEBUG：10，NOTSET：0。 Python 中日志的默认等级是 WARNING，DEBUG 和 INFO 级别的日志将不会得到显示，在 logging 中更改设置。

日志输出

输出到控制台

使用 logging 在控制台打印日志，这里我们用 Pycharm 编辑器来观察：

1
2
3
4
5

import logging

logging.debug('崔庆才丨静觅、韦世东丨奎因')
logging.warning('邀请你关注微信公众号【进击的 Coder】')
logging.info('和大佬一起coding、共同进步')

从上图运行的结果来看，的确只显示了 WARNING 级别的信息，验证了上面的观点。同时也在控制台输出了日志内容，默认情况下 Python 中使用 logging 模块中的函数打印日志，日志只会在控制台输出，而不会保存到日文件。 有什么办法可以改变默认的日志级别呢？ 当然是有的，logging 中提供了 basicConfig 让使用者可以适时调节默认日志级别，我们可以将上面的代码改为：

1
2
3
4
5
6

import logging

logging.basicConfig(level=logging.DEBUG)
logging.debug('崔庆才丨静觅、韦世东丨奎因')
logging.warning('邀请你关注微信公众号【进击的 Coder】')
logging.info('和大佬一起coding、共同进步')

在 basicConfig 中设定 level 参数的级别即可。 思考：如果设定级别为 logging.INFO，那 DEBUG 信息能够显示么？

保存到文件

刚才演示了如何在控制台输出日志内容，并且自由设定日志的级别，那现在就来看看如何将日志保存到文件。依旧是强大的 basicConfig，我们再将上面的代码改为：

1
2
3
4
5
6

import logging

logging.basicConfig(level=logging.DEBUG, filename='coder.log', filemode='a')
logging.debug('崔庆才丨静觅、韦世东丨奎因')
logging.warning('邀请你关注微信公众号【进击的 Coder】')
logging.info('和大佬一起coding、共同进步')

在配置中填写 filename （指定文件名） 和 filemode （文件写入方式），控制台的日志输出就不见了，那么 coder.log 会生成么？ 在 .py 文件的同级目录生成了名为 coder.log 的日志。 通过简单的代码设置，我们就完成了日志文件在控制台和文件中的输出。那既在控制台显示又能保存到文件中呢？

强大的 logging

logging所提供的模块级别的日志记录函数是对logging日志系统相关类的封装 logging 模块提供了两种记录日志的方式：

• 使用logging提供的模块级别的函数
• 使用Logging日志系统的四大组件

这里提到的级别函数就是上面所用的 DEBGE、ERROR 等级别，而四大组件则是指 loggers、handlers、filters 和 formatters 这几个组件，下图简单明了的阐述了它们各自的作用： 日志器（logger）是入口，真正工作的是处理器（handler），处理器（handler）还可以通过过滤器（filter）和格式器（formatter）对要输出的日志内容做过滤和格式化等处理操作。

四大组件

下面介绍下与logging四大组件相关的类：Logger, Handler, Filter, Formatter。 Logger类 Logger 对象有3个工作要做：

1
2
3

1）向应用程序代码暴露几个方法，使应用程序可以在运行时记录日志消息；
2）基于日志严重等级（默认的过滤设施）或filter对象来决定要对哪些日志进行后续处理；
3）将日志消息传送给所有感兴趣的日志handlers。

Logger对象最常用的方法分为两类：配置方法 和 消息发送方法 最常用的配置方法如下： 关于Logger.setLevel()方法的说明： 内建等级中，级别最低的是DEBUG，级别最高的是CRITICAL。例如setLevel(logging.INFO)，此时函数参数为INFO，那么该logger将只会处理INFO、WARNING、ERROR和CRITICAL级别的日志，而DEBUG级别的消息将会被忽略/丢弃。 logger对象配置完成后，可以使用下面的方法来创建日志记录： 那么，怎样得到一个Logger对象呢？一种方式是通过Logger类的实例化方法创建一个Logger类的实例，但是我们通常都是用第二种方式—logging.getLogger()方法。 logging.getLogger()方法有一个可选参数name，该参数表示将要返回的日志器的名称标识，如果不提供该参数，则其值为’root’。若以相同的name参数值多次调用getLogger()方法，将会返回指向同一个logger对象的引用。

1
2
3
4
5

关于logger的层级结构与有效等级的说明：

    logger的名称是一个以'.'分割的层级结构，每个'.'后面的logger都是'.'前面的logger的children，例如，有一个名称为 foo 的logger，其它名称分别为 foo.bar, foo.bar.baz 和 foo.bam都是 foo 的后代。
    logger有一个"有效等级（effective level）"的概念。如果一个logger上没有被明确设置一个level，那么该logger就是使用它parent的level;如果它的parent也没有明确设置level则继续向上查找parent的parent的有效level，依次类推，直到找到个一个明确设置了level的祖先为止。需要说明的是，root logger总是会有一个明确的level设置（默认为 WARNING）。当决定是否去处理一个已发生的事件时，logger的有效等级将会被用来决定是否将该事件传递给该logger的handlers进行处理。
    child loggers在完成对日志消息的处理后，默认会将日志消息传递给与它们的祖先loggers相关的handlers。因此，我们不必为一个应用程序中所使用的所有loggers定义和配置handlers，只需要为一个顶层的logger配置handlers，然后按照需要创建child loggers就可足够了。我们也可以通过将一个logger的propagate属性设置为False来关闭这种传递机制。

Handler Handler对象的作用是（基于日志消息的level）将消息分发到handler指定的位置（文件、网络、邮件等）。Logger对象可以通过addHandler()方法为自己添加0个或者更多个handler对象。比如，一个应用程序可能想要实现以下几个日志需求：

1
2
3
4

1）把所有日志都发送到一个日志文件中；
2）把所有严重级别大于等于error的日志发送到stdout（标准输出）；
3）把所有严重级别为critical的日志发送到一个email邮件地址。
这种场景就需要3个不同的handlers，每个handler复杂发送一个特定严重级别的日志到一个特定的位置。

一个handler中只有非常少数的方法是需要应用开发人员去关心的。对于使用内建handler对象的应用开发人员来说，似乎唯一相关的handler方法就是下面这几个配置方法： 需要说明的是，应用程序代码不应该直接实例化和使用Handler实例。因为Handler是一个基类，它只定义了素有handlers都应该有的接口，同时提供了一些子类可以直接使用或覆盖的默认行为。下面是一些常用的Handler： Formater Formater对象用于配置日志信息的最终顺序、结构和内容。与logging.Handler基类不同的是，应用代码可以直接实例化Formatter类。另外，如果你的应用程序需要一些特殊的处理行为，也可以实现一个Formatter的子类来完成。 Formatter类的构造方法定义如下：

1

logging.Formatter.__init__(fmt=None, datefmt=None, style='%')

该构造方法接收3个可选参数：

• fmt：指定消息格式化字符串，如果不指定该参数则默认使用message的原始值
• datefmt：指定日期格式字符串，如果不指定该参数则默认使用”%Y-%m-%d %H:%M:%S”
• style：Python 3.2新增的参数，可取值为 ‘%’, ‘{‘和 ‘$’，如果不指定该参数则默认使用’%’

Filter Filter可以被Handler和Logger用来做比level更细粒度的、更复杂的过滤功能。Filter是一个过滤器基类，它只允许某个logger层级下的日志事件通过过滤。该类定义如下：

1
2

class logging.Filter(name='')
    filter(record)

比如，一个filter实例化时传递的name参数值为’A.B’，那么该filter实例将只允许名称为类似如下规则的loggers产生的日志记录通过过滤：’A.B’，’A.B,C’，’A.B.C.D’，’A.B.D’，而名称为’A.BB’, ‘B.A.B’的loggers产生的日志则会被过滤掉。如果name的值为空字符串，则允许所有的日志事件通过过滤。 filter方法用于具体控制传递的record记录是否能通过过滤，如果该方法返回值为0表示不能通过过滤，返回值为非0表示可以通过过滤。

1
2
3
4

说明：

    如果有需要，也可以在filter(record)方法内部改变该record，比如添加、删除或修改一些属性。
    我们还可以通过filter做一些统计工作，比如可以计算下被一个特殊的logger或handler所处理的record数量等。

实战演练

上面文绉绉的说了(复制/粘贴)那么多，现在应该动手实践了。 现在我需要既将日志输出到控制台、又能将日志保存到文件，我应该怎么办？ 利用刚才所学的知识，我们可以构思一下： 看起来好像也不难，挺简单的样子，但是实际如此吗？ 在实际的工作或应用中，我们或许还需要指定文件存放路径、用随机数作为日志文件名、显示具体的信息输出代码行数、日志信息输出日期和日志写入方式等内容。再构思一下： 具体代码如下：

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

import os
import logging
import uuid
from logging import Handler, FileHandler, StreamHandler

class PathFileHandler(FileHandler):
    def __init__(self, path, filename, mode='a', encoding=None, delay=False):

        filename = os.fspath(filename)
        if not os.path.exists(path):
            os.mkdir(path)
        self.baseFilename = os.path.join(path, filename)
        self.mode = mode
        self.encoding = encoding
        self.delay = delay
        if delay:
            Handler.__init__(self)
            self.stream = None
        else:
            StreamHandler.__init__(self, self._open())

class Loggers(object):
    # 日志级别关系映射
    level_relations = {
        'debug': logging.DEBUG, 'info': logging.INFO, 'warning': logging.WARNING,
        'error': logging.ERROR, 'critical': logging.CRITICAL
    }

    def __init__(self, filename='{uid}.log'.format(uid=uuid.uuid4()), level='info', log_dir='log',
                 fmt='%(asctime)s - %(filename)s[line:%(lineno)d] - %(levelname)s: %(message)s'):
        self.logger = logging.getLogger(filename)
        abspath = os.path.dirname(os.path.abspath(__file__))
        self.directory = os.path.join(abspath, log_dir)
        format_str = logging.Formatter(fmt)  # 设置日志格式
        self.logger.setLevel(self.level_relations.get(level))  # 设置日志级别
        stream_handler = logging.StreamHandler()  # 往屏幕上输出
        stream_handler.setFormatter(format_str)
        file_handler = PathFileHandler(path=self.directory, filename=filename, mode='a')
        file_handler.setFormatter(format_str)
        self.logger.addHandler(stream_handler)
        self.logger.addHandler(file_handler)

if __name__ == "__main__":
    txt = "关注公众号【进击的 Coder】，回复『日志代码』可以领取文章中完整的代码以及流程图"
    log = Loggers(level='debug')
    log.logger.info(4)
    log.logger.info(5)
    log.logger.info(txt)

文件保存后运行，运行结果如下图所示： 日志确实在控制台输出了，再来看一下目录内是否生成有指定的文件和文件夹： 文件打开后可以看到里面输出的内容： 正确的学习方式是什么 是一步步的看着文章介绍，等待博主结论？ 是拿着代码运行，跑一遍？ 都不是，应该是一边看着文章，一边拿着示例代码琢磨和研究，到底哪里可以改进、哪里可以设计得更好。如果你需要文章中所用到的示例代码和流程图，那么关注微信公众号【进击的 Coder】，回复『日志代码』就可以领取文章中完整的代码以及流程图。毕竟，学习是一件勤劳的事。 参考资料： 云游道士博文 nancy05博文

位运算是我们在编程中常会遇到的操作，但仍然有很多开发者并不了解位运算，这就导致在遇到位运算时会“打退堂鼓”。实际上，位运算并没有那么复杂，只要我们了解其运算基础和运算符的运算规则，就能够掌握位运算的知识。接下来，我们一起学习位运算的相关知识。 程序中的数在计算机内存中都是以二进制的形式存在的，位运算就是直接对整数在内存中对应的二进制位进行操作。

注意：本文只讨论整数运算，小数运算不在本文研究之列

位运算的基础

我们常用的 3， 5 等数字是十进制表示，而位运算的基础是二进制。即人类采用十进制，机器采用的是二进制，要深入了解位运算，就需要了解十进制和二进制的转换方法和对应关系。

二进制

十进制转二进制时，采用“除 2 取余，逆序排列”法：

1. 用 2 整除十进制数，得到商和余数;
2. 再用 2 整除商，得到新的商和余数;
3. 重复第 1 和第 2 步，直到商为 0;
4. 将先得到的余数作为二进制数的高位，后得到的余数作为二进制数的低位，依次排序;

排序结果就是该十进制数的二进制表示。例如十进制数 101 转换为二进制数的计算过程如下：

1
2
3
4
5
6
7

101 % 2 = 50 余 1
50 % 2 = 25 余 0
25 % 2 = 12 余 1
12 % 2 = 6 余 0
6 % 2 = 3 余 0
3 % 2 = 1 余 1
1 % 2 = 0 余 1

逆序排列即二进制中的从高位到低位排序，得到 7 位二进制数为 1100101，如果要转换为 8 位二进制数，就需要在最高位补 0。即十进制数的 8 位二进制数为 01100101。 其完整过程如下图所示： 有网友整理了常见的进制与 ASCII 码对照表，表内容如下： ASCII 控制字符 ASCII 可显示字符

补码

现在，我们已经了解到二进制与十进制的换算方法，并拥有了进制对照表。但在开始学习位运算符之前，我们还需要了解补码的知识。 数值有正负之分，那么仅有 0 和 1 的二进制如何表示正负呢？ 人们设定，二进制中最高位为 0 代表正，为 1 则代表负。例如 0000 1100 对应的十进制为 12，而 1000 1100 对应的十进制为 \-12。这种表示被称作原码。但新的问题出现了，原本二进制的最高位始终为 0，为了表示正负又多出了 1，在执行运算时就会出错。举个例子，1 + (-2) 的二进制运算如下：

1
2
3

0000 0001 + 1000 0010 
= 1000 0011
= -3

这显然是有问题的，问题就处在这个代表正负的最高位。接着，人们又弄出了反码（二进制各位置的 0 与 1 互换，例如 0000 1100 的反码为 1111 0011）。此时，运算就会变成这样：

1
2
3
4
5

0000 0001 + 1111 1101
= 1111 1110
# 在转换成十进制前，需要再次反码
= 1000 0001 
= -1

这次好像正确了。但它仍然有例外，我们来看一下 1 + (-1)：

1
2
3
4

0000 0001 + 1111 + 1110
= 1111 1111
= 1000 0000
= -0

零是没有正负之分的，为了解决这个问题，就搞出了补码的概念。补码是为了让负数变成能够加的正数，所以 负数的补码= 负数的绝对值取反 + 1，例如 \-1 的补码为：

1
2
3
4

\-1 的绝对值 1
= 0000 0001 # 1 的二进制原码
= 1111 1110 # 原码取反
= 1111 1111 # +1 后得到补码

\-1 补码推导的完整过程如下图所示： 反过来，由补码推导原码的过程为 原码 = 补码 - 1，再求反。要注意的是，反码过程中，最高位的值不变，这样才能够保证结果的正负不会出错。例如 1 + (-6) 和 1 + (-9) 的运算过程如下：

1
2
3
4
5
6

# 1 的补码 + -6 的补码
0000 0001 + 1111 1010
= 1111 1011 # 补码运算结果
= 1111 1010 # 对补码减 1，得到反码
= 1000 0101 # 反码取反，得到原码
= -5 # 对应的十进制

1
2
3
4
5
6

# 1 的补码 + -9 的补码
0000 0001 + 1111 0111
= 1111 1000 # 补码运算结果
= 1111 0111 # 对补码减 1，得到反码
= 1000 1000 # 反码取反，得到原码
= -8 # 对应的十进制

要注意的是，正数的补码与原码相同，不需要额外运算。也可以说，补码的出现就是为了解决负数运算时的符号问题。

人生苦短 我用 Python。 崔庆才|静觅 邀请你关注微信公众号：进击的Coder

运算符介绍

位运算分为 6 种，它们是：

名称

符号

按位与

&

按位或

|

按位异或

^

按位取反

~

左移运算

<<

右移运算

>>

按位与

按位与运算将参与运算的两数对应的二进制位相与，当对应的二进制位均为 1 时，结果位为 1，否则结果位为 0。按位与运算的运算符为 &，参与运算的数以补码方式出现。举个例子，将数字 5 和数字 8 进行按位与运算，其实是将数字 5 对应的二进制 0000 0101 和数字 8 对应的二进制 0000 1000 进行按位与运算，即：

1
2
3

0000 0101
&
0000 1000

根据按位与的规则，将各个位置的数进行比对。运算过程如下：

1
2
3
4
5

0000 0101
&
0000 1000
---- ----
0000 0000

由于它们对应位置中没有“均为 1 ”的情况，所以得到的结果是 0000 0000。数字 5 和 8 按位与运算的完整过程如下图： 将结果换算成十进制，得到 0，即 5&8 = 0。

按位或

按位或运算将参与运算的两数对应的二进制位相或，只要对应的二进制位中有 1，结果位为 1，否则结果位为 0。按位或运算的运算符为 |，参与运算的数以补码方式出现。举个例子，将数字 3 和数字 7 进行按位或运算，其实是将数字 3 对应的二进制 0000 0011和数字 7 对应的二进制 0000 0111 进行按位或运算，即：

1
2
3

0000 0011
|
0000 0111

根据按位或的规则，将各个位置的数进行比对。运算过程如下：

1
2
3
4
5

0000 0011
|
0000 0111
---- ----
0000 0111

最终得到的结果为 0000 0111。将结果换算成十进制，得到 7，即 3|7 = 7。

按位异或

按位异或运算将参与运算的两数对应的二进制位相异或，当对应的二进制位值不同时，结果位为 1，否则结果位为 0。按位异或的运算符为 ^，参与运算的数以补码方式出现。举个例子，将数字 12 和数字 7 进行按位异或运算，其实是将数字 12 对应的二进制 0000 1100 和数字 7 对应的二进制 0000 0111 进行按位异或运算，即：

1
2
3

0000 1100
^
0000 0111

根据按位异或的规则，将各个位置的数进行比对。运算过程如下：

1
2
3
4
5

0000 1100
^
0000 0111
---- ----
0000 1011

最终得到的结果为 0000 1011。将结果换算成十进制，得到 11，即 12^7 = 11。

按位取反

按位取反运算将二进制数的每一个位上面的 0 换成 1，1 换成 0。按位取反的运算符为 ~，参与运算的数以补码方式出现。举个例子，对数字 9 进行按位取反运算，其实是将数字 9 对应的二进制 0000 1001 进行按位取反运算，即：

1
2
3
4

～0000 1001
= 0000 1001 # 补码，正数补码即原码
= 1111 1010 # 取反
= -10

最终得到的结果为 \-10。再来看一个例子，\-20 按位取反的过程如下：

1
2
3
4

～0001 0100
= 1110 1100 # 补码
= 0001 0011 # 取反
= 19

最终得到的结果为 19。我们从示例中找到了规律，按位取反的结果用数学公式表示： $～x = -(x + 1)$ 我们可以将其套用在 9 和 \-20 上：

1
2

～9 = -(9 + 1) = -10
~(-20) = -((-20) + 1) = 19

这个规律也可以作用于数字 0 上，即 ~0 = -(0 + 1) = -1。

左移运算

左移运算将数对应的二进位全部向左移动若干位，高位丢弃，低位补 0。左移运算的运算符为 <<。举个例子，将数字 5 左移 4 位，其实是将数字 5 对应的二进制 0000 0101 中的二进位向左移动 4 位，即：

1
2
3
4

5 << 4
= 0000 0101 << 4
= 0101 0000 # 高位丢弃，低位补 0
= 80

数字 5 左移 4 位的完整运算过程如下图： 最终结果为 80。这等效于: $5 _ (2) ^4$ 也就是说，左移运算的规律为： $x << n = x _ (2) ^ n$

右移运算

右移运算将数对应的二进位全部向右移动若干位。对于左边的空位，如果是正数则补 0，负数可能补 0 或 1 （Turbo C 和很多编译器选择补 1）。右移运算的运算符为 \>>。举个例子，将数字 80 右移 4 位，其实是将数字 80 对应的二进制 0101 0000 中的二进位向右移动 4 位，即：

1
2
3
4

80 >> 4
= 0101 0000 >> 4
= 0000 0101 # 正数补0，负数补1 
= 5

最终结果为 5。这等效于： $80 \\div (2)^4$ 也就是说，右移运算的规律为： $x >> n = x \\div (2) ^ n$ 要注意的是，不能整除时，取整数。这中除法取整的规则类似于 PYTHON 语言中的地板除。

超酷人生 我用 Rust 韦世东|奎因 邀请你关注微信公众号：Rust之禅

位运算的应用

在掌握了位运算的知识后，我们可以在开发中尝试使用它。坊间一直流传着位运算的效率高，速度快，但从未见过文献证明，所以本文不讨论效率和速度的问题。如果正在阅读文章的你有相关文献，请留言告知，谢谢。 判断数字奇偶 通常，我们会通过取余来判断数字是奇数还是偶数。例如判断 101 的奇偶用的方法是：

1
2
3
4
5

# python
if 101 % 2:
    print('偶数')
else:
    print('奇数')

我们也可以通过位运算中的按位与来实现奇偶判断，例如：

1
2
3
4
5

# python
if 101 & 1:
    print('奇数')
else:
    print('偶数')

这是因为奇数的二进制最低位始终为 1，而偶数的二进制最低为始终为 0。所以，无论任何奇数与 1 即 0000 0001 相与得到的都是 1，任何偶数与其相与得到的都是 0。 变量交换 在 C 语言中，两个变量的交换必须通过第三个变量来实现。伪代码如下：

1
2
3
4
5
6
7

# 伪代码
a = 3, b = 5
c = a
a = b
b = a
--------
a = 5, b = 3

在 PYTHON 语言中并没有这么麻烦，可以直接交换。对应的 PYTHON 代码如下：

1
2
3
4

# python
a, b = 3, 5
a, b = b, a
print(a, b)

代码运行结果为 5 3。但大部分编程语言都不支持 PYTHON 这种写法，在这种情况下我们可以通过位运算中的按位异或来实现变量的交换。对应的伪代码如下：

1
2
3
4
5

# 伪代码
a = 3, b = 5
a = a ^ b
b = a ^ b
a = a ^ b

最后，a = 5, b = 3。我们可以用 C 语言和 PYTHON 语言进行验证，对应的 PYTHON 代码如下：

1
2
3
4
5
6

# python
a, b = 3, 5
a = a ^ b
b = a ^ b
a = a ^ b
print(a, b)

代码运行结果为 5 3，说明变量交换成功。对应的 C 代码如下：

1
2
3
4
5
6
7
8
9
10

#include<stdio.h>
void main()
{
    int a = 3, b = 5;
    printf("交换前：a=%d , b=%dn",a,b);
    a = a^b;
    b = a^b;
    a = a^b;
    printf("交换后：a=%d , b=%dn",a, b);           
}

代码运行结果如下：

1
2

交换前：a=3 , b=5
交换后：a=5 , b=3

这说明变量交换成功。 求 x 与 2 的 n 次方乘积 设一个数为 x，求 x 与 2 的 n 次方乘积。这用数学来计算都是非常简单的： $x * (2) ^ n$ 在位运算中，要实现这个需求只需要用到左移运算，即 x << n。 取 x 的第 k 位 即取数字 x 对应的二进制的第 k 位上的二进制值。假设数字为 5，其对应的二进制为 0000 0101，取第 k 位二进制值的位运算为 x >> k & 1。我们可以用 PYTHON 代码进行验证：

1
2
3
4

# python
x = 5  # 0000 0101
for i in range(8):
    print(x >> i & 1)

代码运行结果如下：

1
2
3
4
5
6
7
8

1
0
1
0
0
0
0
0

这说明位运算的算法是正确的，可以满足我们的需求。 判断赋值

1
2
3
4

if a == x:
    x = b
else:
    x = a

等效于 x = a ^ b ^ x。我们可以通过 PYTHON 代码来验证：

1
2
3
4
5
6
7

# python
a, b, x = 6, 9, 6
if a == x:
    x = b
else:
    x = a
print(a, b, x)

代码运行结果为 699，与之等效的代码如下：

1
2
3
4

# python
a, b, x = 6, 9, 6
x = a ^ b ^ x
print(a, b, x)

这样就省去了 if else 的判断语句。 代替地板除 二分查找是最常用的算法之一，但它有一定的前提条件：二分查找的目标必须采用顺序存储结构，且元素有序排列。例如 PYTHON 中的有序列表。二分查找的最优复杂度为 O(1)，最差时间复杂度为 O(log n)。举个例子，假设我们需要从列表 [1, 3, 5, 6, 7, 8, 12, 22, 23, 43, 65, 76, 90, 543] 中找到指定元素的下标，对应的 PYTHON 代码如下：

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

# python
def search(lis: list, x: int) -> int:
    """非递归二分查找
    返回指定元素在列表中的索引
    -1 代表不存在"""
    mix_index = 0
    max_index = len(lis) - 1
    while mix_index <= max_index:
        midpoint = (mix_index + max_index) // 2
        if lis[midpoint] < x:
            mix_index = mix_index + 1
        elif lis[midpoint] > x:
            max_index = max_index - 1
        else:
            return midpoint
    return -1

lists = [1, 3, 5, 6, 7, 8, 12, 22, 23, 43, 65, 76, 90, 543]
res = search(lists, 76)
print(res)

在取列表中间值时使用的语句是 midpoint = (mix_index + max_index) // 2，即地板除，我们可以将其替换为 midpoint = (mix_index + max_index) >> 1 最终得到的结果是相同的。这是因为左移 1位 等效于乘以 2，而右移 1 位等效于除以 2。这样的案例还有很多，此处不再赘述。 至此，我们已经对位运算有了一定的了解，希望你在工作中使用位运算。更多 Saoperation 和知识请扫描下方二维码。

本节主要内容有：

• 通过 requests 库模拟表单提交
• 通过 pandas 库提取网页表格

上周五，大师兄发给我一个网址，哭哭啼啼地求我：“去！把这个网页上所有年所有县所有作物的数据全爬下来，存到 Access 里！” 我看他可怜，勉为其难地挥挥手说：“好嘞，马上就开始！”

目标分析

大师兄给我的网址是这个：https://www.ctic.org/crm?tdsourcetag=s_pctim_aiomsg 打开长这样： 根据我学爬虫并不久的经验，通常只要把年月日之类的参数附加到 url 里面去，然后用requests.get拿到response解析 html 就完了，所以这次应该也差不多——除了要先想办法获得具体有哪些年份、地名、作物名称，其他部分拿以前的代码稍微改改就能用了，毫无挑战性工作，生活真是太无聊了 点击 View Summary 后出现目标网页长这样 那个大表格的数据就是目标数据了，好像没什么了不起的—— 有点不对劲 目标数据所在网页的网址是这样的：https://www.ctic.org/crm/?action=result ，刚刚选择的那些参数并没有作为 url 的参数啊！网址网页都变了，所以也不是 ajax 这和我想象的情况有巨大差别啊

尝试获取目标页面

让我来康康点击View Summary这个按钮时到底发生了啥：右键View Summary检查是这样： 实话说，这是我第一次遇到要提交表单的活儿。以前可能是上天眷顾我，统统get就能搞定，今天终于让我碰上一个post了。 点击View Summary，到 DevTools 里找 network 第一条： 不管三七二十一，post一下试试看

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

import requests

url = 'https://www.ctic.org/crm?tdsourcetag=s_pctim_aiomsg'
headers = {'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) '
           'AppleWebKit/537.36 (KHTML, like Gecko) '
           'Chrome/74.0.3729.131 Safari/537.36',
           'Host': 'www.ctic.org'}
data = {'_csrf': 'SjFKLWxVVkkaSRBYQWYYCA1TMG8iYR8ReUYcSj04Jh4EBzIdBGwmLw==',
        'CRMSearchForm[year]': '2011',
        'CRMSearchForm[format]': 'Acres',
        'CRMSearchForm[area]': 'County',
        'CRMSearchForm[region]': 'Midwest',
        'CRMSearchForm[state]': 'IL',
        'CRMSearchForm[county]': 'Adams',
        'CRMSearchForm[crop_type]': 'All',
        'summary': 'county'}
response = requests.post(url, data=data, headers=headers)
print(response.status_code)

果不其然，输出400……我猜这就是传说中的cookies在搞鬼吗？《Python3 网络爬虫实战》只看到第 6 章的我不禁有些心虚跃跃欲试呢！ 首先，我搞不清cookies具体是啥，只知道它是用来维持会话的，应该来自于第一次get，搞出来看看先：

1
2
3
4

response1 = requests.get(url, headers=headers)
if response1.status_code == 200:
    cookies = response1.cookies
    print(cookies)

输出：

1

<RequestsCookieJar[<Cookie PHPSESSID=52asgghnqsntitqd7c8dqesgh6 for www.ctic.org/>, <Cookie _csrf=2571c72a4ca9699915ea4037b967827150715252de98ea2173b162fa376bad33s%3A32%3A%22TAhjwgNo5ElZzV55k3DMeFoc5TWrEmXj%22%3B for www.ctic.org/>]>

Nah，看不懂，不看不管，直接把它放到post里试试

1
2

response2 = requests.post(url, data=data, headers=headers, cookies=cookies)
print(response2.status_code)

还是400，气氛突然变得有些焦灼，我给你cookies了啊，你还想要啥？！ 突然，我发现一件事：post请求所带的data中那个一开始就显得很可疑的_csrf我仿佛在哪儿见过？ 那个我完全看不懂的cookies里好像就有一个_csrf啊！但是两个_csrf的值很明显结构不一样，试了一下把data里的_csrf换成cookies里的_csrf确实也不行。 但是我逐渐有了一个想法：这个两个_csrf虽然不相等，但是应该是匹配的，我刚刚的data来自浏览器，cookies来自 python 程序，所以不匹配！ 于是我又点开浏览器的 DevTools，Ctrl+F 搜索了一下，嘿嘿，发现了： 和 这三处。 第一处那里的下一行的csrf_token很明显就是post请求所带的data里的_csrf，另外两个是 js 里的函数，虽然 js 没好好学但也能看出来这俩是通过post请求获得州名和县名的，Binggo！一下子解决两个问题。 为了验证我的猜想，我打算先直接用 requests 获取点击View Summary前的页面的 HTML 和cookies，将从 HTML 中提取的csrf_token值作为点击View Summary时post请求的data里的_csrf值，同时附上cookies，这样两处_csrf就应该是匹配的了：

1
2
3
4
5
6
7
8

from lxml import etree
response1 = requests.get(url, headers=headers)
cookies = response1.cookies
html = etree.HTML(response1.text)
csrf_token = html.xpath('/html/head/meta[3]/@content')[0]
data.update({'_csrf': csrf_token})
response2 = requests.post(url, data=data, headers=headers, cookies=cookies)
print(response2.status_code)

输出200，虽然和 Chrome 显示的302不一样，但是也表示成功，那就不管了。把response2.text写入 html 文件打开看是这样： Yeah，数据都在！说明我的猜想是对的！那一会再试试我从没用过的requests.Session()维持会话，自动处理cookies。

尝试 pandas 库提取网页表格

现在既然已经拿到了目标页面的 HTML，那在获取所有年、地区、州名、县名之前，先测试一下pandas.read_html提取网页表格的功能。 pandas.read_html这个函数时在写代码时 IDE 自动补全下拉列表里瞄到的，一直想试试来着，今天乘机拉出来溜溜：

1
2
3

import pandas as pd
df = pd.read_html(response2.text)[0]
print(df)

输出： Yeah！拿到了，确实比自己手写提取方便，而且数值字符串自动转成数值，优秀！

准备所有参数

接下来要获取所有年、地区、州名、县名。年份和地区是写死在 HTML 里的，直接 xpath 获取： 州名、县名根据之前发现的两个 js 函数，要用post请求来获得，其中州名要根据地区名获取，县名要根据州名获取，套两层循环就行

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

def new():
    session = requests.Session()
    response = session.get(url=url, headers=headers)
    html = etree.HTML(response.text)
    return session, html

session, html = new()
years = html.xpath('//*[@id="crmsearchform-year"]/option/text()')
regions = html.xpath('//*[@id="crmsearchform-region"]/option/text()')
_csrf = html.xpath('/html/head/meta[3]/@content')[0]
region_state = {}
state_county = {}
for region in regions:
    data = {'region': region, '_csrf': _csrf}
    response = session.post(url_state, data=data)
    html = etree.HTML(response.json())
    region_state[region] = {x: y for x, y in
                            zip(html.xpath('//option/@value'),
                                html.xpath('//option/text()'))}
    for state in region_state[region]:
        data = {'state': state, '_csrf': _csrf}
        response = session.post(url_county, data=data)
        html = etree.HTML(response.json())
        state_county[state] = html.xpath('//option/@value')

啧啧，使用requests.Session就完全不需要自己管理cookies了，方便！具体获得的州名县名就不放出来了，实在太多了。然后把所有年、地区、州名、县名的可能组合先整理成 csv 文件，一会直接从 csv 里读取并构造post请求的data字典：

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

remain = [[str(year), str(region), str(state), str(county)]
         for year in years for region in regions
         for state in region_state[region] for county in state_county[state]]
remain = pd.DataFrame(remain, columns=['CRMSearchForm[year]',
                                       'CRMSearchForm[region]',
                                       'CRMSearchForm[state]',
                                       'CRMSearchForm[county]'])
remain.to_csv('remain.csv', index=False)
# 由于州名有缩写和全称，也本地保存一份
import json
with open('region_state.json', 'w') as json_file:
        json.dump(region_state, json_file, indent=4)

我看了一下，一共 49473 行——也就是说至少要发送 49473 个post请求才能爬完全部数据，纯手工获取的话大概要点击十倍这个数字的次数……

正式开始

那么开始爬咯

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

import pyodbc
with open("region_state.json") as json_file:
    region_state = json.load(json_file)
data = pd.read_csv('remain.csv')
# 读取已经爬取的
cnxn = pyodbc.connect('DRIVER={Microsoft Access Driver (*.mdb, *.accdb)};'
                      'DBQ=./ctic_crm.accdb')
crsr = cnxn.cursor()
crsr.execute('select Year_, Region, State, County from ctic_crm')
done = crsr.fetchall()
done = [list(x) for x in done]
done = pd.DataFrame([list(x) for x in done], columns=['CRMSearchForm[year]',
                                                      'CRMSearchForm[region]',
                                                      'CRMSearchForm[state]',
                                                      'CRMSearchForm[county]'])
done['CRMSearchForm[year]'] = done['CRMSearchForm[year]'].astype('int64')
state2st = {y: x for z in region_state.values() for x, y in z.items()}
done['CRMSearchForm[state]'] = [state2st[x]
                                for x in done['CRMSearchForm[state]']]
# 排除已经爬取的
remain = data.append(done)
remain = remain.drop_duplicates(keep=False)
total = len(remain)
print(f'{total} left.n')
del data

# %%
remain['CRMSearchForm[year]'] = remain['CRMSearchForm[year]'].astype('str')
columns = ['Crop',
           'Total_Planted_Acres',
           'Conservation_Tillage_No_Till',
           'Conservation_Tillage_Ridge_Till',
           'Conservation_Tillage_Mulch_Till',
           'Conservation_Tillage_Total',
           'Other_Tillage_Practices_Reduced_Till15_30_Residue',
           'Other_Tillage_Practices_Conventional_Till0_15_Residue']
fields = ['Year_', 'Units', 'Area', 'Region', 'State', 'County'] + columns
data = {'CRMSearchForm[format]': 'Acres',
        'CRMSearchForm[area]': 'County',
        'CRMSearchForm[crop_type]': 'All',
        'summary': 'county'}
headers = {'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) '
           'AppleWebKit/537.36 (KHTML, like Gecko) '
           'Chrome/74.0.3729.131 Safari/537.36',
           'Host': 'www.ctic.org',
           'Upgrade-Insecure-Requests': '1',
           'DNT': '1',
           'Connection': 'keep-alive'}
url = 'https://www.ctic.org/crm?tdsourcetag=s_pctim_aiomsg'
headers2 = headers.copy()
headers2 = headers2.update({'Referer': url,
                            'Origin': 'https://www.ctic.org'})
def new():
    session = requests.Session()
    response = session.get(url=url, headers=headers)
    html = etree.HTML(response.text)
    _csrf = html.xpath('/html/head/meta[3]/@content')[0]
    return session, _csrf
session, _csrf = new()
for _, row in remain.iterrows():
    temp = dict(row)
    data.update(temp)
    data.update({'_csrf': _csrf})
    while True:
        try:
            response = session.post(url, data=data, headers=headers2, timeout=15)
            break
        except Exception as e:
            session.close()
            print(e)
            print('nSleep 30s.n')
            time.sleep(30)
            session, _csrf = new()
            data.update({'_csrf': _csrf})

    df = pd.read_html(response.text)[0].dropna(how='all')
    df.columns = columns
    df['Year_'] = int(temp['CRMSearchForm[year]'])
    df['Units'] = 'Acres'
    df['Area'] = 'County'
    df['Region'] = temp['CRMSearchForm[region]']
    df['State'] = region_state[temp['CRMSearchForm[region]']][temp['CRMSearchForm[state]']]
    df['County'] = temp['CRMSearchForm[county]']
    df = df.reindex(columns=fields)
    for record in df.itertuples(index=False):
        tuple_record = tuple(record)
        sql_insert = f'INSERT INTO ctic_crm VALUES {tuple_record}'
        sql_insert = sql_insert.replace(', nan,', ', null,')
        crsr.execute(sql_insert)
        crsr.commit()
    print(total, row.to_list())
    total -= 1
else:
    print('Done!')
    crsr.close()
    cnxn.close()

注意中间有个try...except..语句，是因为不定时会发生Connection aborted的错误，有时 9000 次才断一次，有时一次就断，这也是我加上了读取已经爬取的和排除已经爬取的原因，而且担心被识别出爬虫，把headers写的丰富了一些（好像并没有什么卵用），并且每次断开都暂停个 30s 并重新开一个会话 然后把程序开着过了一个周末，命令行里终于打出了Done!，到 Access 里一看有 816288 条记录，心想：下次试试多线程（进程）和代理池。

周一，我把跑出来的数据发给大师兄，大师兄回我：“好的”。 隔着屏幕我都能感受到滔滔不绝的敬仰和感激之情， 一直到现在，大师兄都感动地说不出话来。

前言

本篇博文来自一次公司内部的前端分享，从多个方面讨论了在设计接口时遵循的原则，总共包含了七个大块。系卤煮自己总结的一些经验和教训。本篇博文同时也参考了其他一些文章，相关地址会在后面贴出来。很难做到详尽充实，如果有好的建议或者不对的地方，还望不吝赐教斧正。

一、接口的流畅性

好的接口是流畅易懂的，他主要体现如下几个方面： 1.简单 操作某个元素的css属性，下面是原生的方法:

1

document.querySelector('#id').style.color = 'red';

封装之后

1
2
3
4

function a(selector, color) {
  document.querySelector(selector).style.color = color
}
a('#a', 'red');

从几十个字母长长的一行到简简单单的一个函数调用，体现了api设计原则之一：简单易用。 2.可阅读性 a(‘#a’, ‘red’)是个好函数，帮助我们简单实用地改变某个元素，但问题来了，如果第一次使用该函数的人来说会比较困惑，a函数是啥函数，没有人告诉他。开发接口有必要知道一点，大多数人都是懒惰的（包括卤煮自己），从颜色赋值这个函数来说，虽然少写了代码，但是增加了单词字母的个数，使得它不再好记。每次做这件事情的时候都需要有映射关系： a—->color. 如果是简单的几个api倒是无所谓，但是通常一套框架都有几十甚至上百的api，映射成本增加会使得程序员哥哥崩溃。 我们需要的就是使得接口名称有意义，下面我们改写一下a函数：

1
2

function letSomeElementChangeColor(selector, color) {
  document.querySelectorAll(selector, color).style.color = color; }

letSomeElementChangeColor相对于a来说被赋予了现实语言上的意义，任何人都不需要看说明也能知道它的功能。 3.减少记忆成本 我们刚刚的函数太长了，letSomeElementChangeColor虽然减少了映射成本，有了语言上的意义，但是毫无疑问增加了记忆成本。要知道，包括学霸在内，任何人都不喜欢背单词。不仅仅在此处，原生获取dom的api也同样有这个问题： document.getElementsByClassName； document.getElementsByName; document.querySelectorAll;这些api给人的感觉就是单词太长了，虽然他给出的意义是很清晰，然而这种做法是建立在牺牲简易性和简忆性的基础上进行的。于是我们又再次改写这个之前函数

1
2
3

function setColor(selector, color) {
 xxxxxxxxxxxx
}

在语言意义不做大的变化前提下，缩减函数名称。使得它易读易记易用。 4.可延伸 所谓延伸就是指函数的使用像流水一样按照书写的顺序执行形成执行链条:

1
2
3

document.getElementById('id').style.color = 'red';
document.getElementById('id').style.fontSize = '12px';
document.getElementById('id').style.backgourdColor = 'pink';

如果我们需要实现像以上有强关联性的业务时，用我们之前的之前的方法是再次封装两个函数 setFontSize, setbackgroundColor; 然后执行它们 setColor(‘id’, ‘red’);setFontSiez(‘id’, ’12px’); setbackgroundColor(‘id’, ‘pink’); 显然，这样的做法没有懒出境界来；id元素每次都需要重新获取，影响性能，失败；每次都需要添加新的方法，失败； 每次还要调用这些方法，还是失败。下面我们将其改写为可以延伸的函数 首先将获取id方法封装成对象,然后再对象的每个方法中返回这个对象：

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

function getElement(selector) {
  this.style = document.querySelecotrAll(selector).style;
}

getElement.prototype.color = function(color) {
  this.style.color = color;
  return this;
}
getElement.prototype.background = function(bg) {
  this.style.backgroundColor = bg;
  return this;
}
getElement.prototype.fontSize = function(size) {
  this.style.fontSize = size;
  return this;
}

//调用
var el = new getElement('#id')
el.color('red').background('pink').fontSize('12px');

简单、流畅、易读，它们看起来就像行云流水一样，即在代码性能上得到了提升优化，又在视觉上悦目。后面我们会在参数里面讲到如何继续优化。 所以，大家都比较喜欢用jquery的api，虽然一个$符号并不代表任何现实意义，但简单的符号有利于我们的使用。它体现了以上的多种原则，简单，易读，易记，链式写法，多参处理。 nightmare:

1
2
3

document.getElementById('id').style.color = 'red';
document.getElementById('id').style.fontSize = '12px';
document.getElementById('id').style.backgourdColor = 'pink';

dream:

1

$('id').css({color:'red', fontSize:'12px', backgroundColor:'pink'})

二、一致性

1.接口的一致性 相关的接口保持一致的风格，一整套 API 如果传递一种熟悉和舒适的感觉，会大大减轻开发者对新工具的适应性。 命名这点事：既要短，又要自描述，最重要的是保持一致性 “在计算机科学界只有两件头疼的事：缓存失效和命名问题” — Phil Karlton 选择一个你喜欢的措辞，然后持续使用。选择一种风格，然后保持这种风格。 Nightmare:

1
2
3
4

setColor,
letBackGround
changefontSize
makedisplay

dream:

1
2
3
4

setColor;
setBackground;
setFontSize
set.........

尽量地保持代码风格和命名风格，使别人读你的代码像是阅读同一个人写的文章一样。

三、参数的处理

1.参数的类型 判断参数的类型为你的程序提供稳定的保障

1
2
3
4
5

//我们规定，color接受字符串类型
function setColor(color) {
  if(typeof color !== 'string') return;
dosomething
}

2.使用json方式传参 使用json的方式传值很多好处，它可以给参数命名，可以忽略参数的具体位置，可以给参数默认值等等 比如下面这种糟糕的情况:

1

function fn(param1, param2...............paramN)

你必须对应地把每一个参数按照顺序传入，否则你的方法就会偏离你预期去执行，正确的方法是下面的做法。

1
2
3
4
5
6
7
8

function fn(json) {
//为必须的参数设置默认值
   var default = extend({
    param: 'default',
    param1: 'default'
    ......
   },json)
}

这段函数代码，即便你不传任何参数进来，他也会预期运行。因为在声明的时候，你会根据具体的业务预先决定参数的缺省值。

四、可扩展性

软件设计最重要的原则之一：永远不修改接口，而是去扩展它！可扩展性同时会要求接口的职责单一，多职责的接口很难扩展。 举个栗子：

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

//需要同时改变某个元素的字体和背景
// Nightmare:
function set(selector, color) {
  document.querySelectroAll(selector).style.color = color;
  document.querySelectroAll(selector).style.backgroundColor = color;
}

//无法扩展改函数，如果需要再次改变字体的大小的话，只能修改此函数，在函数后面填加改变字体大小的代码

//Dream
function set(selector, color) {
  var el = document.querySelectroAll(selector);
  el.style.color = color;
  el.style.backgroundColor = color;
  return el;
}

//需要设置字体、背景颜色和大小
function setAgain (selector, color, px) {
  var el = set(selector, color)
  el.style.fontSize = px;
  return el;
}

以上只是简单的添加颜色，业务复杂而代码又不是你写的时候，你就必须去阅读之前的代码再修改它，显然是不符合开放-封闭原则的。修改后的function是返回了元素对象，使得下次需要改变时再次得到返回值做处理。 2.this的运用 可扩展性还包括对this的以及call和apply方法的灵活运用：

1
2
3
4
5
6
7
8
9

function sayBonjour() {
  alert(this.a)
}

obj.a = 1;
obj.say = sayBonjour;
obj.say();//1
//or
sayBonjour.call||apply(obj);//1

五、对错误的处理

1.预见错误 可以用 类型检测 typeof 或者try…catch。 typeof 会强制检测对象不抛出错误，对于未定义的变量尤其有用。 2.抛出错误 大多数开发者不希望出错了还需要自己去找带对应得代码，最好方式是直接在console中输出，告诉用户发生了什么事情。我们可以用到浏览器为我们提供的api输出这些信息:console.log/warn/error。你还可以为自己的程序留些后路: try…catch。

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

function error (a) {
  if(typeof a !== 'string') {
    console.error('param a must be type of string')
  }
}

function error() {
  try {
    // some code excucete here maybe throw wrong
  }catch(ex) {
    console.wran(ex);
  }
}

六、可预见性

可预见性味程序接口提供健壮性，为保证你的代码顺利执行，必须为它考虑到非正常预期的情况。我们看下不可以预见的代码和可预见的代码的区别用之前的setColor

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

//nighware
function set(selector, color) {
  document.getElementById(selector).style.color = color;
}

//dream
zepto.init = function(selector, context) {
  var dom
  // If nothing given, return an empty Zepto collection
  if (!selector) return zepto.Z()
  // Optimize for string selectors
  else if (typeof selector == 'string') {
    selector = selector.trim()
    // If it's a html fragment, create nodes from it
    // Note: In both Chrome 21 and Firefox 15, DOM error 12
    // is thrown if the fragment doesn't begin with <
    if (selector[0] == '<' && fragmentRE.test(selector))
      dom = zepto.fragment(selector, RegExp.$1, context), selector = null
    // If there's a context, create a collection on that context first, and select
    // nodes from there
    else if (context !== undefined) return $(context).find(selector)
    // If it's a CSS selector, use it to select nodes.
    else dom = zepto.qsa(document, selector)
  }
  // If a function is given, call it when the DOM is ready
  else if (isFunction(selector)) return $(document).ready(selector)
  // If a Zepto collection is given, just return it
  else if (zepto.isZ(selector)) return selector
  else {
    // normalize array if an array of nodes is given
    if (isArray(selector)) dom = compact(selector)
    // Wrap DOM nodes.
    else if (isObject(selector))
      dom = [selector], selector = null
    // If it's a html fragment, create nodes from it
    else if (fragmentRE.test(selector))
      dom = zepto.fragment(selector.trim(), RegExp.$1, context), selector = null
    // If there's a context, create a collection on that context first, and select
    // nodes from there
    else if (context !== undefined) return $(context).find(selector)
    // And last but no least, if it's a CSS selector, use it to select nodes.
    else dom = zepto.qsa(document, selector)
  }
  // create a new Zepto collection from the nodes found
  return zepto.Z(dom, selector)
}

以上是zepto的源码，可以看见，作者在预见传入的参数时做了很多的处理。其实可预见性是为程序提供了若干的入口，无非是一些逻辑判断而已。zepto在这里使用了很多的是非判断，这样做的好处当然是代码比之前更健壮，但同时导致了代码的冗长，不适合阅读。总之，可预见性真正需要你做的事多写一些对位置实物的参数。把外部的检测改为内部检测。是的使用的人用起来舒心放心开心。呐！做人嘛最重要的就是海森啦。

七、注释和文档的可读性

一个最好的接口是不需要文档我们也会使用它，但是往往接口量一多和业务增加，接口使用起来也会有些费劲。所以接口文档和注释是需要认真书写的。注释遵循简单扼要地原则，给多年后的自己也给后来者看：

1
2
3
4
5
6
7
8
9
10

//注释接口，为了演示PPT用
function commentary() {
  //如果你定义一个没有字面意义的变量时，最好为它写上注释：a：没用的变量，可以删除
  var a;

  //在关键和有歧义的地方写上注释，犹如画龙点睛：路由到hash界面后将所有的数据清空结束函数
  return go.Navigate('hash', function(){
    data.clear();
  });
}

最后

推荐markdown语法书写API文档，github御用文档编写语法。简单、快速，代码高亮、话不多说上图 卤煮在此也推荐几个在线编辑的网站。诸君可自行前往练习使用。 https://www.zybuluo.com/mdeditor http://mahua.jser.me/

参考博文

前端头条-javascript的api设计原则 原文：http://www.cnblogs.com/constantince/p/5580003.html

在这篇文章中，我们将介绍一些用于AJAX调用的最好的JS库，包括jQuery，Axios和Fetch。欢迎查看代码示例！ AJAX是用来对服务器进行异步HTTP调用的一系列web开发技术客户端框架。 AJAX即Asynchronous JavaScript and XML（异步JavaScript和XML）。AJAX曾是web开发界的一个常见名称，许多流行的JavaScript小部件都是使用AJAX构建的。例如，有些特定的用户交互（如按下按钮）会异步调用到服务器，服务器会检索数据并将其返回给客户端——所有这些都不需要重新加载网页。

AJAX的现代化重新引入

JavaScript已经进化了，现在我们使用前端库和/或如React、Angular、Vue等框架构建了动态的网站。AJAX的概念也经历了重大变化，因为现代异步JavaScript调用涉及检索JSON而不是XML。有很多库允许你从客户端应用程序对服务器进行异步调用。有些进入到浏览器标准，有些则有很大的用户基础，因为它们不但灵活而且易于使用。有些支持promises，有些则使用回调。在本文中，我将介绍用于从服务器获取数据的前5个AJAX库。

Fetch API

Fetch API是XMLHttpRequest的现代替代品，用于从服务器检索资源。与XMLHttpRequest不同的是，它具有更强大的功能集和更有意义的命名。基于其语法和结构，Fetch不但灵活而且易于使用。但是，与其他AJAX HTTP库区别开来的是，它具有所有现代Web浏览器的支持。Fetch遵循请求-响应的方法，也就是说，Fetch提出请求并返回解析到Response对象的promise。 你可以传递Request对象来获取，或者，也可以仅传递要获取的资源的URL。下面的示例演示了使用Fetch创建简单的GET请求。

1
2
3
4
5
6
7
8

fetch('https://www.example.com', {
        method: 'get'
    })
    .then(response => response.json())
    .then(jsonData => console.log(jsonData))
    .catch(err => {
            //error block
     })

正如你所看到的，Fetch的then方法返回了一个响应对象，你可以使用一系列的then 进行进一步的操作。我使用.json() 方法将响应转换为JSON并将其输出到控制台。 假如你需要POST表单数据或使用Fetch创建AJAX文件上传，将会怎么样？此时，除了Fetch之外，你还需要一个输入表单，并使用FormData库来存储表单对象。

1
2
3
4
5
6
7
8

var input = document.querySelector('input[type="file"]')
var data = new FormData()
data.append('file', input.files[0])
data.append('user', 'blizzerand')
fetch('/avatars', {
    method: 'POST',
    body: data
})

你可以在官方的Mozilla web文档中阅读更多关于Fetch API的信息。

Axios

Axios是一个基于XMLHttpRequest而构建的现代JavaScript库，用于进行AJAX调用。它允许你从浏览器和服务器发出HTTP请求。此外，它还支持ES6原生的Promise API。Axios的其他突出特点包括：

• 拦截请求和响应。
• 使用promise转换请求和响应数据。
• 自动转换JSON数据。
• 取消实时请求。

要使用Axios，你需要先安装它。

1

npm install axios

下面是一个演示Axios行动的基本例子。

1
2
3
4
5
6
7
8

// Make a request for a user with a given ID
axios.get('/user?ID=12345')
  .then(function (response) {
    console.log(response);
  })
  .catch(function (error) {
    console.log(error);
  });

与Fetch相比，Axios的语法更简单。让我们做一些更复杂的事情，比如我们之前使用Fetch创建的AJAX文件上传器。

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

var data = new FormData();
   data.append('foo', 'bar');
   data.append('file', document.getElementById('file').files[0]);
   var config = {
        onUploadProgress: function(progressEvent) {
          var percentCompleted = Math.round( (progressEvent.loaded * 100) / progressEvent.total );
        }
    };
    axios.put('/upload/server', data, config)
      .then(function (res) {
        output.className = 'container';
        output.innerHTML = res.data;
      })
      .catch(function (err) {
        output.className = 'container text-danger';
        output.innerHTML = err.message;
      });

Axios更具可读性。Axios也非常受React和Vue等现代库的欢迎。

jQuery

jQuery曾经是JavaScript中的一个前线库，用于处理从AJAX调用到操纵DOM内容的所有事情。虽然随着其他前端库的“冲击”，其相关性有所降低，但你仍然可以使用jQuery来进行异步调用。 如果你之前使用过jQuery，那么这可能是最简单的解决方案。但是，你将不得不导入整个jQuery库以使用$.ajax方法。虽然这个库有特定于域的方法，例如$.getJSON，$.get和$.post，但是其语法并不像其他的AJAX库那么简单。以下代码用于编写基本的GET请求。

1
2
3
4
5
6
7
8
9
10
11

$.ajax({
  url: '/users',
  type: "GET",
  dataType: "json",
  success: function (data) {
      console.log(data);
  }
  fail: function () {
      console.log("Encountered an error")
  }
});

jQuery好的地方在于，如果你有疑问，那么你可以找到大量的支持和文档。我发现了很多使用FormData()和jQuery进行AJAX文件上传的例子。下面是最简单的方法：

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

var formData = new FormData();
formData.append('file', $('#file')[0].files[0]);
$.ajax({
       url : 'upload.php',
       type : 'POST',
       data : formData,
       processData: false,  // tell jQuery not to process the data
       contentType: false,  // tell jQuery not to set contentType
       success : function(data) {
           console.log(data);
           alert(data);
       }
});

SuperAgent

SuperAgent是一个轻量级和渐进式的AJAX库，更侧重于可读性和灵活性。SuperAgent还拥有一个温和的学习曲线，不像其他库。它有一个针对Node.js API相同的模块。SuperAgent有一个接受GET、POST、PUT、DELETE和HEAD等方法的请求对象。然后你可以调用.then()，.end()或新的.await()方法来处理响应。例如，以下代码为使用SuperAgent的简单GET请求。

1
2
3
4
5
6
7
8

request
   .post('/api/pet')
   .send({ name: 'Manny', species: 'cat' })
   .set('X-API-Key', 'foobar')
   .set('Accept', 'application/json')
   .then(function(res) {
      alert('yay got ' + JSON.stringify(res.body));
   });

如果你想要做更多的事情，比如使用此AJAX库上传文件，那该怎么做呢？ 同样超级easy。

1
2
3
4
5
6
7

request
   .post('/upload')
   .field('user[name]', 'Tobi')
   .field('user[email]', 'tobi@learnboost.com')
   .field('friends[]', ['loki', 'jane'])
   .attach('image', 'path/to/tobi.png')
   .then(callback);

如果你有兴趣了解更多关于SuperAgent的信息，那么它们有一系列很不错的文档来帮助你开始这个旅程。

Request——简化的HTTP客户端

Request库是进行HTTP调用最简单的方法之一。结构和语法与在Node.js中处理请求的方式非常相似。目前，该项目在GitHub上有18K个星，值得一提的是，它是可用的最流行的HTTP库之一。 下面是一个例子：

1
2
3
4
5
6

var request = require('request');
request('http://www.google.com', function (error, response, body) {
  console.log('error:', error); // Print the error if one occurred
  console.log('statusCode:', response && response.statusCode); // Print the response status code if a response was received
  console.log('body:', body); // Print the HTML for the Google homepage.
});

结论

从客户端进行HTTP调用在十年前可不是一件容易的事。前端开发人员不得不依赖于难以使用和实现的XMLHttpRequest。现代的库和HTTP客户端使得用户交互、动画、异步文件上传等前端功能变得更加简单。 我个人最喜欢的是Axios，因为我觉得它更易读更赏心悦目。你也可以忠于Fetch，因为它文档化良好且有标准化的解决方案。 你个人最喜欢的AJAX库是哪个？ 欢迎各位分享你的看法。

• 译文链接：http://www.codeceo.com/article/5-javascript-ajax-libs.html
• 英文原文：Top JavaScript Libraries for Making AJAX Calls
• 翻译作者：码农网 – 小峰

简评：一开始 JavaScript 只是为网页增添一些实时动画效果，现在 JS 已经能做到前后端通吃了，而且还是年度流行语言。本文分享几则 JS 小窍门，可以让你事半功倍 ~

1. 删除数组尾部元素

一个简单方法就是改变数组的length值:

1
2
3
4
5
6
7
8

const arr = [11, 22, 33, 44, 55, 66];
// truncanting
arr.length = 3;
console.log(arr); //=> [11, 22, 33]
// clearing
arr.length = 0;
console.log(arr); //=> []
console.log(arr[2]); //=> undefined

2. 使用对象解构（object destructuring）来模拟命名参数

如果需要将一系列可选项作为参数传入函数，你很可能会使用对象（Object）来定义配置（Config）。

1
2
3
4
5
6
7

doSomething({ foo: 'Hello', bar: 'Hey!', baz: 42 });
function doSomething(config) {
  const foo = config.foo !== undefined ? config.foo : 'Hi';
  const bar = config.bar !== undefined ? config.bar : 'Yo!';
  const baz = config.baz !== undefined ? config.baz : 13;
  // ...
}

不过这是一个比较老的方法了，它模拟了 JavaScript 中的命名参数。 在 ES 2015 中，你可以直接使用对象解构：

1
2
3

function doSomething({ foo = 'Hi', bar = 'Yo!', baz = 13 }) {
  // ...
}

让参数可选也很简单：

1
2
3

function doSomething({ foo = 'Hi', bar = 'Yo!', baz = 13 } = {}) {
  // ...
}

3. 使用对象解构来处理数组

可以使用对象解构的语法来获取数组的元素：

1
2

const csvFileLine = '1997,John Doe,US,john@doe.com,New York';
const { 2: country, 4: state } = csvFileLine.split(',');

4. 在 Switch 语句中使用范围值

可以这样写满足范围值的语句：

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

function getWaterState(tempInCelsius) {
  let state;

  switch (true) {
    case (tempInCelsius <= 0): 
      state = 'Solid';
      break;
    case (tempInCelsius > 0 && tempInCelsius < 100): 
      state = 'Liquid';
      break;
    default: 
      state = 'Gas';
  }
  return state;
}

5. await 多个 async 函数

在使用 async/await 的时候，可以使用 Promise.all 来 await 多个 async 函数

1

await Promise.all([anAsyncCall(), thisIsAlsoAsync(), oneMore()])

6. 创建 Pure objects

你可以创建一个 100% pure object，它不从Object中继承任何属性或则方法（比如constructor, toString()等）

1
2
3
4
5

const pureObject = Object.create(null);
console.log(pureObject); //=> {}
console.log(pureObject.constructor); //=> undefined
console.log(pureObject.toString); //=> undefined
console.log(pureObject.hasOwnProperty); //=> undefined

7. 格式化 JSON 代码

JSON.stringify除了可以将一个对象字符化，还可以格式化输出 JSON 对象

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

const obj = { 
  foo: { bar: [11, 22, 33, 44], baz: { bing: true, boom: 'Hello' } } 
};
// The third parameter is the number of spaces used to 
// beautify the JSON output.
JSON.stringify(obj, null, 4); 
// =>"{
// =>    "foo": {
// =>        "bar": [
// =>            11,
// =>            22,
// =>            33,
// =>            44
// =>        ],
// =>        "baz": {
// =>            "bing": true,
// =>            "boom": "Hello"
// =>        }
// =>    }
// =>}"

8. 从数组中移除重复元素

通过使用集合语法和 Spread 操作，可以很容易将重复的元素移除：

1
2
3

const removeDuplicateItems = arr => [...new Set(arr)];
removeDuplicateItems([42, 'foo', 42, 'foo', true, true]);
//=> [42, "foo", true]

9. 平铺多维数组

使用 Spread 操作平铺嵌套多维数组：

1
2

const arr = [11, [22, 33], [44, 55], 66];
const flatArr = [].concat(...arr); //=> [11, 22, 33, 44, 55, 66]

不过上面的方法仅适用于二维数组，但是通过递归，就可以平铺任意维度的嵌套数组了：

1
2
3
4
5
6
7
8
9

function flattenArray(arr) {
  const flattened = [].concat(...arr);
  return flattened.some(item => Array.isArray(item)) ? 
    flattenArray(flattened) : flattened;
}

const arr = [11, [22, 33], [44, [55, 66, [77, [88]], 99]]];
const flatArr = flattenArray(arr); 
//=> [11, 22, 33, 44, 55, 66, 77, 88, 99]

希望这些小技巧能帮助你写好 JavaScript ~ 原文：https://zhuanlan.zhihu.com/p/37493249

现代人都普遍比较焦虑，越来越多的人感到生活压力很大，在一二线城市不少白领人士更是已是患上“知识焦虑症”：这年头知识信息迭代太快，学习跟不上，别人懂的自己都不懂，总感觉自己欠缺的很多，没有技术和专长不知未来靠什么生存，担心自己长期落后他人从而被社会淘汰，从而产生了一种对未来不确定的心理恐惧。 于是，他们就急于渴求，希望能在短时间内学习大量知识希望从根本上解决自己的实际问题，拼命利用碎片化时间学习补充欠缺知识，不断完善自己的知识体系。这时知识付费的出现，正好满足了他们这些刚性需求。 再加上2018年前以逻辑思维为主一批内容供应商到处鼓吹和贩卖知识焦虑，在这种风气影响下连身边的很多小伙伴都购买了大量知识付费产品，但一年下来却发现这些知识根本没有学会几个，内容良莠不齐，服务跟不上，就算能坚持学完下来还是什么都不会，焦虑依然存在 。甚至更多人觉得其实知识付费就是一场骗局，从本质上来说知识付费并没有解决任何的问题，表面上只是缓解了一些焦虑，在短时间内让一些人自我感觉良好，实则上只是自欺欺人而已。 于是，一些感觉被欺骗的用户纷纷发声，对某些知识付费大号和机构更是愤怒抨击，在这些负面影响下这两年知识付费其实已逐渐降温并遭遇爆冷，甚至还有一些负面声音在说： 在线知识付费的寒冬是不是要来临了？ 其实不然，纵观当下市场发展态势知识付费的前景仍然是广阔的，竞争激烈程度仍方兴未艾，当人们对知识的盲目消费退烧后，知识付费更多的是回归服务价值， 核心需求有两方面 ： 一方面是为了提升欠缺的知识让自己具有更多的市场竞争力，另一方面也希望自己花钱买的知识付费产品是一些真正有帮助的东西，可帮自己迎来一个不错的未来。所以，知识付费的下一阶段必然聚焦于如何让学习用户获得真正有效的学习效果。 那么，知识付费下半场风口到底会吹去哪？ 好学豚认为这一领域的大方向以后的发展趋势大致有如下特征：

趋势一：内容下沉，回归有价值的真实内容

1、职场技能

在知识付费领域和在整个教育市场体系里，职场技能都是最刚需的内容板块，从最早的电算会计化到后来的英语类培训，再到如今一些以工具为代表的设计、办公技能、IT编程等等培训，无一不彰显着其旺盛的生命力。 究其根本原因，这是因为它能够切实解决职场人士的实际需求，所以职场技能内容才会一直火爆，繁荣至今仍在蓬勃发展。

2、知识拓展

知识拓展是近年来兴起的版块内容，也是互联网上传播特别广泛的内容。以得到为代表，邀请行业细分领域的专业人士，按照标准的生产流程来生产较高质量的内容，帮助拓广知识的视野从而实现专家指路的效果。不容忽视的是，知识拓展的内容从今天来看存在较大的局限，很难解决用户的实际问题，学习效果也很难得到保证；如何打磨出更加直击用户痛点的产品，需要更多的探索和尝试。

3、兴趣爱好

在线教育领域，兴趣爱好的内容已经有了长足发展。用户的痛点正在逐渐从追求高大上、财务自由这些虚伪的概念转型到享受生活：提 升生活趣味让自己活得更舒服。兴趣爱好内容之所以能生命力如此旺盛，最大因素要得益于其以兴趣为导向，学习者本身并不会有太高的学习结果诉求，更多的是在学习之中获得的乐趣以及对授课老师的认同。

趋势二：后续服务提升，注重全流程效果

今后知识付费需要做好三个关键点的平衡：碎片化学习、学习规模和学习效果，这三者缺一不可。根据业内行家的实践和推断，下一阶段知识付费的标配服务模式将会是1+1+N模式，能较好地实现以上三个关键点的平衡。 第一个“1”代表的是标准化的课程： 这个课程将会以“图文”、“视频”或“音频”形式进行展现，让学习者完成自学。这个“1”满足了碎片化学习的随时随地性，给予了学习者最大限度的自由度，同时也满足了由于学习规模日益扩大而带来的各种问题。 第二个“1”代表的是在线训练营： 就是把线下的集中学习模式搬到线上，开展一段时间的在线集中训练，通过学习流程、学习氛围、学习评估的三位一体运作，从而使学习效果得以达成。总体做法是把所有参与训练营的学员，分成不同的小组，然后配定相应老师。每个学员在学习过程中都需要完成相应作业，然后交给老师进行批改和点评。整个训练营阶段会有实战练习，根据学习者的自身情况或使用真实的案例来进行实战，进而帮助学习者实现学以致用。同时，老师需要对每个学习者进行阶段性评分，在学习完成时要进行总体评估；老师还需要针对小组学习效果进行展示和相应氛围的营造。 最后一个“N”则代表通过科技的力量，实现多种教学辅助手段 ：比如老师和学员之间的交互，老师批量布置和批改作业，对学员进行评分和评估，给积极学习者一些奖励等等，所有这些辅助手段，将会让老师和学员之间的交互更紧密，让学习效率更高、让学习流程更完整、学习模式更人性，从而最终达到提升学习效果的目的。

趋势三：更多垂直领域的小KOL将通过工具类平台输出产品

垂直领域的小KOL，他们标签清晰、价值点明确，用户深度认可，反倒更容易突围，甚至可以脱离平台，通过好学豚这类工具就可以完成知识店铺的搭建。而且因为他们有很强的用户沉淀能力，所以也更有动力参与。长期来看，小KOL通过线上虚拟产品输出知识将会成为一个新的趋势。

趋势四：一线城市受众有限，二、三线城市女性用户价值开始受到重视

一线城市对于知识付费产品的承载能力是有限的，据观察主流付费用户都不是一线白领，而是二三线城市的宝妈。她们更愿意在知识上付钱，也愿意分享课程，赚取一定分成。 互联网独角兽的发展规律一再地证明二三线城市的女性是主力消费群体，知识付费也不会逃离这个规律，现在很多母婴类课程、女性个人提升课程、陪伴式励志课程、情商人际关系类课程销量都很不错。这是一个巨大的市场空窗，目前市场上的多数知识付费平台还忽视了二三线城市的用户，电商平台和垂直大号也还没有真正介入这一行业，这个空窗很有可能下一家知识付费独角兽企业崛起的机会。 针对以上趋势，好学豚知识付费平台也正在进行多方面的尝试，希望能把握住这些新的市场机会迎来爆发性增长，对于当下的知识付费从业者来说既是一个巨大的挑战，也是突围而出成为新独角兽企业的机会。 原文：https://www.iyiou.com/p/104850.html

首先，这篇文章不是一个广告。 但你可能已经要被这个时代无处不在的洗脑广告逼疯了。 大街小巷贴满的纸皮广告、商场和电梯里循环播放的电子屏广告、电脑上避不开关不掉停不了的网页广告…… 某招聘软件和某旅拍公司的循环怒吼式视频让人生理性地记住了它，但心理上可能想把相关人员关电梯里让它们把这条广告看一万遍。 ▲ 图片来自：「伯爵旅拍」广告截图 广告的形式不断在变化，从广播、平面、视频，到 H5、直播，部分广告会以新颖的形式和优质的内容取胜，但人们看广告一直都是被动接受的过程。 上周蜘蛛侠上映，索尼在 Snapchat 上 推出了 AR 活动宣传 ，为了贴合「英雄远征」的主题，索尼让蜘蛛侠「出现」在世界各地的地标处，比如纽约的熨斗大厦、伦敦的白金汉宫、巴黎的艾菲尔铁塔，只要你将自拍镜头对准建筑，就可以看到蜘蛛侠在屏幕上摆动。 ▲图片来自：mobilemarketingmagazine 它让人们愿意看蜘蛛侠的广告，同时也让广告成了一种主动参与的过程。 接下来要讲的，就是未来这一种我们会主动点开的——VR 广告。

当广告变成了一种「真实」的体验

我们看现在的广告，有一种潜意识默认的原则，就是注意力只给它们 3 秒钟。 但现在的 VR 广告，是给你无限的时间，让你自己去体验。 AR 火起来，还是被 2015 年 Snapchat 的搞怪 AR 滤镜，以及 2016 年的神奇宝贝 GO 带动，这也改变了市场营销对 AR 的看法，让 AR 开始在广告界生根发芽。 宜家是首批尝试购买 AR 技术并以此宣传的公司之一。 在 IKEA Place app 中 ，人们可以看到新款家具实际摆放在家里的样子，以判断它们是不是有足够空间布局放置、颜色风格是否和周围环境搭调，这可以帮宜家提高客户满意度以及降低产品退回率。 随后苹果发布了 ARkit 技术，Google、Facebook、亚马逊等大公司也在 2017 年和 2018 年期间发布了自己 AR 软件开发套件，以支持日后 AR 技术的发展。 Facebook 去年就为广告商提供了 展示产品的新方式 ，让人们在新闻流中看到品牌广告时，能够通过前置摄像头对比自己戴上太阳镜等配饰、甚至穿各种衣服的样子。现在 Facebook 也一直在通过各个平台包括 Instagram 扩大购物范围和增值产品。 除了家居服饰，美容时尚等行业也开始尝试利用 AR 营销，主要是为了弥补线上和线下的差距。 两周前，人们已经能在 YouTube 上一边看美妆博主的化妆教程，一边在分屏之下跟着博主一起涂口红试色，这个名为 AR Beauty Try-On 的功能 由 Google 推出，M・A・C 是第一个跟上这项 AR 广告的品牌。测试结果发现，人们愿意花费超过 80 秒的时间去体验虚拟唇膏色调。 甚至当你逛淘宝店，在前几周 天猫旗舰店升级的 2.0 版本，能直接让你像逛线下实体店一样逛线上 3D 商店、参观漫游，每家店铺展示内容也因人而异。 而且，你还可以实地进入 AR 广告之中。 在汽车行业，宝马、保时捷、丰田等汽车品牌都成为了 AR 广告的追随者。 丰田上个月给 2020 年卡罗拉 推出了 AR 移动广告 ，人们可以 360 度全方位观看车内视图和功能，以及固定在一个地方的 3D 数字模型，甚至还可以在车内行走。这能让购买者更简单地了解车辆的技术特性，也有助于在购买车辆前对其预先认证。 这种自然而直观的方式，不仅让人们和品牌建立起更真实的关系，与以往广告最大的不同就是，人们还能随时参与、持续互动，并响应内容。

我们可以拿回看广告的主动权

现在，我们自己可以掌控广告。 目前我们 能看到的 AR 广告 ，主要包括被赞助的拍照滤镜镜头、应用软件和游戏内的 AR 广告单元，信息流内的 AR 广告单元等。 之前是广告「邀请」我们看，没有任何协商。但现在我们「侵入」广告，去满足自己的好奇心。广告变成了一个工具，我们通过它与我们喜欢的品牌获得联系。 这种形式现在也让 AR 广告成为当今市场上破坏性最小的广告单元之一。 ▲ 图片来自：unsplash 另外，AR 广告已经不再是单独的一个内容，而是进入我们的真实生活，或者进入其它我们沉浸的内容之中——广告本身就是商品的展示位，不会再有其它如美化特效、夸张视觉等因素插入和干扰。 而且这些 AR 广告最初打开的阀门，就掌握在消费者手上。 因为 AR 广告现在都需要申请对其相机／设备的访问，在非相机优先的应用中，也需要申请特定权限，因此你完全可以选择你需要的内容，并与之开始进一步互动。 ▲ 图片来自： Cyber Infrastructure 可以说，AR 就是有史以来最强大的故事叙述媒体。它的互动带来的「响应式特色」，就是它最大的优势。 Unity 技术的 AR / VR 广告创新 负责人 Tony Parisi 说 ： 响应性 AR 广告是一种更加友好，不那么令人生畏的方法，这些广告能够提高客户的选择率，同时通过控制权来提高用户的舒适度。 尽管 AR 广告现在还不足以吸引大多数用户，人们似乎更觉得这只是消费者的一种自我意淫。 但实际上幸运的是，现在它背后有一批最大的科技公司在支持和推动，这就让更多设计师有机会去创造更好的 AR 广告环境，更多品牌有空间去施放更大的营销活动。 Google、苹果、Facebook 这样的大平台仍然主导着 AR 领域及其营销的发展。这些科技公司还和零售商 组成了一个小组 ，为用于增强现实购物的 3D 图像创建一套通用标准。 ▲ Google 推出名为 Swirl 的沉浸式显示，消费者可以 360 度查看、旋转、放大、缩小商品 在这个背景之下，市场研究公司 Markets and Markets 的数据 预计，到明年 AR 将拥有 10 亿用户，到 2022 年将达到 22 亿美元的广告支出。 AR 广告进入我们的生活将会更加快速，而我们掌握的主动权也会越来越多，正如以色列最大的互联网公司 IronSource 首席设计官 Dan Greenberg 所认为的 ： 我们不断研究如何在广告中为用户提供尽可能多的选择的方法。因为给用户提供更多控制权，才是创建真正个性化移动体验的关键。

AR 会是下一个广告形态

数字广告总体上正朝着更丰富、更身临其境、更多选择的方向发展，消费者正在被置于互动体验的中心。 根据 Gartner 的估计 ，随着 5G 高速移动服务的推出，明年它将推动 AR 购物增长到 1 亿消费者。 ▲ 图片来自：unsplash 因为在高速运行的网络下，开发者不仅能够创造更高质量的 3D 可视化技术，消费者也能获得更多形式的沉浸式体验，品牌也能将其购物平台更多扩展到商店和传统网站之外的移动设备上，而且广告也不会再只限于移动设备的小屏幕。 还可以预见的是，5G 网络之下数据信息密度也会迅速加大，除了文本，还有图像、视频，人们接受的购物信息无疑更广、更深、更繁杂，而 AR 能够降低广告的感知成本，让人们消费数字内容将更简便和直观。 ▲ 图片来自：unsplash 但现在 AR 广告还未普及的主要问题，就在于它的成本和技术。 比起其他广告形式来说，其实它的投入成本并不低。Digiday 指出 单一的广告体验 可能需要花费 5,000 到 30,000 美元甚至更多才能正常开发，投资回报率也很难衡量。 而近阶段虽然 AR 技术发展很快，但 5G 手机还刚推出第一批，5G 网络也并未稳定普及，这也是影响 AR 广告现在扩大规模的关键因素——没有与之匹配的设备。另外，比起其它开发多年的其它形式的广告，AR 广告迭代和优化也还不太灵活，并非广告商们信手就可捏来。 ▲ 图片来自：unsplash AR 热潮刚刚开始真正起飞，我们现在看到的只是关于 AR 能带来什么以及它能做些什么的一瞥。不过苹果 2017 年推出 ARKit 时，首席执行官蒂姆・库克在 财报电话会议上就指出 AR 将成为「主流」： 虽然我们现在还只触及冰山一角，但它将永久改变我们使用技术的方式。 而这个未来正在靠近。Digi-Capital 预计在未来五年内 AR 广告的市场价值将达到 830 亿美元。而且下一代移动设备，还会为我们带来更多新的可能性。 折叠手机的柔性屏幕将能让 AR 广告拥有更多形式；内置投影仪的手机，能让 AR 广告用更大的位置呈现，当广告变成了一种看电影的方式，这对广告商也意味着有更多的空间来宣传。 ▲ 图片来自： satzuma 但无论何种新的形式，接下来，当我们沉迷于自己所选的 AR 广告体验中无法自拔，会不会更加停不下来「买买买」呢？ 我开始觉得这是一篇关于 AR 的沉浸式广告了。 原文：https://www.ifanr.com/1230440

阿里作为中国互联网企业的标杆，不仅一直在为广大人民群众提供快捷便利的服务。也不断引领行业，在各个专业领域，给专业人员提供了优质的工具与服务。对设计师而言，无论是每年一度的 UCAN大会，还是 Kitchen、语雀、Ant Design 等设计开发工具，都给广大设计师带来很大的便利。 而最近，阿里又推出了一款基于 Lottie 的动效设计平台 ── 犸良。能够快速生成设计师想要的动态效果，并交付给开发，极大地提高了设计效率和设计还原度。

犸良是什么？

它是一个积累了很多通用动效素材的平台，让不会动效的同学们也能基于动效库和素材库快速生成一个通用动效创意，你只需要简单地编辑图片、颜色或者文字即可。同时平台集成了以 Lottie 为代表的动效技术，让曾经令人苦恼的安装包大小和性能问题一并解决。 △ 官网： https://design.alipay.com/emotion

犸良的应用场景

犸良支持全平台 iOS、Android、H5、小程序。无论是营销展位、活动页面、空状态还是产品icon。犸良编辑器对接投放平台，一站式完成动效创意制作和投放。 丰富的动效素材能够满足多种场景需要。

犸良怎么用？

方式一：基于模版直接制作（适用于设计师进行动态banner制作）

1. 选择模版
2. 从动画仓库选择动画进行当前动画的替换
3. 通过替换图片或修改颜色来自定义动画
4. 自定义模板文字内容
5. 选择模板背景图片
6. 完成编辑选择是否带背景（banner模版默认带背景）
7. 导出成功下载 json

方式二：自定义画布制作（适用于设计师进行模板覆盖不到的动效应用场景）

使用犸良一分钟做出来的效果，大家感受下：

体验感受

综合体验了一下犸良，相对于鹿班人工智能随意撸图。猛良其实是一款基于人工的动效模板网站。所有的动态效果都是设计师提前做好的。基于 Lottie 的特性，将可编辑的属性进行模块化。 说到这里有些设计师可能有疑问了，Lottie 究竟是什么？在优设已经有相关文章介绍的比较全面了，这里就不赘述了，阅读链接： http://www.uisdc.com/tag/lottie/ 。 简言之 Lottie 就是一个快速将 AE 中设计的动效快速调出，并且开发可以直接调用的动效库。 Lottie 的原理是将矢量图形和动态效果通过代码实现，复杂的图形导出图片资源。最终生成 json 文件+图片资源。犸良所做的就是，将 json 里的颜色属性提取出来，用户可以从外部修改。同样只需要替换图片资源，就可以让用户自己设计的图形根据 json 写好的运动方式来展示。如果你把一只移动的猪替换成猫了，那么你看到的效果就是一只移动的猫。 而它的文字编辑功能，我觉得就比较神奇了。因为 Lottie 貌似不能从外部修改字体，应该是阿里自己写的。如果有知道的同学也欢迎解惑。因为我们在实际工作中经常遇到这样的问题，就是如果动效包含文本了，需要适配国际化，就没法从外部修改语言。如果能解决这个问题，将会减少很多麻烦。 从现有的素材来看，其主要应用场景还是电商和运营方面。相信未来会增加更多的素材和应用场景。希望以后能够开放出让设计师可以将自己做的动效分享出来供大家使用，或者提供优质付费内容也是不错的选择。 就个人的工作经验来看，Lottie 还是有丰富的应用场景的。比如可以做动态图标、动态闪屏页、表情贴纸、直播礼物、空白页、动态banner…… 其实 Lottie 官方社区也有很多的动效资源，都是来自全世界的设计师上传的，大家可以去下载参考，如果要商用，可能需要联系作者。 △ 附上链接： https://lottiefiles.com/popular 本文资料，很多都是来自语雀的分享。再次感谢相关人员的辛勤付出。大家可以在此处查看犸良的完整介绍： https://www.yuque.com/dapolloali/news/ui43vg 。 再次附上官网： https://design.alipay.com/emotion 因为犸良是基于 Lottie 的工具，所以有相关基础的设计师很容易上手。还不了解的同学也可以在各大设计网站搜索到。 欢迎关注作者的微信公众号：「懿凡设计」 本文原文：https://www.uisdc.com/alibaba-emotion

前几天，公众号「人工智能爱好者社区」的负责人书豪对我进行了一次采访，问了我一些问题，其中有些问题确实有深度，我在此一一进行了作答，这里将其记录下来。

当前觉得自己最不可替代性或最有优势的劳动价值在哪里？

有一种不断追求更优的心吧。 作为一名程序员，就拿写代码来说，比如做一个项目，我会把自己看作是负责人，以负责人的心态来做这件事情，自己主动有这份心去把这件事做好，而不是别人分配给我我做完就应付完事了。 在做项目过程中我会一直想着自己怎么实现是更优化的，如架构怎样设计扩展性更好，算法模块怎样效率更高，用户怎样使用会更方便。另外我一般会从多个角度来优化自己的项目，比如站在产品角度思考这么实现的用户体验，站在程序员角度思考更好的技术方案，站在设计角度思考布局交互。 此外就是感觉自己有点强迫症，如果某件事做不完，会一直在心里挂念着，直到把这件事完成。

觉得自己最牛逼的能力是什么？

不能说是牛逼的能力，因为我觉得我并没有什么牛逼的能力。我只能说有一些习惯或特性会对完成一件事情或达成一个目标更有帮助。 比如在学习的时候我会有做记录的习惯，学习的时候我会把我理解到的东西记录下来，然后学习完毕之后会把记录和理解的知识点归纳和总结一下，在这个过程中确实会需要对整个知识点进一步的思考，确实是非常有帮助的。 另外一个或许就是自控能力吧，我不敢说自己的自控能力是多么强，因为我自己确实也有时候是什么都不想做的。不过当自己一旦开始做一件事的时候，我会控制自己不去做的无关的事情，比如编写一个程序我可能一天到晚都会专注于这件事情，在没有完成的时候总觉得心里有件事没完成，于是乎就会继续干下去，可能熬个通宵也会想把它做完 ，这可以总结为一旦开始了就不容易停下。但自己也有个缺点，就是有时候就是觉得一件事麻烦不想开始做，不容易开始。所以我也在改正这个缺点。如果做事情的时候能够容易开始、持续专注，那就更好了。 另外就是上文提到的，自己有个追求完美的心。比如做一件事的时候会想追求完美和极致，一旦某处觉得不是很切合自己的想法，我会想办法把它变得更好一点。但我也不知道这样是不是好的，因为可能有些时候会把自己搞得比较累，但是事情的结果总归是相对好一点的。

工作以来，经历的困难是什么？如何面对的，是如何爬出这段艰难的处境的？

我正式工作只有三个月，不过工作之前已经在微软实习了一年多的时间了。 我自己有个特点就是不想给别人添麻烦，即使自己的事情压得太多，承担太多，也不想给别人添什么麻烦。所以很多时候我会把一些事情扛在自己身上，也不容易去拒绝一些事情，所以之前有时候我会同时并行着非常多的事情。 比如某个同学让我帮忙做点事情，我会答应并把它加到自己的待做清单里面；然后导师、领导又同时安排了一些事情；然后同事又让我帮忙做点事情。好，我基本都会答应然后去处理，即使真的自己压的喘不过气来了，也不想去再找另外的人帮忙或者推脱掉。直到有一天，我累得生病了，发了好几天烧也不舒服，很多事情也没有完成。 有一次我去找我当时在微软的宋老师交流的时候，她告诉我了一些方法。其实我这种做法是不对的，一些事情没有必要一定会去答应和接受，并把所有的责任都扛在自己身上，一些事情要学会拒绝，并去主动和别人确定好事情的重要程度、紧急程度，以及你真的有没有必要去帮某些人做某些事情。时间是自己的，要学会合理安排自己的时间，如果遇到新来的事情，要跟对方说清楚，比如我正在忙，你的事情我可能得晚几天才能帮你。另外遇到突发的情况或者实在让自己为难的事情，就多去跟对方商量，确定下事情的紧急程度、重要程度，然后再去合理分配自己的时间。后来我尝试做出了一些改变，一些事情不再无条件强加到自己身上，并会主动与对方沟通情况以把握好处理每件事情的时机，我的心态和生活规律也就慢慢地调整过来了。

你经历过的至暗时刻大致是什么样的，为什么说它是你的至暗时刻，主观能力和客观环境当时是什么样的？

每个人都会经历过很多挫折，并且会在经历挫折的时候由于当时的心智和世界观觉得那个挫折就是无法抵抗的“至暗时刻”，我大学时候被劈腿，高考失利，初中脑炎，甚至小学的时候摔断胳膊和食物中毒昏迷一周，都觉得那是在我能力范围内无法解决的事情了，但实际上我并没有把它们称为是”至暗时刻“。 我在遇到挫折的时候，我会想，两年之后或者十年之后，这个事情对我有没有影响。很多情况下是没有的，所以，它仅仅是我成长历程上的一个小坎，迈过去就好了。很多人在经历所谓“至暗时刻”的时候，总以为自己处在这个黑暗圆圈的最中央最无助最绝望的地方，但至暗时刻其实是一个圆环，你只需要从直径 8 走到直径 10 的地方就可以看到明天和未来，如果这么想的话，大多数的至暗时刻都不值一提了。

你印象中对你影响最深刻的人是哪一位，他给了你什么样的启发和力量？

我小时候其实成长条件还算不错的，父母几乎从来没有打过我骂过我，都是以鼓励的心态来培养我的，其实父母是对我影响最深刻的人，没有他们就没有我的现在。 不过除了父母以外就再提一位让我印象比较深刻的老师吧。之所以印象深刻可能就是因为他是惟一一位打过我的老师，因为人总是能对和平常状态反差强烈的事情印象最为深刻。 当时是高中上晚自习的时候，我没有好好写作业，而是拿着我的学习机在看游戏的图片，正好被老师抓到了，他把我拽出教室，狠狠地打了我的胸口两拳，当时他问过我一句话：“你知道什么是‘慎独’吗？”，我当时沉默了，他接着说：“‘慎独’就是谨慎独行，就是在别人没有监督你的时候，自己能够管住自己做正确的事情。” 从那以后，我便把这两个字一直记在心里，知道什么时候应该去做什么，当我向偷懒或者被某些事情诱惑的时候，我会尽力地控制自己。到现在为止，我个人觉得自己的自控力或专注力还算是比较强了。 真的非常感谢老师当年给我上的这一课。

技术成长最快的一段时间当时面对的是什么样的环境下，为什么说这段时间成长环境最快？

我认为不论是做什么，成长最快的时间基本上就是刚刚接触这个领域的时刻，成长的速度会慢慢地放缓。所以技术上来说，成长最快的时间可以说是我大学刚刚接触技术领域各个方向的时候了。 大学那会儿初步了解了一些编程理念之后，我加入了一个实验室，那会儿实验室分了很多方向，可以说是学校中技术方向最为全面的实验室了，包括前端、后台、安卓、iOS、美工、游戏等等，那会儿还有几个非常厉害的学长带着我们，带我们去学习和探索很多技术上的东西，那会儿就接触了 Git、Web 开发、移动开发、游戏开发，参加了非常多的比赛，做了一系列的外包，搭建自己的博客，分享自己的技术。总的来说学到了很多，真的特别感谢当时带我的几位学长，有了平台，有人带飞，的确是可以飞速成长的。

未来 3 到 5 年的打算是什么？打算如何突破这个打算，量化来说，困难程度有多大？需要的运气成分有多大？

现在我自己来看，我还是一个初出茅庐的小喽啰，不论是技术、金钱、人脉都还是比较薄弱的。我其中一个目标便是能够在生活上立稳脚跟，不为生活上的各种条件所困，娶到我的女朋友并一起过上富足快乐的日子。再长远的目标就是实现各种自由，如财务自由、时间自由。 要达成这个目标的确还是比较有挑战性的，我还需要非常的多的努力。当前初步的打算一定是努力工作，自己的主业上能够稳扎稳打，自己的主要工作必须要做好，从技术等各个层面上提升自己。另外其他的时间我会想办法累积自己的一些软实力，比如提升自己的知名度、积累自己的人脉等等。这个困难没法量化，也几乎不会靠什么运气成分，需要靠自己稳扎稳打地来一步步地做。

如果有天你失业了，会如何面对这个处境，当前的危机在哪里？

其实这个对于来说倒不怕，我本是技术出身，某个时代总是会有当前时代所最流行的技术的。如果但从技术方面看话，我可以不断地去学习和输出，即使是我四十多岁了，我一样可以做一个学习者，那会儿可能拼精力比不过，但那会儿构思能力、总结能力还是不会差的，至于知识的变现，方式就太多了。 但肯定不能仅靠这个来生存，多少还是有一定的压力的。其他的副业一定也是需要发展的，比如理财、投资、写作、服务等多种形式都可以成为经济的来源。所以我个人建议不要把所有的精力都完全压在主业上，推荐适当发展一下副业。

你拿到过最好的工作机会的这段经历自己是如何准备这个过程的？

我拿到的最好的工作机会就是我当前选择的微软了，这边工作氛围我非常喜欢，各种待遇都算不错。 由于我当时是在微软实习，所以最后是通过转正的途径来参加面试的。转正面试我非常非常重视，在工作的同时我提前准备了面试可能问的各个方面的问题。这边面试首先要求基本的算法能力是过关的，这是一个硬性要求，如果这都写不出来可能会被直接 Pass 的，所以当时一直在刷题、看数据结构、算法题等等，确保一些 LeetCode 上面简单和中等难度的题目都能比较稳地做出来。由于我面试的岗位对算法、工程能力都比较看重，所以那会儿还准备了很多机器学习算法、熟悉了相关的机器学习模型，比如逻辑回归、SVM、BP 算法的具体推导过程。对于工程方面这个可能真的要看平时的积累了，由于我之前做过很多的工程类项目，包括网络爬虫、前端开发、后端开发、框架搭建等等，所以简历上的项目还算比较说得过去，面试的时候聊一聊其中的一些理念和架构就好了。 当时面试真的特别重视，所以准备面试的过程也是非常焦虑，整个准备时间一个多月，所以当时可以算是焦虑了一个多月吧，当时也同时在忙公司和学校的项目，可以说压力是非常大的，不过好在取得了不错的结果，得知面试结果的一刻也是舒了一口气，感谢自己曾经的努力。

你觉得自己拥有什么样的缺点，这些缺点，是什么原因和经历造成的，未来的你，会选择什么样的行业和岗位进行跟进突击？

我觉得我个人有个缺点，就是挺多事情不是特别主动。这确实就是自己的性格导致的，我挺多事情并不想去麻烦别人，也不想去占用别人的时间，很多事情愿意靠自己的力量去探索去达成。 在我的成长历程上，挺多事情好像都是别人找到我，比如加好友、比如合作项目，基本都是别人找到我，然后我觉得 OK，就去答应然后做了，目前看来这并不是一件坏事，也对我的生活没有产生一些负面影响。 但是这样其实我无形中失去了一些可能我能力上能触及的更好的机会，比如结交更多朋友，合作更好的项目。所以，以后我也会去求变，去主动结实更优秀的人，去主动找寻更好的机会。 至于行业和岗位的话，我对我目前的行业和岗位是非常满意的，我在目前我的计划里面也会从事当前的行业和岗位的。

对于投资风险你有什么样的理解？你如何打理自己的资金？理财策略是什么？

投资会伴随着风险，这是毋庸置疑的，对于投资的回报，虽然说存在非常多的不可控因素，但风险的大小是可以通过一定的观察、计算、经验来的出来的。不同的投资和操作，其对结果的影响是不同的。 投资我通常和理财挂钩，因为广义上的大额的投资对我来说还是不现实的，目前的我是会在我现有的资金基础上进行适当的理财的。 我会把我的资产划分为四个部分。第一部分是危急时刻可以救命的，这部分是完全不能动的，就存起来，当自己危机的情况下可以取出来保证自己正常的生存的，量的大小的话就按照能满足自己正常生活一年的水平来存就好。第二部分是作为自己的固有资产来存的，比如为了自己将来买房子、车子来做准备用的，这部分基本上就是只增不减的，平时也不会动用这部分的资产。第三部分是满足自己日常花销和生活的，这部分基本上我就放在了支付宝和微信里面，平时买点东西或者正常开支来使用。最后一部分就是用来做理财的，由于我是一个相对比较保守型的，这部分占比不算多，我会拿这些钱去购买一些比较高风险高收益的基金等，观察某个情形出售，然后短期捞利收手再去出手下一个，当然赚的还不多，也有些情况下由于判断失误就亏了不少。不过这部分的盈亏我自己都是可以接受的，不会影响我的正常生活。 总的来说，我个人建议适当划分一下自己的资产及分配，然后在自己可承受的范围内适当去理财和投资。当然如果钱多的话当我什么都没有说哈。

庆才是个有感情经历的人，我想问你，对于男人寻找结婚伴侣或者找女朋友，你觉得最需要对方什么样的特质，有哪些变量是必须要的，有哪些变量是可以剔除的？

对于伴侣的选择，我个人觉得性格三观合得来、脾气好是非常重要的。因为性格和脾气基本上就是与生俱来的东西，这个是非常难改的。如果两个人性格上合不来，比如很多事情上处事态度不同、三观不一致，每次产生冲突的时候是会感觉非常累的，另外如果脾气上两个人都控制不好，事情可能会进一步变得艰难。 另外相貌其实也挺重要的，我不得不承认自己确实也是一个看脸的人，而且看得还蛮重的。这不仅仅是为了自己觉得开心和舒服，也有一部分会为后代考虑吧。 所以有一句名言说的好，相貌决定了你愿不愿意去了解一个人内心，而内心决定了你会不会一票否决这个人的样貌。

你的第一桶金是如何获得的，是自己，还是团队一起，这件事的主观能力方面当时的难度有多大，客观上，你创造了哪些条件达成它？

第一桶金如果不论大小的话，那就是大学时候和实验室的同学一起做外包赚到的，几千到上万不等，做过不少项目，具体记不太清了。 完成这些项目，大部分是技术上的突破，当时我更多是以技术开发的身份参与到其中的，由于当时对相关的技术栈还算比较了解，所以当时并没有觉得实现难度上有多大，不过当时也非常感谢实验室和学校能提供对接的平台，让我们的技术能力得以更好地发挥。

当下，你最担心什么，最害怕什么，为何会有这个恐惧，你会如何破局？

思来想去没想到有什么担心和害怕的，我目前对自己的生活还是比较喜欢的，另外我也对将来的生活充满信心。不过我现在并没有什么心思会考虑将来会出现什么让我担心和害怕的事，因为可能这些事情的出现都是不可预料到的吧。 所以，与其去担心这些事情，还不如着眼当下，去努力拼搏。

你觉得自己在商业能力上与技术能力上，哪个更有优势，为什么？

现在肯定还是技术能力上更有优势，因为自己目前的定位就是技术为主的工程师，我目前赖以生存的能力就是自己的技术。商业能力上，我并没有什么经验，人脉也不算广，当然这肯定也是我想扩展的一个方向之一。

平时工作中会用到哪些算法，在算法方面的能力你是如何突破的？

现在工作做的事情涉及的方向比较多，包括前端、后台、机器学习、图像处理、自然语言处理等技术，爬虫是我自己的附加职责了。 算法方面，自然语言处理方向涉及较多。由于我更加专注于产品和落地，所以会更偏向于使用一些实用和更有效率的算法，保证上线和实际使用的真实效果。另外对于一些前沿的模型，可能和大多数搞科研的同学一样，我也会去搜索当前前沿的论文来看，找找开源代码，然后尝试对接实现，不断迭代调整自己的算法。

你做过最成功最有成就感的一件事是什么？

应该就是写出来了一本爬虫相关的书籍，并帮助了很多人。 我研究爬虫时间不短了，当时图灵的王编辑找我约稿的时候我还是非常激动和欣喜的，当时正好也想借机把自己学过的爬虫知识系统地做一个梳理，写书的过程很辛苦，不过后来顺利出版了，现在销量也已经远超我的预期。 现在还有不少读者加我，说看了我的书收获很大，有的读者还是看了我的书顺利转行爬虫并找到了工作，听到这些消息，真的非常非常有成就感，希望我的书对读者有帮助。

你做股票投资亏损最严重的经历是什么样的，亏损的原因可否总结？

我没做过股票，只做过一些高风险高收益的基金投资，亏损倒不严重，都在我自己的可控范围之内。 亏损的一些原因可以稍微归结下，一个就是自己对市场的把握程度不够，有时候听别人说好，或者看着短期的势头不错就直接出手买了。另外就是自己平时工作忙，无暇分配那么多的时间来关注市场行情的变化，结果导致下次看到的时候，已经跌到没法看了。

你对于人性是什么样的看法，可以结合自己的工作经历或者投资经历谈谈。

人性这个东西非常复杂，这个看法就太宽泛了。 体会最深的一点就是，不要试图去改变一个人，很多都是天生的，难以更改的。改变可能仅仅发生在某些重大变化和突发情况下，或者从小的教育。所以，对于我们日常生活和工作来看，一个人三观不合，或者性格不合，还是不要去修正了，这太难了。所以，我的选择是对于这样的人，少去接触、少去交流、少去合作。不过好在我现在几乎没有碰到多少难以交流和合作的人，但一旦有，我还是会持有那样的态度的。毕竟让一个自己不认可的人来浪费自己的时间是非常亏的。

人生中有无数的风险，为规避人生的种种风险，你做了什么？

风险我主要就考虑两个方面了，一个是健康风险，一个是资金风险。 健康风险，对于我这一行，可能听得最多的就是程序员过劳猝死了。其实我也挺害怕的，有时候我也会熬夜，有时候工作强度也很大，有时候也会久坐不动。所以我会控制自己的时间，比如坐的时间长了就起来活动一下，注意波保护自己的颈椎腰椎等等，另外定期体检，看看自己身体有什么不良状况及时整治。佛祖保佑，我是不会猝死的好不好。 资金风险，这个是上文所提到的，主业技术方向，需要保持一个终身学习能力，靠自己的技术能力通过多种方式变现。另外也得注意发展一下副业，比如投资、理财、写作等等方向，并且要培养一个可以累积和增长的能力，比如写作，其水平就是慢慢累积的，而且是持续可增长的，这种就比较稳了。总之建议大家多个方向都去尝试一下，不要把鸡蛋放在同一个篮子里。

你是如何追到这么优秀的女朋友的？

关于这个问题我是比较困惑的啊，为什么一定是我追的不能是她追的我或者是互相喜欢呢？当然，事实上，确实算得上我“追”她，不过此追非彼追。我觉得很多人之所以觉得追女孩子困难，是因为大家追的不是这个女孩子跟自己脾气性格符合，而是追的漂亮，这样一来自然会容易觉得聊天总陷入死路，如果换个想法，只是寻找和自己脾气性格符合能够开心的在一起的（当然最好还能漂亮一点），在一起就非常顺其自然啦。所以我女朋友经常说我们之间不存在我追她或者她追我，因为两个人接触之后就觉得应该在一起啦~ 最后欢迎大家关注「崔庆才」的个人公众号「进击的 Coder」

本文转载自：陈文管的博客-微信公众号文章爬取之：微信自动化 本文内容详细介绍微信公众号历史文章自动化浏览脚本的实现，配合服务端对公众号文章数据爬取来实现微信公众号文章数据的采集。服务端爬取实现见：微信公众号文章爬取之：服务端数据采集。 背景：在团队的学习方面需要每周收集开发方面的博客文章，汇总输出每周的技术周报。周报小组成员收集的文章大多数是来自微信公众号，公众号的内容相对网页博客内容质量还是比较高的。既然数据的来源是确定的，收集汇总的流程是确定的，那么就把这个流程自动化，把人工成本降低到0。

一、方案选取

1、数据源选取

主要是爬取的数据来源选取，网上资料看的较多是爬取搜狗微信的内容，但是第三方平台（包括新榜、清博等 ）的公众号文章数据更新做不到实时，而且数据也不全，还要和各种反爬措施斗智斗勇，浪费时间精力的事情划不来。最直接的方式当然是直接爬取微信公众号历史文章里面的内容。 在前期预研主要参考的资料是知乎专栏：微信公众号内容的批量采集与应用 。 上面的方案是借助阿里巴巴开源的AnyProxy工具，AnyProxy作为一个中间人在微信客户端和服务器之间的交互过程中做数据截获和转发。获取到公众号文章的实际链接地址之后转发到自己的服务器进行保存，整个数据采集的自动化程度较大取决于微信客户端的自动化浏览实现。

2、自动化方案选取

如果是比较简单的安卓应用自动化操作的实现，一般直接使用AccessibilityService就行，UIAutomator也是基于AccessibilityService来实现的，但是AccessibilityService不支持WebView的操作，因为微信公众号历史文章页面是用WebView来加载的，要实现自动化必须同时支持安卓原生和WebView两个上下文环境的操作。 经过现有的几个自动化方案实现对比，最便利又具备极佳扩展性的方案就是使用Appium。

• Appium是开源的移动端自动化测试框架；
• 支持Native App、Hybird App、Web App；
• 支持Android、iOS、Firefox OS；
• 跨平台，可以在Mac，Windows以及Linux系统上；
• 用Appium自动化测试不需要重新编译App；
• 支持Java、python、ruby、C#、Objective C、PHP等主流语言;

更多资料参考：Android自动化测试框架

公众号文章爬取系统架构图

二、Appium安装配置（Mac）

Appium程序的安装，我这边不是使用brew命令安装的方式，直接从BitBucket下载Appium安装包，也可以从Github上下载。这边使用BitBucket 1.5.3版本。 Appium1.5.0之后的版本，需要在终端安装doctor，在终端输入命令：npm install -g appium-doctor，安装完毕之后，在终端输入命令：appium-doctor，查看所需的各个配置是否都已经安装配置完毕。下面是我这边在终端输出得到的结果：

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

info AppiumDoctor Appium Doctor v.1.4.3
info AppiumDoctor ### Diagnostic starting ###
info AppiumDoctor  ✔ The Node.js binary was found at: /Users/chenwenguan/.nvm/versions/node/v8.9.3/bin/node
info AppiumDoctor  ✔ Node version is 8.9.3
info AppiumDoctor  ✔ Xcode is installed at: /Library/Developer/CommandLineTools
info AppiumDoctor  ✔ Xcode Command Line Tools are installed.
info AppiumDoctor  ✔ DevToolsSecurity is enabled.
info AppiumDoctor  ✔ The Authorization DB is set up properly.
WARN AppiumDoctor  ✖ Carthage was NOT found!
info AppiumDoctor  ✔ HOME is set to: /Users/chenwenguan
WARN AppiumDoctor  ✖ ANDROID_HOME is NOT set!
WARN AppiumDoctor  ✖ JAVA_HOME is NOT set!
WARN AppiumDoctor  ✖ adb could not be found because ANDROID_HOME is NOT set!
WARN AppiumDoctor  ✖ android could not be found because ANDROID_HOME is NOT set!
WARN AppiumDoctor  ✖ emulator could not be found because ANDROID_HOME is NOT set!
WARN AppiumDoctor  ✖ Bin directory for $JAVA_HOME is not set
info AppiumDoctor ### Diagnostic completed, 7 fixes needed. ###
info AppiumDoctor 
info AppiumDoctor ### Manual Fixes Needed ###
info AppiumDoctor The configuration cannot be automatically fixed, please do the following first:
WARN AppiumDoctor - Please install Carthage. Visit https://github.com/Carthage/Carthage#installing-carthage for more information.
WARN AppiumDoctor - Manually configure ANDROID_HOME.
WARN AppiumDoctor - Manually configure JAVA_HOME.
WARN AppiumDoctor - Manually configure ANDROID_HOME and run appium-doctor again.
WARN AppiumDoctor - Add '$JAVA_HOME/bin' to your PATH environment
info AppiumDoctor ###
info AppiumDoctor 
info AppiumDoctor Bye! Run appium-doctor again when all manual fixes have been applied!
info AppiumDoctor

上面打叉的都是没配置好的，在终端输入命令安装Carthage ：brew install carthage

输入命令查看JDK安装路径：/usr/libexec/java_home -V

1
2

1.8.0_60, x86_64: "Java SE 8" /Library/Java/JavaVirtualMachines/jdk1.8.0_60.jdk/Contents/Home
/Library/Java/JavaVirtualMachines/jdk1.8.0_60.jdk/Contents/Home

需要把上面的路径配置到环境变量中，ANDROID_HOME就是Android SDK的安装路径。

输入命令打开配置文件： open ~/.bash_profile，在文件中添加如下内容：

1
2
3

export JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk1.8.0_60.jdk/Contents/Home  
export PATH=$JAVA_HOME/bin:$PATH  
export ANDROID_HOME=/Users/chenwenguan/Library/Android/sdk

输入命令让配置立即生效：source ~/.bash_profile

更多安装配置资料可参考：Mac上搭建Appium环境过程以及遇到的问题

TIPS

在首次使用Appium时可能会出现一个错误：

1

Could not detect Mac OS X Version from sw_vers output: '10.13.2

在终端输入命令：

1

grep -rl "Could not detect Mac OS X Version from sw_vers output" /Applications/Appium.app/

得到如下结果：

1
2
3
4

/Applications/Appium.app//Contents/Resources/node_modules/appium-support/lib/system.js
/Applications/Appium.app//Contents/Resources/node_modules/appium-support/build/lib/system.js
/Applications/Appium.app//Contents/Resources/node_modules/appium/node_modules/appium-support/lib/system.js
/Applications/Appium.app//Contents/Resources/node_modules/appium/node_modules/appium-support/build/lib/system.js

打开上面四个路径下的文件，添加当前的Appium版本参数，具体内容可参考：在Mac OS 10.12 上安装配置appium

三、具体代码实现

预研资料主要参考这篇博文：Appium 微信 webview 的自动化技术 自动化实现的原理就是通过ID或者模糊匹配找到相应的控件，之后对这个控件做点击、滑动等操作。如果要对微信WebView做自动化，必须能够获取到WebView里面的对象，如果是Android原生的控件可以通过AndroidStudio里面的Android Device Monitor来查看控件的id、类名等各种属性。

1、Android原生控件属性参数值的获取

在AndroidStudio打开Monitor工具：Tools->Android->Android Device Monitor 按照下图的步骤查看控件的ID等属性，后续在代码实现中会用到。

Android Device Monitor

2、WebView属性参数值的获取

如果是在安卓真机上，需要打开WebView的调试模式才能读取到WebView的各个属性，在微信里面可以在任意聊天窗口输入debugx5.qq.com，这是微信x5内核调试页面，在信息模块中勾选打开TBS内核Inspector调试功能。

微信X5内核调试页面

之后还要在真机上安装Chrome浏览器，如果是在虚拟机上无需做此操作。 接下来在Chrome浏览器中输入：chrome://inspect ，我这边使用的是虚拟机，真机上也一样，进入到公众号历史文章页面，这边就会显示相应可检视的WebView页面，点击inspect，进入到Developer Tools页面。

chrome inspect页面

如果进入到Developer Tools页面显示一片空白，是因为chrome inspect需要加载 https://chrome-devtools-frontend.appspot.com 上的资源，所以需要翻墙，把appstop.com 加入翻墙代理白名单，或者直接全局应用翻墙VPN，具体可参考：使用chrome remote debug时打开inspect时出现一片空白 下面是美团技术团队历史文章列表的详细结构信息，具体的文章列表项在weui-panel->weui-panel__bd appmsg_history_container->js_profile_history_container->weui_msg_card_list路径下。

Chrome inspect查看WebView详细内容

继续展开节点查看文章详细结构信息，这边可以看到每篇文章的ID都是以“WXAPPMSG100″开头的，类名都是“weui_media_box”开头，一开始的实现是通过模糊匹配ID来查找历史文章列表项数据，但在测试过程中出现来一个异常，后来发现，如果是纯文本类型的文章，也就是只有一段话的文章，它是没有ID的，所以不能通过ID来模糊匹配。

公众号历史文章列表项详细结构

之后就把现有的四种公众号文章类型都找来出来，找它们的共性，虽然ID不一定有，但是class类型值一定有，四种类型值如下，这样就可以通过class类型值来匹配查找数据了。

1
2
3
4

 * weui_media_box appmsg js_appmsg : 文章
 * weui_media_box text js_appmsg : 文本
 * weui_media_box img js_appmsg : 图片
* weui_media_box appmsg audio_msg_primary js_appmsg playing : 语音

3、具体代码实现

整体自动化是按照如下顺序：通讯录页面->点击公众号进入公众号列表页面->公众号列表项选择一个点击->公众号页面->公众号消息页面->点击“全部消息”进入公众号历史文章页面->根据设置的时间类型（一周之内、一个月之内、一年之内或者全部）逐个点击历史文章列表项，完毕之后返回公众号列表页面，继续下一个公众号浏览的操作；

1）初始化

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

private static AndroidDriver getDriver() throws MalformedURLException {
        DesiredCapabilities capability = new DesiredCapabilities();
         capability.setCapability("platformName", "emulator-5554");
         capability.setCapability("platformVersion", "4.4.4");
         capability.setCapability("deviceName", "MuMu");
         /**
          * 真机上platformName使用"Android"
          */
         /*
         capability.setCapability("platformName", "Android");
         capability.setCapability("platformVersion", "6.0");
         capability.setCapability("deviceName", "FRD-AL00");
         */
         capability.setCapability("unicodeKeyboard","True");
         capability.setCapability("resetKeyboard","True");
         capability.setCapability("app", "");
         capability.setCapability("appPackage", "com.tencent.mm");
         capability.setCapability("appActivity", ".ui.LauncherUI");
         capability.setCapability("fastReset", false);
         capability.setCapability("fullReset", false);
         capability.setCapability("noReset", true);
         capability.setCapability("newCommandTimeout", 2000);
         /**
          * 必须加这句，否则webView和native来回切换会有问题
          */
         capability.setCapability("recreateChromeDriverSessions", true);
         /**
          * 关键是加上这段
          */
         ChromeOptions options = new ChromeOptions();
         options.setExperimentalOption("androidProcess", "com.tencent.mm:tools");
         capability.setCapability(ChromeOptions.CAPABILITY, options);
         String url = "http://127.0.0.1:4723/wd/hub";
         mDriver = new AndroidDriver<>(new URL(url), capability);
         return mDriver;
     }

如果是虚拟机则platformName使用具体的虚拟机名称，如果是真机使用“Android”，platformVersion和deviceName可以使用工程安装APK之后查看详细信息，对应的参数就是显示的系统版本和设备名称。

设备信息

URL参数是在Appium里面设置的，确保”http://127.0.0.1:4723/wd/hub”字符串中的服务器地址和端口与Appium设置一致。

Appium URL参数设置

2）列表滑动和元素获取

不管是WebView还是Android原生ListView的滑动都需要在Android原生上下文环境下操作driver.context(“NATIVE_APP”); 滑动操作都可以通过如下代码实现，通过滑动前后的PageSource对比可以知道列表是否已经滑动到底部。

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

     /**
      * 滑动列表加载下一页数据
      *
      * @param driver
      * @return
      * @throws InterruptedException
      */
     private static boolean isScrollToBottom(AndroidDriver driver) throws InterruptedException {
         int width = driver.manage().window().getSize().width;
         int height = driver.manage().window().getSize().height;
         String beforeswipe = driver.getPageSource();
         driver.swipe(width / 2, height * 3 / 4, width / 2, height / 4, 1000);
         /**
          * 设置8s超时，网络较差情况下时间过短加载不出内容
          */
         mDriver.manage().timeouts().implicitlyWait(8000, TimeUnit.MILLISECONDS);
         String afterswipe = driver.getPageSource();
         /**
          * 已经到底部
          */
         if (beforeswipe.equals(afterswipe)) {
             return true;
         }
         return false;
     }

TIPS： 如果是Android原生的ListView读取到的数据是在屏幕上显示的数据，超过屏幕的数据是获取不到的，如果是WebView的列表获取的数据是所有已加载的数据，不管是否在屏幕显示范围内。 获取公众号列表数据逻辑代码如下，”com.tencent.mm:id/a0y”是具体的公众号名称TextView的ID。

1

List<WebElement> elementList = mDriver.findElementsById("com.tencent.mm:id/a0y");

获取历史文章列表数据逻辑代码如下，div是节点，上面说到公众号四种类型的文章都是以’weui_media_box’类名开头的，通过模糊匹配class类名以’weui_media_box’开始的元素来过滤出所有的公众号文章列表项。

1

List<WebElement> msgHistory = driver.findElements(By.xpath("//div[starts-with(@class,'weui_media_box')]"));

3）元素定位方式

如果一定需要模糊匹配就使用By.xpath()的方式，因为Android APK应用如果有增加或减少了布局字符串资源或者控件，编译之后生成的ID可能会不一样，这边说的ID是指通过Android Device Monitor查看的布局ID，不是实际的布局代码控件id，布局控件id除非命名改动，否则不会变化。所以不同版本的微信客户端生成的ID很可能会不一样，如果要批量实现自动化最好使用模糊匹配的方式，但By.xpath()方式查找定位元素是遍历页面的所有元素，会比较耗时，也容易出现异常。 在测试过程中执行

1

driver.findElement(By.xpath("//android.widget.ImageView[@content-desc='返回']")).click();

时候经常出现如下错误，改为

1

driver.findElementById("com.tencent.mm:id/ht").click();

异常消失，猜测原因就是因为By.xpath()方法查找比较耗时导致。

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