Python 异步网络爬虫 I

本文主要讨论下面几个问题：

• 什么是异步（Asynchronous）编程？
• 为何要使用异步编程？
• 在 Python 中有哪些实现异步编程的方法？
• Python 3.5 如何使用 async/await 实现异步网络爬虫？

所谓异步是相对于同步（Synchronous）的概念来讲的，之因此容易形成混乱，是由于刚开始接触这两个概念时容易把同步看作是同时，而同时不是意味着并行（Parallel）吗？然而实际上同步或者异步是针对于时间轴的概念，同步意味着顺序、统一的时间轴，而异步则意味着乱序、效率优先的时间轴。好比在爬虫运行时，先抓取 A 页面，而后从中提取下一层页面 B 的连接，此时的爬虫程序的运行只能是同步的，B 页面只能等到 A 页面处理完成以后才能抓取；然而对于独立的两个页面 A1 和 A2，在处理 A1 网络请求的时间里，与其让 CPU 空闲而 A2 等在后面，不如先处理 A2，等到谁先完成网络请求谁就先来进行处理，这样能够更加充分地利用 CPU，可是 A1 和 A2 的执行顺序则是不肯定的，也就是异步的。

很显然，在某些状况下采用异步编程能够提升程序运行效率，减小没必要要的等待时间，而之因此可以作到这一点，是由于计算机的 CPU 与其它设备是独立运做的，同时 CPU 的运行效率远高于其余设备的读写（I/O）效率。为了利用异步编程的优点，人们想出了不少方法来从新安排、调度（Schedule）程序的运行顺序，从而最大化 CPU 的使用率，其中包括进程、线程、协程等（具体可参考《Python 中的进程、线程、协程、同步、异步、回调》）。在 Python 3.5 之前经过 @types.coroutine 做为修饰器的方式将一个生成器（Generator）转化为一个协程，而在 Python 3.5 中则经过关键词 async/await 来定义一个协程，同时也将 asyncio 归入为标准库，用于实现基于协程的异步编程。

要使用 asyncio 须要理解下面几个概念：

• Event loop
• Coroutine
• Future & Task

Event loop

了解 JavaScript 或 Node.js 确定对事件循环不陌生，咱们能够把它看做是一种循环式（loop）的调度机制，它能够安排须要 CPU 执行的操做优先执行，而会被 I/O 阻塞的行为则进入等待队列：

asyncio 自带了事件循环：

import asyncio

loop = anscio.get_event_loop()
# loop.run_until_complete(coro())
loop.close()复制代码

固然你也能够选择其它的实现形式，例如 Sanic 框架采用的 uvloop，用起来也很是简单（ 至于性能上是否更优我没有验证过，但至少在 Jupyter Notebook 上 uvloop 用起来更方便）：

import asyncio
import uvloop

loop = uvloop.new_event_loop()
asyncio.set_event_loop(loop)复制代码

Coroutine

Python 3.5 之后推荐使用 async/await 关键词来定义协程，它具备以下特性：

• 经过 await 将可能阻塞的行为挂起，直到有结果以后继续执行，Event loop 也是据此来对多个协程的执行进行调度的；
• 协程并不像通常的函数同样，经过 coro() 进行调用并不会执行它，而只有将它放入 Event loop 进行调度才能执行。

一个简单的例子：

import uvloop
import asyncio

loop = uvloop.new_event_loop()
asyncio.set_event_loop(loop)

async def compute(a, b):
    print("Computing {} + {}...".format(a, b))
    await asyncio.sleep(a+b)
    return a + b
tasks = []
for i, j in zip(range(3), range(3)):
    print(i, j)
    tasks.append(compute(i, j))
loop.run_until_complete(asyncio.gather(*tasks))
loop.close()

### OUTPUT
""" 0 0 1 1 2 2 Computing 0 + 0... Computing 1 + 1... Computing 2 + 2... CPU times: user 1.05 ms, sys: 1.21 ms, total: 2.26 ms Wall time: 4 s """复制代码

