【爬虫小白】异步爬虫原理和解析

event_loop：事件循环，相当于一个无限循环，可以把一些函数注册到这个事件循环上，当满足条件发生的时候，就会调用对应的处理方法。
coroutine：中文翻译叫做协程，在Python中常指代为协程对象类型，可以将协程对象注册到时间循环中，他会被事件循环调用。我们可以使用async关键字来定义一个方法，这个方法在调用时不会立即执行，而是返回一个协程对象。
task：任务，它是对协程对象的进一步封装。包含了任务的各个状态。
future：代表将来执行或没有执行的任务的结果，实际上和task没有本质区别。

另，需要了解async/await关键字，它是从Python3.5才出现的，专门用于定义协程。其中，async定义一个协程，await用来挂起阻塞方法的执行。

定义协程

定义一个协程，体验一下它和普通进程在实现上的不同之处，

【示例一】如下：（此处重点说明一下，event_loop(事件循环)和coroutine)

import anyncio  #声明引用asyncio
asyncio def execute(x):
    print('Number:',x)

coroutine=execute(1)
print('Coroutine:',coroutine)  #此处返回的是coroutine协程对象，

loop=asyncio.get_event_loop()  #使用get_event_loop创建一个事件循环loop

loop.run_until_complete(coroutine) #调用loop对象run_until_complete方法将协程注册到事件循环loop中，然后启动。这样我们就可以看到execute方法打印输出的结果。

注：以上代码其实可以看出，async定义的方法就会变成一个无法直接执行的coroutine对象，必须将其注册到事件循环中才能执行。

【示例二】如下：(此处重点说明task，）

‘’‘
以下代码，提到task，它是对coroutine对象的进一步封装，
task里面比coroutine对象多了运行状态，
例如：
running，finished等
我们可以通过这些状态来获取协程对象的执行情况
’‘’
import asyncio

async def execute(x)
    print('Number:',x)
    return x

coroutine =execute(1)  #返回coroutine协程对象

#-------------------定义task的方法一--------------------------

loop=asyncio.get_evet_loop()  #定一个循环事件。

task =loop.create_task(coroutine) #这里是调用create_task方法将coroutine对象转化成task对象，
print('Task:',task)  #这里打印输出，返回返现它是pending状态。
loop.run_until_complete(task)  #我们将task对象，添加到事件循环中得到执行
print('Task:',task)   #我们这次打印，发现他的状态变成finished，同时看到其result变成1，也就我们定义的execute方法返回的结果。

#------------------定义task的方法二--------------------------
‘’‘
    此方法，定义task对象，可以直接通过asyncio的ensure_future方法 
    就可以不借助loop来定义，即使没有声明loop也可以提前定义好task对象
’‘’
task =asyncio.ensure_future(coroutine)
print('Task:',task)

loop =asyncio.get_event_loop()  #定一个循环事件。
loop.run_until_complete(task)
print('Task:',task)

当大家运行后，看到返回结果，发现其运行效果都是一样的。

绑定回调

另外我们可以为某个task绑定一个回调方法。

【示例】如下：

import asyncio
import requests

async def execute(url):
    req = requests.get(url)
    return req

def callback(response): #回调方法
    print(response.result().status_code)


coroutine = execute('https://www.baidu.com')
task = asyncio.ensure_future(coroutine)
task.add_done_callback(callback)

loop = asyncio.get_event_loop()
loop.run_until_complete(task)

上述代码，我们定义了一个request方法，请求一个百度，获取其状态码，这个方法里面我们没有任何print语句。

随后定义一个callback方法，这个方法接收一个参数，是response对象，这样我们就定义好一个coroutine对象和回调方法，我们现在希望的效果是，当coroutine对象执行完毕之后，就去执行声明的callback方法。

那么二者怎么关联起来？很简单只需要调用add_done_callback方法即可，我们将callback方法传递给封装好的task对象，这样当task执行完毕之后就可以调用callback方法了，同时task对象还会作为参数传递callback方法，调用task对象的result方法就可以获取返回结果。

注：我们也可以不使用回调方法，直接在task运行完毕后可以直接调用result方法获取结果

【示例】如下

import asyncio
import requests


async def execute(url):
    req = requests.get(url)
    return req

coroutine = execute('https://www.baidu.com')
task = asyncio.ensure_future(coroutine)

loop = asyncio.get_event_loop()
loop.run_until_complete(task)
print(task.result().status_code)

以上示例，运行的结果是一样的。

多任务协程

上面的例子，我们只执行一次请求，如果我们想执行多次请求应该怎么办呢？我们可以定义一个task列表，然后使用asyncio的wait方法即可执行。

【示例】如下：

import asyncio
import requests


async def execute(url='https://www.baidu.com'):
    req = requests.get(url)
    return req
coroutine = execute

tasks = [asyncio.ensure_future(coroutine()) for _ in range(1,5)]

loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))
for i in tasks:
    print('任务：',i.get_name(),'。状态：',i.result())

