Python asyncio se rassemble
Une entrée / sortie asynchrone ou Asyncio est une méthodologie de programmation qui utilise une boucle d'événement ou un seul thread pour accomplir une concurrence élevée. Python n'est pas le seul langage ou cadre qui utilise l'approche; Les nodejs de JavaScript sont peut-être les plus connus. Nous utilisons Asyncio dans Python plutôt que le multithreading parce que l'écriture d'une programmation en filetage est assez difficile. Il est beaucoup plus difficile de rencontrer des problèmes de course lors de l'utilisation de la programmation asynchrone, car vous pouvez identifier spécifiquement où le code passera d'une tâche à l'autre.En raison de l'exigence que chaque thread a sa pile, les threads utilisent une grande quantité de données. La programmation asynchrone maintient la pile petite en la détendant en continu entre les opérations, permettant à tous les programmes de partager la même pile. La plate-forme a besoin de plus de mémoire pour prendre en charge les threads car ce sont des constructions OS. Les tâches asynchrones n'ont pas ce problème.
Ici, nous discuterons de la fonction Asyncio - Rasseoir. Deux fonctions cruciales doivent être comprises lors de l'apprentissage du module Python Asyncio. La première option est exécutée, ce qui est une méthode simple pour exécuter une coroutine, et la deuxième option est de rassembler. Le contexte actuel redémarre une fois que toutes les coroutines sont terminées, vous permettant de lancer un certain nombre d'entre elles en utilisant simultanément.
Les réponses de chaque coroutine sont répertoriées dans la valeur de retour. Comme son nom l'indique, Asyncio.rassembler () se concentre principalement sur la collecte des résultats. Il attend de nombreux futurs, puis renvoie les résultats dans une séquence spécifique. L'asyncio.rassembler () annule tous les travaux incomplets qu'il rassemble s'il est annulé par lui-même.
Syntaxe d'Asyncio.se rassembler à Python
Asyncio.rassemble () accepte un seul ou multiple attendu comme * args, les résume dans des tâches le cas échéant, puis attend chacun d'eux pour terminer. Les résultats de chaque attente sont ensuite retournés dans l'ordre que vous les avez transmis:
# f_output, g_output = attendre asyncio.rassembler (f (), g ())Vous pouvez également fournir les exceptions de retour = vrai, dans lesquelles les exceptions de cas sont livrées avec les résultats réguliers, et vous devez déterminer par vous-même s'ils ont réussi.
Exemple 1:
L'asyncio.la fonction de collecte () peut être utilisée pour exécuter de nombreuses coroutines simultanément. Les coroutines sont exécutées simultanément par cette fonction comme des paramètres.
heure d'importation
Async Def Wishes ():
imprimer ("bonjour")
Awaitasyncio.sommeil (1)
imprimer ("Passez une bonne journée")
asynchrone def main ():
commencer = le temps.temps()
Awaitasyncio.rassembler (souhaits (), souhaits ())
écoulé = temps.Time () - commencer
print (f "__name__ exécuté dans Elapsed: 0.2f secondes.")
asyncio.Run (main ())
Ici, nous avons importé deux modules: Asyncio et l'heure de Python. Ensuite, nous avons défini une fonction avec le nom «souhaits». Nous avons établi la définition de la fonction asynchrone. La définition asynchrone ne contient que du code asynchrone; Tous les autres code sont synchrones. À l'intérieur de la fonction Async Def Wishes, nous avons imprimé les valeurs de chaîne. L'asyncio.La fonction de sommeil a été appelée et la valeur de la suspension du thread sélectionné a été définie à l'aide du mot-clé Await. Attendre renvoie le contrôle à la boucle d'événement lors d'un appel de fonction.
Après cela, nous avons construit une autre fonction de Def asynchrone comme Main (). À l'intérieur de cette fonction, nous définissons la variable où la fonction temporelle du module de temps Python est appelée. Avec le mot-clé Await, nous avons défini l'asyncio.Rassemblez la fonction pour rassembler le résultat de la fonction. Nous avons également enregistré le temps d'éclat pour l'exécution du code principal.
Dans la sortie, nous avons les coroutines générées deux fois simultanément à partir de la fonction des souhaits (). La sortie du code mentionné précédemment est affichée avec succès dans l'image suivante:
Exemple 2:
L'exécution de plusieurs co-routines peut être planifiée dynamiquement à l'aide de la méthode Asyncio Gather comme démontré dans cet exemple. Après la collection réussie de tous les résultats de co-routine, l'appel d'attente fournit les valeurs comme résultats et les imprime.
Async Def add (A: int, b: int):
retourner un + b
async def get_result ():
entrées = [(4, 5), (6, 6), (7, 8), (9, 4)]
tâches = [asyncio.create_task (add (a, b)) pour a, b en entrées]
résultat = asyncio.rassembler (* tâches)
Imprimer ("Résultat:")
Imprimer (attendre le résultat)
asyncio.Run (get_result ())
Dans cet exemple particulier, nous avons inclus le module Asyncio pour utiliser l'Asyncio.rassembler. Ensuite, nous avons défini une fonction asynchrone pour l'ajout. Nous avons généré la fonction Add Async et définie les deux variables A et B avec le type de données int sur la fonction ADD. Avec la commande de retour, nous avons ajouté ces variables avec l'opérateur plus.
Après avoir établi la coroutine, nous avons créé une autre fonction pour planifier la boucle d'événement dans la coroutine. La fonction est nommée «get_result» où nous avons initialisé la liste avec les entrées de variable. Après cela, nous avons créé la liste des tâches dans la variable de tâche. Avec l'asyncio.Rassemblez la fonction, nous avons rassemblé le résultat de la liste des tâches en passant la tâche du pointeur à cette fonction. Nous avons enfin imprimé le résultat. La liste de tâches suivante est obtenue à partir du programme précédent:
Exemple 3:
Nous avons rassemblé le résultat de la tâche future en passant la tâche future dans l'Asyncio.rassembler. Future désigne un calcul en cours d'exécution ou qui sera prévu à l'avenir. Un résultat éventuel d'une procédure asynchrone est représenté par un objet attendable de bas niveau unique.
De Asyncio Import Future
Async Def Fonction1 (Future):
imprimer ("Fonction1 dormira pendant 3 secondes")
AWAIT ASYNCIO.sommeil (3)
Imprimer ("Fonction1 Résolution de l'avenir")
avenir.fait()
avenir.set_result ("Future est résolu")
Fonction Async Def 2 (Future):
imprimer ("function2 attendra l'avenir")
attendre l'avenir
print ("function2 trouve le futur résolu")
asynchrone def main ():
futur = future ()
Résultats = Awaitasyncio.rassembler (function2 (futur), function1 (futur))
Si __name __ == "__ Main___":
asyncio.Run (main ())
imprimer ("Main terminé")
Ici, nous avons d'abord inclus le module Asyncio et le futur module de l'Asyncio. Ensuite, nous avons défini la coroutine comme «fonction1» et passé l'avenir. Puis, à l'intérieur de cette coroutine, nous avons appelé la fonction de sommeil pour la suspension de la coroutine. Nous avons appelé l'appel du système DID et les appels système set_result à l'avenir. Là, nous avons une autre coroutine qui est nommée «Function2» et elle prend également le futur comme argument. Nous avons appelé la commande Await à l'avenir pour être résolu.
Après cela, nous avons la définition principale asynchrone que nous avons appelée la fonction future, et obtenons le résultat de l'avenir par l'Asyncio.rassembler la méthode. En fin de compte, nous avons imprimé l'instruction lorsque la fonction principale a été terminée. La sortie du code mentionné précédemment est affichée avec succès dans l'image suivante:
Conclusion
Se rassembler est fort, comme vous pouvez le voir. Nous pouvons demander succinctement plusieurs ressources à la fois, ce qui est un événement typique dans les programmes Web. Avec l'aide du python asyncio.Rasseoir le module intégré, la programmation asynchrone a été présentée dans ce tutoriel. Nous avons rassemblé les résultats des coroutines, des tâches et des futurs. Un code simultané peut être votre meilleur choix lorsque vous avez besoin d'optimiser les performances pour des activités particulières, car nous avons précédemment discuté de la façon d'exécuter les nombreuses coroutines en utilisant simultanément l'Asyncio.rassembler des méthodes.