Quelles sont les méthodes d’implémentation des coroutines Python ?

Qu'est-ce que la coroutine

En Python, la coroutine est une méthode de programmation simultanée légère qui peut réaliser une exécution simultanée efficace grâce au multitâche collaboratif. L'utilisation du mot-clé rendement pour suspendre l'exécution d'une fonction et enregistrer l'état d'exécution actuel est une fonctionnalité particulière des coroutines. Par conséquent, une coroutine peut être considérée comme un type particulier de fonction génératrice. Lorsqu'une coroutine est suspendue, son exécution peut être reprise à l'aide de la méthode send et une valeur est renvoyée lors de la reprise.

Avant Python 3.4, le mot-clé rendement était souvent utilisé pour implémenter des coroutines, appelées « coroutines génératrices ». Après l'introduction du module asyncio dans Python 3.4, vous pouvez utiliser le mot-clé async/await pour définir des fonctions de coroutine, appelées « coroutines natives ».

Par rapport aux threads et aux processus, les coroutines présentent les avantages suivants :

• Léger : le coût de changement de contexte des coroutines est très faible. Un certain nombre de coroutines peuvent être exécutées simultanément dans un seul thread.

• Faible latence : lors de l'exécution de la coroutine, il n'y a pas de surcharge de changement de thread ou de verrouillage et de déverrouillage, permettant une réponse plus rapide aux événements externes.

• Efficacité : le code coroutine est généralement plus concis et lisible que le code multithread et multi-processus, et a des coûts de maintenance inférieurs.

Les scénarios d'utilisation des coroutines incluent la programmation réseau, les E/S asynchrones, le traitement des flux de données, les tâches à haute concurrence, etc.

Generator Coroutine

Dans Python 3, Generator Coroutine fait référence à une coroutine implémentée à l'aide de fonctions génératrices. Une fonction génératrice est une fonction spéciale qui renvoie un objet générateur. L'exécution de la fonction peut être suspendue via l'instruction rendement, puis poursuivie la prochaine fois que la méthode 『next』() de l'objet générateur est appelée. . mettre en œuvre.

Ce qui suit est un exemple de coroutine de générateur simple, qui contient une coroutine de fonction de générateur et une simple opération d'E/S asynchrone :

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

Sortie du résultat :

[root@workhost k8s]# python3 test.py
Main démarrée
Coroutine démarrée
Coroutine reçue : Bonjour
Coroutine reçue : Monde#🎜🎜 #Main terminé

Jetons un coup d'œil au processus d'exécution du code ci-dessus :

• main la fonction commence à s'exécuter, L'impression principale a commencé.

• Créez un objet générateur c et appelez next(c) pour suspendre son exécution à la première instruction rendement.

• Utilisez c.send('Hello') pour reprendre l'exécution de la fonction génératrice et utilisez 'Hello' comme valeur de retour de la fonction génératrice.

• En attendant 1 seconde, la fonction principale suspend l'exécution et attend que la boucle d'événements lance la tâche suivante.

• Après avoir attendu 1 seconde, utilisez c.send('World') pour continuer à exécuter la fonction génératrice et utilisez 'World' comme valeur de retour de la fonction génératrice .

• La fonction principale reprend l'exécution et imprime Main terminée.

En utilisant la fonction génératrice coroutine, ce code implémente une coroutine simple. Une fonction génératrice suspend l'exécution de la fonction en utilisant l'instruction rendement, qui peut ensuite être reprise via la méthode send, en transmettant la valeur à la fonction génératrice. De cette façon, vous pouvez utiliser des fonctions de générateur pour obtenir une concurrence asynchrone. Utilisez une fonction de générateur pour accepter les résultats d'une opération d'E/S asynchrone et les imprimer, comme indiqué dans l'exemple.

Native Coroutine

Python 3 introduit Native Coroutine comme nouveau type de coroutine. Les coroutines natives sont définies à l'aide du mot-clé async/await, et contrairement aux coroutines du générateur, elles peuvent renvoyer des valeurs comme les fonctions normales en utilisant l'instruction return au lieu d'utiliser l'instruction rendement.

Ce qui suit est un exemple simple de coroutine native, qui contient une fonction de coroutine modifiée avec le mot-clé async et une simple opération d'E/S asynchrone :

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

Résultat : #🎜 🎜#

[root@workhost k8s]# python3 test.py

Main démarrée

Coroutine démarrée
Coroutine terminée
Main terminée
# 🎜🎜#
Continuez à regarder le processus d'exécution :

main la fonction démarre l'exécution et imprime Main démarré.

• Appelez la fonction coroutine et exécutez-la en tant qu'objet coroutine.

• Dans la fonction coroutine, imprimez Coroutine démarrée.

• Dans la fonction coroutine, utilisez wait asyncio.sleep(1) pour suspendre l'exécution de la fonction et attendre 1 seconde.

• Après 1 seconde, reprenez l'exécution de la fonction coroutine et imprimez Coroutine terminée.

• La fonction principale reprend l'exécution et imprime Main terminée.

• Dans le code ci-dessus, une coroutine de fonction de coroutine native est définie à l'aide du mot-clé async, et le mot-clé wait y est utilisé pour suspendre l'exécution de la fonction et attendre pour l'achèvement asynchrone des opérations d'E/S. L'utilisation de coroutines natives vous permet d'écrire du code asynchrone simultané, améliorant ainsi l'efficacité et les performances du code.

两种协程对比

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函数来异步地处理批量任务。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!