这里我们用for循环创建了五个task，组成一个列表，然后把这个列表首先传递给了asyncio的wait()方法，然后在将其注册到时间循环中，就可以发起五个任务了。最后我们再将任务的运行结果输出就可以了。

协程实现

上面的代码中，我们可以用一个网络请求作为示例，这就是一个耗时等待的操作，因为我们请求网页之后，需要等待页面响应并返回结果，耗时等待的操作一般都是IO操作，比如文件读取、网络请求等等。协程对于处理这种操作是有很大优势的，当遇到需要等待的情况的时候，程序可以暂时挂起，转而去执行其它操作，从而避免一直等待一个程序而耗费过多的时间，充分利用资源。

按照多任务协程上述代码里面，在执行过程中，其实是和正常请求并没有什么两样，依然是按照顺序执行的。

其实，要实现异步处理，我们先要有挂起的操作，当一个任务需要等待IO结果的时候，可以挂起当前任务，转而去执行其它任务，这样我们才能充分利用好资源。

要实现异步，接下来我们需要了解一下，await的用法，使用await可以将耗时等待的操作挂起，让出控制权，当协程执行的时候遇到await，时间循环就会将本协程挂起，转而去执行别的协程，直到其它的协程挂起或执行完毕。

#把//多任务协程下的代码里函数excute//修改程一下内容。
async def execute(url='https://www.baidu.com'):
    print('Waiting for ',url)
    req = await requests.get(url)
    print('Get response from',url ,'response',req)

如果仅仅在requests前面加一个await，然而执行一下代码，会得到如下报错：

TypeError: object Response can't be used in 'await' expression

这次它遇到await方法确实挂起了，也等待了，但是最后却报这个错，这个错误的意思是requests返回的Response对象不能和await一起使用，这是为什么呢？因为根据官方文档说明，await后面格式必须如下格式之一：

A native coroutine object returned from a native coroutine function，一个原生 coroutine 对象。
A generator-based coroutine object returned from a function decorated with types.coroutine，一个由 types.coroutine 修饰的生成器，这个生成器可以返回 coroutine 对象。
An object with an __await__ method returning an iterator，一个包含 __await__ 方法的对象返回的一个迭代器。

requests返回的Response不符合上面任一条件，因此就会报上面的错。

既然await后面可以跟一个coroutine对象，那么我用async把请求的方法改成coroutine对象不就可以了吗？所以改成如下的样子：

import asyncio, requests,time

start=time.time()

async def get(url):
    req = requests.get(url)
    return req.status_code

async def execute():
    url = 'https://www.baidu.com'
    print('Waiting for ', url)
    response = await get(url)
    print(response)
    print('Get response from ', url, 'response', response)

tasks = [asyncio.ensure_future(execute()) for _ in range(10)]
loop =asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))
end=time.time()
print('Cost time:',end-start)

这里我们将请求的页面的方法独立出来，并用async修饰，这样就得到一个coroutine对象。

//返回太多，需要的话自己运行看下。

从运行返回的内容，可以发现，还不是我们所需要的异步执行，也就是说，我们仅仅将涉及IO操作的代码封装到async修饰的方法里面是不可行的，我们必须要使用支持异步操作的请求方式才可以实现正在的异步，所以这里就需要aiohttp派上用场了。

使用aiohttp

aiohttp是一个支持异步请求的库，利用它和asyncio配合我们可以非常方便地实现异步请求操作。

安装如下：

pip install aiohttp

官方文档链接为：https://aiohttp.readthedocs.io/，它分为两部分，一部分是：Client，一部分是：Server，详细的内容可以参考官方文档。

下面将aiohttp用上，将代码改成如下：

import asyncio
import aiohttp
import time

start = time.time()

async def get(url):
    session = aiohttp.ClientSession()
    response = await session.get(url)
    await response.text()
    await session.close()
    return response

