1. 首页
  2. 文章中心
  3. 爬虫

python爬虫进阶|异步协程前言一、基本概念二、异步协程

54 阅读 0 评论
我是靠谱客的博主 安静曲奇，这篇文章主要介绍python爬虫进阶|异步协程前言一、基本概念二、异步协程，现在分享给大家，希望可以做个参考。

python爬虫进阶 | 异步协程

  • 前言
  • 一、基本概念
  • 二、异步协程

前言

python

之前爬虫使用的是requests+多线程/多进程，后来随着前几天的深入了解，才发现，对于爬虫来说，真正的瓶颈并不是CPU的处理速度，而是对于网页抓取时候的往返时间，因为如果采用requests+多线程/多进程，他本身是阻塞式的编程，所以时间都花费在了等待网页结果的返回和对爬取到的数据的写入上面。而如果采用非阻塞编程，那么就没有这个困扰。这边首先要理解一下阻塞和非阻塞的区别。

  1. 阻塞调用是指调用结果返回之前，当前线程会被挂起（线程进入非可执行状态，在这个状态下，CPU不会给线程分配时间片，即线程暂停运行）。函数只有在得到结果之后才会返回。
  2. 对于非阻塞则不会挂起，直接执行接下去的程序，返回结果后再回来处理返回值。

其实爬虫的本质就是client发请求，批量获取server的响应数据，如果我们有多个url待爬取，只用一个线程且采用串行的方式执行，那只能等待爬取一个结束后才能继续下一个，效率会非常低。需要强调的是：对于单线程下串行N个任务，并不完全等同于低效，如果这N个任务都是纯计算的任务，那么该线程对cpu的利用率仍然会很高，之所以单线程下串行多个爬虫任务低效，是因为爬虫任务是明显的IO密集型（阻塞）程序。那么该如何提高爬取性能呢？

一、基本概念

协程，英文叫做 Coroutine，又称微线程，纤程，协程是一种用户态的轻量级线程。

协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈。因此协程能保留上一次调用时的状态，即所有局部状态的一个特定组合，每次过程重入时，就相当于进入上一次调用的状态。

协程本质上是个单进程，协程相对于多进程来说，无需线程上下文切换的开销，无需原子操作锁定及同步的开销，编程模型也非常简单。

我们可以使用协程来实现异步操作，比如在网络爬虫场景下，我们发出一个请求之后，需要等待一定的时间才能得到响应，但其实在这个等待过程中，程序可以干许多其他的事情，等到响应得到之后才切换回来继续处理，这样可以充分利用 CPU 和其他资源，这就是异步协程的优势。

二、异步协程

在python3.4之后新增了asyncio模块，可以帮我们检测IO，实现应用程序级别的切换（异步IO）。注意：asyncio只能发tcp级别的请求，不能发http协议。

asyncio 是干什么的？

  1. 异步网络操作
  2. 并发
  3. 协程

几个概念：

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

1.定义一个协程：

import asyncio

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


coroutine = execute(1)
print('Coroutine:', coroutine)
print('After calling execute')

loop = asyncio.get_event_loop()
loop.run_until_complete(coroutine)
print('After calling loop')

#输出结果
Coroutine: <coroutine object execute at 0x1034cf830>

After calling execute

Number: 1

After calling loop

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

2.绑定回调：也可以为某个 task 绑定一个回调方法

import asyncio
import requests

async def request():
    url='https://www.baidu.com'
    status = requests.get(url).status_code
    return status

def  callback(task):
    print('Status:',task.result())

coroutine = request()
task = asyncio.ensure_future(coroutine)
task.add_done_callback(callback)
print('Task:',task)

loop = asyncio.get_event_loop()
loop.run_until_complete(task)
print('Task:',task)

#输出结果
Task: <Task pending coro=<request() running at demo.py:5> cb=[callback() at demo.py:11]>

Status: <Response [200]>

Task: <Task finished coro=<request() done, defined at demo.py:5> result=<Response [200]>>

3.多任务协程

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

import asyncio
import requests

async def request():
    url = 'https://www.baidu.com'
    status = requests.get(url).status_code
    return status

tasks = [asyncio.ensure_future(request()) for _ in range(5)]
print('Tasks:',tasks)

loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))
for task in tasks:
    print('Task Result:',task.result())

#输出结果：
Tasks: [<Task pending coro=<request() running at demo.py:5>>, <Task pending coro=<request() running at demo.py:5>>, <Task pending coro=<request() running at demo.py:5>>, <Task pending coro=<request() running at demo.py:5>>, <Task pending coro=<request() running at demo.py:5>>]

Task Result: <Response [200]>

Task Result: <Response [200]>

Task Result: <Response [200]>

Task Result: <Response [200]>

Task Result: <Response [200]>

4.协程实现
　上面的案例只是为后面的使用作铺垫，接下来我们正式来看下协程在解决 IO 密集型任务上有怎样的优势吧！

