Python协程的实现方式有哪些

什么是协程

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

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

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

• 轻量级：协程的上下文切换成本很小，可以在单线程内并发执行大量的协程。

• 低延迟：协程的执行过程中，没有线程切换的开销，也没有加锁解锁的开销，可以更快地响应外部事件。

• 高效性：协程的代码通常比多线程和多进程的代码更加简洁和可读，维护成本更低。

协程的使用场景包括网络编程、异步 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 started
Coroutine started
Coroutine received: Hello
Coroutine received: World
Main finished

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

• main 函数开始执行，打印出 Main started。

• 创建一个生成器对象 c，调用 next(c) 使其执行到第一个 yield 语句处暂停。

• 使用 c.send('Hello') 恢复生成器函数的执行，并将 'Hello' 作为生成器函数的返回值。

• 在等待1秒钟的过程中，main 函数暂停执行，等待事件循环发起下一次任务。

• 在等待1秒钟后，使用 c.send('World') 继续执行生成器函数，并将 'World' 作为生成器函数的返回值。

• main 函数恢复执行，打印出 Main finished。

通过使用生成器函数 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协程的实现方式有哪些的详细内容，更多请关注编程网其它相关文章！