La bibliothèque Asyncio est introduite dans Python 3.4 pour exécuter des programmes simultanés à thread unique. Cette bibliothèque est populaire que les autres bibliothèques et frameworks pour sa vitesse impressionnante et leur utilisation diverses. Cette bibliothèque est utilisée dans Python pour créer, exécuter et structurer des coroutines et gérer plusieurs tâches simultanément sans effectuer les tâches en parallèle. Les principales parties de cette bibliothèque sont définies ci-dessous:

Coroutine: La partie du code qui peut être interrompue et reprendre dans un script multithread s'appelle Coroutine. Les coroutines travaillent en coopération dans un programme multithread. Quand une coroutine s'arrête, une autre coroutine peut 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 terminer.

Tâche: L'exécution et le résultat des coroutines sont définis par les tâches. Vous pouvez attribuer plusieurs tâches à l'aide de la bibliothèque Asyncio et exécuter les tâches de manière asynchrone.

Avenir: Il agit comme un futur stockage où le résultat des coroutines se stockera après l'achèvement. Ceci est utile lorsque une coroutine a besoin 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éez une seule coroutine avec une seule tâche

Créer un fichier nommé async1.py et ajouter le code suivant. La bibliothèque Asyncio est importée pour utiliser les fonctions de cette bibliothèque. ajouter La fonction est déclaré pour calculer la somme d'une gamme particulière de nombres. La plage de nombres de 1 à 101 est attribuée par la tâche avec une seconde retard. La boucle d'événement est déclarée qu'elle fonctionnera jusqu'à ce que toutes les tâches de la méthode principale complètent. Après avoir calculé la valeur, la fonction attendra une seconde et imprimera le résultat.

importer asyncio
Async Def Add (démarrer, fin, attendre):
#Initialiser la variable de somme
sum = 0
#Calculate la somme de tous les nombres
pour n à portée (début, fin):
somme + = n
#Wait pour les secondes assignées
AWAIT ASYNCIO.sommeil (attendez)
# Print le résultat
print (f'sum de start à end est sum ')
asynchrone def main ():
#Assign une seule tâche
tâche = boucle.create_task (add (1,101,1))
#Run la tâche de manière asynchrone
AWAIT ASYNCIO.attendre ([tâche])
Si __name__ == '__MAIN__':
#Declare Event Loop
boucle = asyncio.get_event_loop ()
#Run le code jusqu'à terminer toute la tâche
boucle.run_until_complete (main ())
#Fermer la boucle
boucle.fermer()

Sortir:

$ python3 async1.py

La sortie montre la somme de 1 à 101 qui est 5050.

Exemple-2: Créez 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 ajouter le code suivant. Trois tâches sont générées avec trois gammes différentes et des valeurs d'attente dans principal() 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 calculer la somme de 10 à 1000 en attendant 1 seconde. La tâche avec de faibles valeurs d'attente se terminera au début et la tâche avec une valeur d'attente élevée se terminera enfin.

importer asyncio
Async Def Add (démarrer, fin, attendre):
#Initialiser la variable de somme
sum = 0
#Calculate la somme de tous les nombres
pour n à portée (début, fin):
somme + = n
#Wait pour les secondes assignées
AWAIT ASYNCIO.sommeil (attendez)
# Print le résultat
print (f'sum de start à end est sum ')
asynchrone def main ():
#Assign première tâche
tâche1 = boucle.create_task (add (5 500000,3))
#Assign deuxième tâche
tâche2 = boucle.create_task (add (2 300000,2))
#Assign troisième tâche
tâche3 = boucle.create_task (add (10,1000,1))
#Run les tâches de manière asynchrone
AWAIT ASYNCIO.attendre ([tâche1, tâche2, tâche3])
Si __name__ == '__MAIN__':
#Declare Event Loop
boucle = asyncio.get_event_loop ()
#Run le code jusqu'à terminer toute la tâche
boucle.run_until_complete (main ())
#Fermer la boucle
boucle.fermer()

Sortir:

$ python3 async1.py

La 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 l'avenir

Cet exemple montre l'utilisation d'un futur objet de la bibliothèque Asyncio. Créer un nouveau fichier nommé async3.py et ajouter le code suivant. Deux tâches sont affectées à 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 terminera le dernier. La deuxième tâche attendra 1 seconde et terminera d'abord.

importer asyncio
Async Def Show_Message (numéro, attendre):
# Print le message
print (f'task numéro est en cours d'exécution ')
#Wait pour les secondes assignées
AWAIT ASYNCIO.sommeil (attendez)
print (f'task numéro est terminé ')
Async def stop_after (quand):
AWAIT ASYNCIO.dormir (quand)
boucle.arrêt()
asynchrone def main ():
#Assign première tâche
tâche1 = asyncio.assure_future (show_message (1,2))
Imprimer («annexe 1»)
#Assign deuxième tâche
tâche2 = asyncio.assure_future (show_message (2,1))
Imprimer («annexe 2»)
#Run les tâches de manière asynchrone
AWAIT ASYNCIO.attendre ([tâche1, tâche2])
Si __name__ == '__MAIN__':
#Declare Event Loop
boucle = asyncio.get_event_loop ()
#Run le code de la méthode principale jusqu'à terminer toutes les tâches
boucle.run_until_complete (main ())

Sortir:

$ python3 async3.py

Il est montré dans la sortie que la tâche1 est démarrée en premier et terminée en dernier, et 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 à l'aide de la bibliothèque Asyncio de Python est expliqué ici. J'espère que vous pourrez écrire du code multithread dans Python après avoir pratiqué les exemples de ce tutoriel.