que fait `rendement de asyncio.sleep (delay)`?
L'exemple suivant de Python dans un Nutshell définit x à 23 Après un délai d'une seconde et demie:
@asyncio.coroutine
def delayed_result(delay, result):
yield from asyncio.sleep(delay)
return result
loop = asyncio.get_event_loop()
x = loop.run_until_complete(delayed_result(1.5, 23))
J'ai du mal à comprendre ce que fait yield from asyncio.sleep(delay).
De https://docs.python.org/3/library/asyncio-task.html#asyncio.sleep
Coroutine asyncio.sleep(delay, result=None, *, loop=None)Créez une coroutine qui se termine après un temps donné (en secondes). Si le résultat est fourni, il est produit à l'appelant lorsque la coroutine est terminée.
Donc asyncio.sleep(delay) retourne un objet coroutine.
Que signifie un objet coroutine "complet"?
Quelles valeurs yield from asyncio.sleep(delay) fournit-elle au programme principal?
Merci.
La ligne de code suivante:
time.sleep(5)
... bloque l'exécution de votre code pendant 5 secondes. Rien de plus n'est calculé ou exécuté tant que la fonction de veille n'a pas terminé sa sieste de 5 secondes, car l'application ne peut pas continuer sans que la fonction de sommeil ne revienne à l'appelant. C'est ce qu'on appelle la programmation synchrone, lorsqu'il n'y a pas de mécanisme pour que l'application modifie son focus et effectue d'autres tâches en périodes d'attente telles que l'attente des résultats d'un appel vers une base de données, une API Web ou comme dans ce cas la fonction veille . En programmation synchrone, il n'y a pas besoin d'une boucle d'événement car il n'y a aucune attente que l'application gère son temps ni qu'elle change de tâche pour des gains d'efficacité.
Le code suivant:
asyncio.sleep(5)
... fait partie de la bibliothèque asyncio, conçue pour la programmation asynchrone où ne boucle d'événement se voit attribuer des tâches à concurrencer et elle (la boucle d'événement) surveille l'état de toutes ses tâches et passe de l'une à un autre dans le but de minimiser le temps d'inactivité/d'attente. Il ne s'agit pas de thread où plusieurs processus sont exécutés simultanément, il s'agit simplement d'optimiser l'exécution des tâches afin que le processeur ne reste pas inactif, ce qui permet de réduire considérablement les temps d'exécution globaux.
Le rendement du mot clé (le mot clé python 3.5 en attente peut être utilisé) est le moment où la boucle d'événement a la possibilité de laisser une tâche se terminer (par exemple, pendant qu'une requête est renvoyée à partir d'un appel de base de données) et se concentrer sur une autre tâche dont la boucle d'événement a connaissance et qui peut en fait être calculée/exécutée entre-temps.
@ asyncio.coroutine decorator + yield from est compatible avec python 3.5 en avant mais en utilisant le nouveau mot-clé async def pour définir une coroutine asyncrone et le mot-clé attend à l'intérieur pour permettre à la boucle d'événement d'évaluer le passage à une autre tâche est la voie à suivre commune et à l'épreuve du temps si vous êtes 3.5 ou supérieur.
Asyncronous python peut être assez difficile à comprendre, mais il y a un certain nombre d'excellentes discussions pycon sur le sujet des dernières années - recherchez-en une sur Youtube et si bien sûr lisez les documents? ???
yield from est la syntaxe python3.4 pour 3.5 await qui aura probablement plus de sens.
"complète" signifie simplement que la tâche de la coroutine est terminée.
Dans ce cas, vous souhaitez utiliser le sommeil asynchrone afin de pouvoir calculer d'autres tâches pendant que la tâche de sommeil est en cours d'exécution, cela a plus de sens si vous avez d'autres tâches/coroutines parallèles en cours d'exécution.