async def request():
    url = 'https://www.baidu.com'
    print('Waiting for ', url)
    response = await get(url)
    print('Get response from ', url, 'response', response)

tasks = [asyncio.ensure_future(request()) for _ in range(10)]
loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))
end = time.time()
print('Cost time:', end - start)

在这里，我们将请求库有requests改成aiohttp，通过aiohttp的ClientSession类的get方法进行请求。

//上面的代码，大家自己运行，就能看到效果了。。😃😃😃

**代码里面我们使用了await，后面跟了get方法，在执行这10个协程的时候，如果遇到await，那么就会将当前协程挂起，转而去执行其它的协程，知道其它协程也挂起或执行完毕，再进行下一个协程的执行。

**运行时，时间循环会运行第一个task，针对第一个task来说，当执行到第一个await跟着的get方法时，它被挂起，但这个get方法第一步的执行是费阻塞的，挂起之后立马被唤醒，所以立即又进入执行，创建了ClientSession对象，接着遇到第二个await，调用session.get请求方法，然后就被挂起，由于请求需要耗时很久，所以一直没有被唤醒。

**当第一个task被挂起，那么事件循环会寻找当前未被挂起的协程继续执行，于是就转而执行第二个task了，于是一样的流程操作，直到执行了第十个task的session.get方法后。所有task都处于挂起状态，那么只能等待，5秒后，几个请求同时都有了响应，然后几个task也被唤醒接着执行，输出请求结果。

**这就是异步操作的便捷之处，当遇到阻塞式操作时，任务被挂起，程序接着去执行其它的任务，而不是傻傻地等待，这就就可以充分利用CPU时间，而不必把时间浪费在等待IO上。

***另外需要注意，那就服务器在同一时刻接受无限请求都能保证正常返回结果，也就是服务器无限抗压，另外还要忽略IO传输时延，确实可以做到无限task一起执行且在预想时间内得到结果，但由于不同服务器处理的实现机制不同，可能某些服务器并不能承受这么高的并发，因此响应速度也会变慢。

import aiohttp
import asyncio
import time

def test(number):
    start = time.time()

    async def get(url):
        session = aiohttp.ClientSession()
        response = await session.get(url)
        await response.text()
        await session.close()
        return response

    async def request():
        url = 'https://www.baidu.com/'
        await get(url)

    tasks = [asyncio.ensure_future(request()) for _ in range(number)]
    loop = asyncio.get_event_loop()
    loop.run_until_complete(asyncio.wait(tasks))
    end = time.time()
    print('Number:', number, 'Cost time', end - start)


for number in [1, 3, 5, 10, 15, 30, 50, 75, 100, 200, 500]:
    test(number)

【返回】

Number: 1 Cost time 0.11472892761230469
Number: 3 Cost time 0.10772204399108887
Number: 5 Cost time 0.10681009292602539
Number: 10 Cost time 0.11580681800842285
Number: 15 Cost time 0.1703197956085205
Number: 30 Cost time 0.38277196884155273
Number: 50 Cost time 0.3503608703613281
Number: 75 Cost time 0.40204310417175293
Number: 100 Cost time 1.3165500164031982
Number: 200 Cost time 1.3197250366210938
Number: 500 Cost time 2.0203850269317627

可以看到，即使我们增加了并发数，但在服务器能承受高并发的前提下，其爬取速度不会太受影响。

【注意】

如果在有关aiohttp代码，在运行时如果提示报错。在声明session的时候，修改成这样：
session = aiohttp.ClientSession(connector=aiohttp.TCPConnector(limit=64,verify_ssl=False))

__淡墨青衫__

关注

1
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
【爬虫小白】异步爬虫原理和解析

异步基础概念在了解异步协程之前，先得了解一些基础概念，如堵塞和非堵塞、同步和异步、多进程和协程。阻塞阻塞状态指程序未得到所需计算资源被挂起的状态。程序在等待某个操作完成期间，自身无法继续处理其它的事情，则称该程序在该操作上是阻塞的。常见的阻塞形式有：网络I/O阻塞、磁盘I/O阻塞、用户输入阻塞等。阻塞是无处不在的，包括CPU切换上下文时，所有的进程都无法真正处理事情，它们也会被阻塞。如果是多核CPU则正在执行上下文切换操作的核不可被利用。非阻塞程序在等待某操作过程中，自身不被阻塞，可
复制链接

扫一扫