Python 协程的两种核心实现：生成器与原生协程对比

在上面的代码中，生成器函数通过使用 yield 语句暂停函数的执行，然后通过 send 方法恢复函数的执行，并将值传递给生成器函数。这种方式虽然能实现异步并发，但在 Python 3.5 引入原生协程之前，需要手动管理生成器的启动和唤醒，较为繁琐。

原生协程

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

示例代码

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())

执行流程分析

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

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

两种协程对比

Python 中原生协程和生成器协程是两种不同的协程实现方式，它们各自有自己的特点和适用场景。

区别

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

优缺点分析

原生协程

优点：

• 代码简洁易懂：使用 async/await 关键字，可以编写出更简洁易懂的协程代码，逻辑更接近同步代码。
• 性能更高：原生协程不需要创建生成器对象，也不需要通过 yield 语句来控制函数的执行流程，因此能够更加高效地处理异步操作。
• 支持异步 I/O 和任务处理：原生协程可以支持异步 I/O 操作和并发任务处理，可以在处理异步操作时更加灵活。
• 异常处理完善：原生协程支持标准的 try-except 异常捕获机制，错误处理更加直观。

缺点：

• 兼容性差：原生协程是 Python 3.5 版本之后才引入的新特性，因此在旧版本的 Python 中无法使用。
• 学习曲线：对于不熟悉异步编程的开发者，理解事件循环和协程调度可能需要一定时间。

生成器协程

优点：

• 兼容性好：生成器协程是 Python 2 和 Python 3 都支持的特性，适用于较老的项目环境。
• 可读性好：生成器协程使用 yield 关键字来实现，代码逻辑清晰易懂，适合简单的数据流处理。
• 异常处理方便：生成器协程在处理异常时比较方便，可以使用 try-except 语句来处理。

缺点：

• 性能相对较低：生成器协程需要创建生成器对象，也需要通过 yield 语句来控制函数的执行流程，因此处理异步操作时性能相对较低。
• 功能有限：生成器协程不能像原生协程一样直接支持异步 I/O 操作和任务处理，需要配合 asyncio 手动管理。
• 启动复杂：生成器协程需要显式调用 next() 或 send() 来启动，容易遗漏导致协程未执行。

实战案例：批量异步任务处理

接下来，模拟一个场景，假设实现一个异步的批量处理任务的工具，使用原生协程来实现。这个案例将展示如何处理并发、批次控制以及异常捕获。

import asyncio
import random
import time

async def process_task(task_id):
    """
    模拟单个任务的处理过程
    """
    try:
        # 模拟耗时操作，随机睡眠 0.5 到 2.0 秒
        delay = random.uniform(0.5, 2.0)
        await asyncio.sleep(delay)
        print(f"Task {task_id} processed in {delay:.2f}s")
        return task_id
    except Exception as e:
        print(f"Task {task_id} failed: {e}")
        raise

async def batch_process_task(tasks, batch_size=10):
    """
    将任务列表划分为多个批次进行并发处理
    """
    start_time = time.time()
    for i in range(0, len(tasks), batch_size):
        batch = tasks[i:i+batch_size]
        # 使用 asyncio.gather 并发处理每个批次的任务
        # limit 参数限制最大并发数，防止资源耗尽
        await asyncio.gather(*[process_task(task) for task in batch])
    end_time = time.time()
    print(f"All tasks completed in {end_time - start_time:.2f}s")

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

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

输出说明

运行上述代码，控制台会输出类似以下的日志（顺序可能因系统调度而异）：

Task 9 processed in 1.23s
Task 10 processed in 0.85s
Task 1 processed in 1.50s
...
All tasks completed in 5.42s

在这个案例中，batch_process_task 函数使用原生协程来处理每个批次的任务，process_task 函数则是处理每个具体任务的函数。main 函数负责构造任务列表，并且使用 batch_process_task 函数来异步地处理批量任务。通过 asyncio.gather，我们实现了在同一批次内的任务并发执行，同时通过分批处理控制了并发度，避免了对系统资源的过度消耗。

常见误区与最佳实践

在使用 Python 协程时，开发者需要注意以下几点以避免常见错误：

1. 不要在协程中使用阻塞 I/O：协程的核心优势在于非阻塞 I/O。如果在协程中使用了阻塞操作（如 time.sleep 或 requests.get），会导致整个事件循环被阻塞，失去并发意义。应始终使用 await asyncio.sleep 或 aiohttp 等异步库。
2. 正确处理异常：原生协程中的异常不会自动传播到主线程，必须使用 try-except 块捕获，或者让 asyncio.gather 收集异常。未处理的异常可能导致协程静默失败。
3. 避免死锁：在嵌套调用协程时，确保所有调用链都是异步的。如果在协程中调用了同步阻塞函数，可能会导致事件循环无法推进。
4. 合理使用并发限制：虽然协程很轻量，但过多的并发任务仍可能消耗大量内存或 CPU。使用 asyncio.Semaphore 或 gather 的 limit 参数来控制并发数量。

总结

Python 提供了两种主要的协程实现方式：生成器协程和原生协程。生成器协程基于 yield 关键字，兼容性好但功能受限；原生协程基于 async/await 关键字，语法更现代，性能更优，是 Python 3.5+ 推荐的标准写法。在实际开发中，建议优先使用原生协程配合 asyncio 框架，以实现高效、可维护的异步程序。