Python协程的实现方式有哪些-Python教程-PHP中文网

Python协程的实现方式有哪些

WBOY

发布： 2023-05-20 11:08:14

转载

914人浏览过

什么是协程

在 python 中，协程（coroutine）是一种轻量级的并发编程方式，可以通过协作式多任务来实现高效的并发执行。使用 yield 关键字挂起函数的执行，以及保存当前执行状态，是协程的特殊之处。因此，协程可视为一种特殊的生成器函数。当协程被挂起时，可以使用 send 方法来恢复其执行，并在恢复后返回一个值。

在 Python 3.4 以前，常使用 yield 关键字来实现协程，即称为“生成器协程”。在 Python 3.4 引入了 asyncio 模块后，可以使用 async/await 关键字来定义协程函数，称为“原生协程”。

协程相比于线程和进程，具有以下优点：

轻量级：协程的上下文切换成本很小，可以在单线程内并发执行大量的协程。
低延迟：协程的执行过程中，没有线程切换的开销，也没有加锁解锁的开销，可以更快地响应外部事件。

立即学习“Python免费学习笔记（深入）”；
高效性：协程的代码通常比多线程和多进程的代码更加简洁和可读，维护成本更低。

协程的使用场景包括网络编程、异步 I/O、数据流处理、高并发任务等。

生成器协程

在 Python 3 中，生成器协程（Generator Coroutine）是指使用生成器函数来实现的协程。生成器函数是一种特殊的函数，其返回一个生成器对象，可以通过 yield 语句暂停函数的执行，然后在下一次调用生成器对象的 「next」() 方法时继续执行。

下面给出一个简单的生成器协程的示例，其中包含一个生成器函数 coroutine 和一个简单的异步 I/O 操作：

import asyncio

def coroutine():
    print('Coroutine started')
    while True:
        result = yield
        print('Coroutine received:', result)

async def main():
    print('Main started')
    c = coroutine()
    next(c)
    c.send('Hello')
    await asyncio.sleep(1)
    c.send('World')
    print('Main finished')

asyncio.run(main())

登录后复制

结果输出：

[root@workhost k8s]# python3 test.py Main startedCoroutine startedCoroutine received: HelloCoroutine received: WorldMain finished

来看一下，上面代码的执行过程：

main 函数开始执行，打印出 Main started。
创建一个生成器对象 c，调用 next(c) 使其执行到第一个 yield 语句处暂停。
使用 c.send('Hello') 恢复生成器函数的执行，并将 'Hello' 作为生成器函数的返回值。
在等待1秒钟的过程中，main 函数暂停执行，等待事件循环发起下一次任务。
在等待1秒钟后，使用 c.send('World') 继续执行生成器函数，并将 'World' 作为生成器函数的返回值。
main 函数恢复执行，打印出 Main finished。

极限网络办公Office Automation
专为中小型企业定制的网络办公软件,富有竞争力的十大特性： 1、独创 web服务器、数据库和应用程序全部自动傻瓜安装，建立企业信息中枢只需3分钟。 2、客户机无需安装专用软件，使用浏览器即可实现全球办公。 3、集成Internet邮件管理组件，提供web方式的远程邮件服务。 4、集成语音会议组件，节省长途话费开支。 5、集成手机短信组件，重要信息可直接发送到员工手机。 6、集成网络硬

0

查看详情

通过使用生成器函数 coroutine，这段代码实现了一个简单的协程。生成器函数通过使用 yield 语句暂停函数的执行，然后可以通过 send 方法恢复函数的执行，并将值传递给生成器函数。通过这种方式，可以使用生成器函数实现异步并发。使用生成器函数接受异步 I/O 操作的结果，并将其打印出来，如示例所示。

原生协程

Python 3引入原生协程(Native Coroutine)作为一种新型协程类型。原生协程是通过使用 async/await 关键字来定义的，与生成器协程不同，它们可以像普通函数一样使用 return 语句返回值，而不是使用 yield 语句。

下面给出一个简单的原生协程示例，其中包含一个 async 关键字修饰的协程函数 coroutine 和一个简单的异步 I/O 操作：

import asyncio

async def coroutine():
    print('Coroutine started')
    await asyncio.sleep(1)
    print('Coroutine finished')

async def main():
    print('Main started')
    await coroutine()
    print('Main finished')

asyncio.run(main())

