Ces deux types de coroutines génératrices sont-ils le même concept?

Question

Il semble y avoir deux types de coroutine à base de générateur:

1. De a reply par Jim Fasarakis Hilliard:

   coroutine base Générateur: Un générateur (def + yield) que est enveloppé par types.coroutine. Vous devez l'envelopper dans types.coroutine si vous en avez besoin pour être considéré comme un objet coroutin.

2. De Python dans un Nutshell, qui n'appelle explicitement "coroutine à base de générateur":

   Lorsque vous écrivez du code Python basé sur asyncio (de préférence en utilisant également add-on modules de asyncio.org), vous écrirez habituellement coroutine. Jusqu'à Python 3.4 inclus, ces fonctions sont des générateurs utilisant l'instruction yield from couverte dans "rendement de (v3-only)" à la page 95, décorée avec @asyncio.coroutine, couverte dans "coroutines asynchrones" à la page 518;

   De https://www.python.org/dev/peps/pep-0492/#differences-from-generators

   coroutines à base de générateur

   (code asyncio doit être décoré avec @ asyncio.coroutine)

   http://masnun.com/2015/11/13/python-generators-coroutines-native-coroutines-and-async-await.html appelle aussi "coroutine base générateur".

Les deux types de coroutines génératrices sont-ils le même concept? Dans la négative, quelles sont leurs différences dans les buts et les usages?

Merci.

Answer 1

Ils sont du même type de coroutine.types.coroutine et asyncio.coroutine ne sont que deux façons distinctes de les créer.

asyncio.coroutine est plus, l'introduction de antidatant async coroutines, et sa fonctionnalité a changé quelque peu de son comportement d'origine maintenant que async coroutines existent.

asyncio.coroutine et types.coroutine ont un comportement subtilement différent, surtout si elle est appliquée à tout autre qu'une fonction de générateur, ou si asyncio est en debug mode.

Answer 2

En ce qui me concerne, async def est le bon façon de définir une coroutine. yield et yield from ont leur rôle dans les générateurs, et ils sont également utilisés pour mettre en œuvre des «futurs», qui sont le mécanisme de bas niveau qui gère la commutation entre différents contextes coroutine.

J'ai fait this diagram il y a quelques mois pour résumer les relations entre eux. Mais franchement, vous pouvez ignorer toute l'affaire en toute sécurité. Les boucles d'événements ont la tâche de gérer tous les détails de bas niveau de la gestion de l'exécution des coroutines, donc utilisez l'un d'entre eux, comme asyncio. Il existe également des wrappers compatibles asyncio pour d'autres boucles d'événements, comme le mien glibcoro pour GLib/GTK. En d'autres termes, respectez l'API asyncio, et vous pouvez écrire des coroutines "event-loop-agnostic"!