因为咱们没办法知道协程将在何时调用及返回，asyncio 中提供了 Future 这一对象来追踪它的执行结果。

Future & Task

Future 至关于 JavaScript 中的 Promise，用于保存将来可能返回的结果。而 Task 则是 Future 的子类，与 Future 不一样的是它包含了一个将要执行的协程（ 从而组成一个须要被调度的任务）。还以上面的程序为例，若是想要知道计算结果，能够经过 asyncio.ensure_future() 方法将协程包裹成 Task，最后再来读取结果：

import uvloop
import asyncio

loop = uvloop.new_event_loop()
asyncio.set_event_loop(loop)

async def compute(a, b):
    print("Computing {} + {}...".format(a, b))
    await asyncio.sleep(a+b)
    return a + b
tasks = []
for i, j in zip(range(3), range(3)):
    print(i, j)
    tasks.append(asyncio.ensure_future(compute(i, j)))
loop.run_until_complete(asyncio.gather(*tasks))
for t in tasks:
    print(t.result())
loop.close()

### OUTPUT
""" 0 0 1 1 2 2 Computing 0 + 0... Computing 1 + 1... Computing 2 + 2... 0 2 4 CPU times: user 1.62 ms, sys: 1.86 ms, total: 3.49 ms Wall time: 4.01 s """复制代码

异步网络请求

Python 处理网络请求最好用的库就是 requests（应该没有之一），但因为它的请求过程是同步阻塞的，所以只好选用 aiohttp。为了对比同步与异步状况下的差别，先伪造一个假的异步处理服务器：

from sanic import Sanic
from sanic.response import text
import asyncio
app = Sanic(__name__)

@app.route("/<word>")
@app.route("/")
async def index(req, word=""):
    t = len(word) / 10
    await asyncio.sleep(t)
    return text("It costs {}s to process `{}`!".format(t, word))
app.run()复制代码

服务器处理耗时与请求参数（word）长度成正比，采用同步请求方式，运行结果以下：

import requests as req

URL = "http://127.0.0.1:8000/{}"
words = ["Hello", "Python", "Fans", "!"]

for word in words:
    resp = req.get(URL.format(word))
    print(resp.text)

### OUTPUT
""" It costs 0.5s to process `Hello`! It costs 0.6s to process `Python`! It costs 0.4s to process `Fans`! It costs 0.1s to process `!`! CPU times: user 18.5 ms, sys: 2.98 ms, total: 21.4 ms Wall time: 1.64 s """复制代码

采用异步请求，运行结果以下：

import asyncio
import aiohttp
import uvloop

URL = "http://127.0.0.1:8000/{}"
words = ["Hello", "Python", "Fans", "!"]

async def getPage(session, word):
    with aiohttp.Timeout(10):
        async with session.get(URL.format(word)) as resp:
            print(await resp.text())

loop = uvloop.new_event_loop()
asyncio.set_event_loop(loop)
session = aiohttp.ClientSession(loop=loop)

tasks = []
for word in words:
    tasks.append(getPage(session, word))

loop.run_until_complete(asyncio.gather(*tasks))

loop.close()
session.close()

### OUTPUT
""" It costs 0.1s to process `!`! It costs 0.4s to process `Fans`! It costs 0.5s to process `Hello`! It costs 0.6s to process `Python`! CPU times: user 61.2 ms, sys: 18.2 ms, total: 79.3 ms Wall time: 732 ms """复制代码

从运行时间上来看效果是很明显的。

未完待续

接下来将对 aiohttp 进行简单封装，更有利于假装成普通浏览器用户访问，从而服务于爬虫发送网络请求。

【阅读原文】

参考

1. Python 中的进程、线程、协程、同步、异步、回调
2. Asyncio Document
3. aiohttp - HTTP Client