为了表现出协程的优势，我们需要先创建一个合适的实验环境，最好的方法就是模拟一个需要等待一定时间才可以获取返回结果的网页，上面的代码中使用了百度，但百度的响应太快了，而且响应速度也会受本机网速影响，所以最好的方式是自己在本地模拟一个慢速服务器，这里我们选用 Flask。

#服务器代码：
from flask import Flask
import time
 
app = Flask(__name__)
 
@app.route('/')
def index():
    time.sleep(3)
return 'Hello!'

if __name__ == '__main__':
    app.run(threaded=True)       #这表明 Flask 启动了多线程模式，不然默认是只有一个线程的。

接下来我们再重新使用上面的方法请求一遍：

import asyncio
import requests
import time
 
start = time.time()
 
async def request():
    url = 'http://127.0.0.1:5000'
    print('Waiting for', url)
    response = requests.get(url)
    print('Get response from', url, 'Result:', response.text)
 
tasks = [asyncio.ensure_future(request()) for _ in range(5)]
loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))
 
end = time.time()
print('Cost time:', end - start)

#输出结果：
Waiting for http://127.0.0.1:5000
Get response from http://127.0.0.1:5000 Result: Hello!
Waiting for http://127.0.0.1:5000
Get response from http://127.0.0.1:5000 Result: Hello!
Waiting for http://127.0.0.1:5000
Get response from http://127.0.0.1:5000 Result: Hello!
Waiting for http://127.0.0.1:5000
Get response from http://127.0.0.1:5000 Result: Hello!
Waiting for http://127.0.0.1:5000
Get response from http://127.0.0.1:5000 Result: Hello!
Cost time: 15.049368143081665

在这里我们还是创建了五个 task，然后将 task 列表传给 wait() 方法并注册到时间循环中执行。

其实，要实现异步处理，我们得先要有挂起的操作，当一个任务需要等待 IO 结果的时候，可以挂起当前任务，转而去执行其他任务，这样我们才能充分利用好资源，上面方法都是一本正经的串行走下来，连个挂起都没有，怎么可能实现异步？

要实现异步，接下来我们再了解一下 await 的用法，使用 await 可以将耗时等待的操作挂起，让出控制权。当协程执行的时候遇到 await，时间循环就会将本协程挂起，转而去执行别的协程，直到其他的协程挂起或执行完毕。
所以，我们可能会将代码中的 request() 方法改成如下的样子：

async def request():
    url = 'http://127.0.0.1:5000'
    print('Waiting for', url)
    response = await requests.get(url)
print('Get response from', url, 'Result:', response.text)

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

Waiting for http://127.0.0.1:5000
Waiting for http://127.0.0.1:5000
Waiting for http://127.0.0.1:5000
Waiting for http://127.0.0.1:5000
Waiting for http://127.0.0.1:5000
Cost time: 15.048935890197754
Task exception was never retrieved
future: <Task finished coro=<request() done, defined at demo.py:7> exception=TypeError("object Response can't be used in 'await' expression",)>
Traceback (most recent call last):
  File "demo.py", line 10, in request
    status = await requests.get(url)
TypeError: object Response can't be used in 'await' expression

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

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

最后

以上就是安静曲奇最近收集整理的关于python爬虫进阶|异步协程前言一、基本概念二、异步协程的全部内容，更多相关python爬虫进阶|异步协程前言一、基本概念二、异步协程内容请搜索靠谱客的其他文章。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
点赞(36)

相关文章

流畅python学习笔记第十八章：使用asyncio包处理并发(二)
流畅python学习笔记第十八章：使用asyncio包处理并发(二)
Python: 进阶系列之五：并发编程：异步IO（asyncio) 协程(coroutine)与任务(task)的使用
Python: 进阶系列之五：并发编程：异步IO（asyncio) 协程(coroutine)与任务(task)的使用
爬虫15——协程异步
爬虫15——协程异步
Python爬虫实战：单线程、多线程和协程性能对比一、前言二、爬取测试三、单线程爬虫四、多线程爬虫五、异步协程爬虫六、总结回顾
Python爬虫实战：单线程、多线程和协程性能对比一、前言二、爬取测试三、单线程爬虫四、多线程爬虫五、异步协程爬虫六、总结回顾
python爬虫进阶|异步协程前言一、基本概念二、异步协程
python爬虫进阶|异步协程前言一、基本概念二、异步协程
异步编程-协程
异步编程-协程
多线程爬取，效率提升很多哦
多线程爬取，效率提升很多哦
python scrapy框架基如何实现多线程_网络爬虫第三次作业——多线程、scrapy框架...
python scrapy框架基如何实现多线程_网络爬虫第三次作业——多线程、scrapy框架...

评论列表共有 0 条评论

立即
投稿
返回
顶部