Phenquestions
Coroutine : La partie du code qui peut être interrompue et reprise dans un script multithread est appelée coroutine. les coroutines fonctionnent en coopération dans un programme multithread. Lorsqu'une coroutine s'arrête, une autre coroutine peut s'exécuter.
Boucle d'événement : Il est utilisé pour démarrer l'exécution des coroutines et gérer les opérations d'entrée/sortie. Il faut plusieurs tâches et les accomplir.
Tâche: L'exécution et le résultat des coroutines sont définis par les tâches. Vous pouvez affecter plusieurs nombres de tâches à l'aide de la bibliothèque asyncio et exécuter les tâches de manière asynchrone.
Futur: Il agit comme un futur stockage où le résultat des coroutines sera stocké après l'achèvement. Ceci est utile lorsqu'une coroutine nécessite d'attendre le résultat d'une autre coroutine.
Comment vous pouvez implémenter les concepts ci-dessus de la bibliothèque asyncio est montré dans ce tutoriel en utilisant quelques exemples simples.
Exemple 1 : créer une coroutine unique avec une seule tâche
Créer un fichier nommé async1.py et ajoutez le code suivant. la bibliothèque asyncio est importée pour utiliser les fonctions de cette bibliothèque. ajouter la fonction est déclarée pour calculer la somme d'une plage particulière de nombres. La plage de numéros de 1 à 101 est attribuée par la tâche avec un délai d'une seconde. La boucle d'événement est déclarée qu'elle s'exécutera jusqu'à ce que toutes les tâches de la méthode principale soient terminées. Après avoir calculé la valeur, la fonction attendra une seconde et imprimera le résultat.
importer asyncioasync def ajouter (début, fin, attente):
#Initialiser la variable somme
somme = 0
#Calculer la somme de tous les nombres
pour n dans la plage (début, fin):
somme += n
#Attendez les secondes attribuées
attendre asyncio.dormir (attendre)
#Imprimer le résultat
print(f'Sum from start to end is sum')
async def main() :
#Attribuer une seule tâche
tâche=boucle.create_task(add(1,101,1))
#Exécuter la tâche de manière asynchrone
attendre asyncio.attendre([tâche])
if __name__ == '__main__' :
#Déclarer la boucle d'événement
boucle = asyncio.get_event_loop()
#Exécutez le code jusqu'à ce que toutes les tâches soient terminées
boucle.run_until_complete(main())
#Fermer la boucle
boucle.Fermer()
Production:
$ python3 async1.pyLa sortie montre la somme de 1 à 101 qui est 5050.
Exemple-2 : Créer plusieurs coroutines
L'utilisation de la bibliothèque asyncio sera effacée lorsque vous exécuterez plusieurs coroutines simultanément. Créer un nouveau fichier nommé async2.py et ajoutez le code suivant. Trois tâches sont générées avec trois plages et valeurs d'attente différentes dans principale() méthode. La première tâche calculera la somme de 5 à 500000 en attendant 3 secondes, la deuxième tâche calculera la somme de 2 à 300000 en attendant 2 secondes et la troisième tâche calculera la somme de 10 à 1000 en attendant 1 seconde. La tâche avec des valeurs d'attente faibles se terminera d'abord et la tâche avec une valeur d'attente élevée se terminera enfin.
importer asyncioasync def ajouter (début, fin, attente):
#Initialiser la variable somme
somme = 0
#Calculer la somme de tous les nombres
pour n dans la plage (début, fin):
somme += n
#Attendez les secondes attribuées
attendre asyncio.dormir (attendre)
#Imprimer le résultat
print(f'Sum from start to end is sum')
async def main() :
#Attribuer la première tâche
tâche1=boucle.create_task(add(5,500000,3))
#Attribuer une deuxième tâche
tâche2=boucle.create_task(add(2,30000,2))
#Attribuer une troisième tâche
tâche3=boucle.create_task(add(10,1000,1))
#Exécuter les tâches de manière asynchrone
attendre asyncio.attendre([tâche1, tâche2, tâche3])
if __name__ == '__main__' :
#Déclarer la boucle d'événement
boucle = asyncio.get_event_loop()
#Exécutez le code jusqu'à ce que toutes les tâches soient terminées
boucle.run_until_complete(main())
#Fermer la boucle
boucle.Fermer()
Production:
$ python3 async1.pyLa sortie montre que la tâche3 est terminée en premier car le temps d'attente de cette tâche n'était que de 1 seconde et que la tâche1 est terminée en dernier car le temps d'attente de cette tâche était de 3 secondes.
Exemple-3 : coroutines avec futur
Cet exemple montre l'utilisation du futur objet de la bibliothèque asyncio. Créer un nouveau fichier nommé async3.py et ajoutez le code suivant. Deux tâches sont assignées pour l'avenir dans cet exemple. voir le message la fonction est déclarée ici pour imprimer le message avant d'exécuter la coroutine et après avoir terminé l'exécution. La première tâche attendra 2 secondes et se terminera en dernier. La deuxième tâche attendra 1 seconde et se terminera en premier.
importer asyncioasync def show_message (nombre, attendez) :
#Imprimer le message
print(f'La tâche numéro est en cours d'exécution')
#Attendez les secondes attribuées
attendre asyncio.dormir (attendre)
print(f'La tâche numéro est terminée')
async def stop_after (quand) :
attendre asyncio.dormir (quand)
boucle.arrêter()
async def main() :
#Attribuer la première tâche
tâche1=asyncio.assurer_future(afficher_message(1,2))
print('Programme 1')
#Attribuer une deuxième tâche
tâche2=asyncio.assurer_future(afficher_message(2,1))
print('Programme 2')
#Exécuter les tâches de manière asynchrone
attendre asyncio.attendre([tâche1, tâche2])
if __name__ == '__main__' :
#Déclarer la boucle d'événement
boucle = asyncio.get_event_loop()
#Exécutez le code de la méthode principale jusqu'à ce que toutes les tâches soient terminées
boucle.run_until_complete(main())
Production:
$ python3 async3.pyIl est indiqué dans la sortie que la tâche1 est démarrée en premier et terminée en dernier, et que la tâche2 est démarrée plus tard mais terminée en premier pour un court temps d'attente.
Conclusion
Le concept de base de la programmation asynchrone utilisant la bibliothèque asyncio de python est expliqué ici. J'espère que vous serez capable d'écrire du code multi-thread en python après avoir pratiqué les exemples de ce tutoriel.