登录后复制

结果输出：

[root@workhost k8s]# python3 test.py
Main started
Coroutine started
Coroutine finished
Main finished

继续看一下执行过程：

main 函数开始执行，打印出 Main started。
调用 coroutine 函数，将其作为一个协程对象运行。
在 coroutine 函数中，打印出 Coroutine started。
在 coroutine 函数中，使用 await asyncio.sleep(1) 暂停函数的执行，等待1秒钟。
在1秒钟后，恢复 coroutine 函数的执行，并打印出 Coroutine finished。
main 函数恢复执行，打印出 Main finished。

在上面的代码中，使用 async 关键字定义了一个原生协程函数 coroutine，并在其中使用 await 关键字来暂停函数的执行，等待异步 I/O 操作的完成。使用原生协程可以编写并发异步代码，从而提高代码的效率和性能。

两种协程对比

Python 3 中，原生协程和生成器协程是不同的协程实现方式，它们分别具有独特的特点和适用场景。下面，通过对比它们的区别和优缺点，才可以更好地理解它们之间的异同，以便选择适合自己的协程实现方式，从而更好地编写高效、可维护的异步程序。

1.区别：

定义方式不同：原生协程使用 async/await 关键字来定义，而生成器协程使用 yield 关键字来定义。
返回方式不同：原生协程使用 return 语句来返回结果，而生成器协程使用 yield 语句来返回结果。
调用方式不同：原生协程使用 await 关键字来调用，而生成器协程使用 yield from 或 yield 语句来调用。
原生协程与生成器协程的实现方式不同，前者使用 asyncio 库，后者则是 Python 语言内置的特性。

2.优缺点：

原生协程的优点：

代码简洁易懂：使用 async/await 关键字，可以编写出更简洁易懂的协程代码。
性能更高：原生协程不需要创建生成器对象，也不需要通过 yield 语句来控制函数的执行流程，因此能够更加高效地处理异步操作。
支持异步 I/O 和任务处理：原生协程可以支持异步 I/O 操作和并发任务处理，可以在处理异步操作时更加灵活。

原生协程的缺点：

兼容性差：原生协程是 Python 3.5 版本之后才引入的新特性，因此在旧版本的 Python 中无法使用。
异常处理不方便：原生协程在处理异常时比较麻烦，需要使用 try/except 语句来处理。

生成器协程的优点：

兼容性好：生成器协程是 Python 2 和 Python 3 都支持的特性。
可读性好：生成器协程使用 yield 关键字来实现，代码逻辑清晰易懂。
异常处理方便：生成器协程在处理异常时比较方便，可以使用 try/except 语句来处理。

生成器协程的缺点：

性能相对较低：生成器协程需要创建生成器对象，也需要通过 yield 语句来控制函数的执行流程，因此处理异步操作时性能相对较低。
功能有限：生成器协程不能像原生协程一样支持异步 I/O 操作和任务处理。

实战案例

接下来，模拟一个场景，假设实现一个异步的批量处理任务的工具，使用原生协程来实现。

看下面代码：

import asyncio
import random

async def batch_process_task(tasks, batch_size=10):
    # 将任务列表划分为多个批次
    for i in range(0, len(tasks), batch_size):
        batch = tasks[i:i+batch_size]
        # 使用原生协程来异步处理每个批次的任务
        await asyncio.gather(*[process_task(task) for task in batch])

async def process_task(task):
    # 模拟任务处理过程
    await asyncio.sleep(random.uniform(0.5, 2.0))
    print("Task {} processed".format(task))

async def main():
    # 构造任务列表
    tasks = [i for i in range(1, 101)]
    # 并发处理批量任务
    await batch_process_task(tasks, batch_size=10)

if __name__ == '__main__':
    asyncio.run(main())

登录后复制

输出：

[root@workhost k8s]# python3 test.py
Task 9 processed
Task 10 processed
Task 1 processed
Task 8 processed
Task 6 processed
Task 4 processed
Task 3 processed
Task 2 processed
Task 5 processed
...
...

batch_process_task函数使用原生协程来处理每个批次的任务，而process_task函数则是处理每个任务的函数。在main函数中，任务列表会被构造，并使用batch_process_task函数来异步地处理批量任务。

以上就是Python协程的实现方式有哪些的详细内容，更多请关注php中文网其它相关文章！