Python Asyncio versammeln sich
Asynchroner Eingang/Ausgang oder Asyncio ist eine Programmiermethode, die eine Ereignisschleife oder einen einzelnen Thread verwendet, um eine hohe Parallelität zu erreichen. Python ist nicht die einzige Sprache oder Framework, die den Ansatz verwendet. Javascripts NodeJs ist vielleicht das bekannteste. Wir verwenden Asyncio in Python und nicht in Multithreading. Bei der Verwendung asynchroner Programmierung ist es wesentlich schwieriger, Rennprobleme zu treffen, da Sie genau bestimmen können, wo sich der Code von einer Aufgabe zur nächsten ändert.Aufgrund der Anforderung, dass jeder Thread seinen Stapel hat, verwenden Threads eine große Datenmenge. Die asynchronisierte Programmierung hält den Stapel klein, indem er ihn kontinuierlich zwischen den Operationen entspannt und es allen Programmen ermöglicht, denselben Stapel zu teilen. Die Plattform benötigt mehr Speicher, um die Threads zu unterstützen, da sie Betriebssystemkonstrukte sind. Asynchrone Aufgaben haben dieses Problem nicht.
Hier werden wir die asyncio -Funktion besprechen - versammeln. Zwei entscheidende Funktionen sollten beim Erlernen des Python Asyncio -Moduls verstanden werden. Die erste Option ist ausgeführt, eine einfache Methode zum Ausführen einer Coroutine, und die zweite Option ist gesammelt. Der aktuelle Kontext startet neu, sobald alle Coroutinen abgeschlossen sind, so.
Die Antworten jeder Coroutine sind im Rückgabewert aufgeführt. Wie der Name schon sagt, Asyncio.Sammeln () konzentriert sich hauptsächlich darauf, die Ergebnisse zu sammeln. Es wartet auf zahlreiche Futures und gibt dann die Ergebnisse in einer bestimmten Reihenfolge zurück. Der Asyncio.sammeln () storniert alle unvollständigen Jobs, die sie sammelt.
Syntax von Asyncio.Treffen Sie sich in Python
Asyncio.sammeln () akzeptiert ein einzelnes oder mehrere wartungswerte als *args, füllt sie gegebenenfalls in Aufgaben und wartet dann auf jeden von ihnen, um sie zu vervollständigen. Die Ergebnisse jedes erwartbaren Zeitpunkts werden dann in der Reihenfolge zurückgegeben, dass Sie sie bestanden haben:
# f_output, g_output = wartet Asyncio.sammeln (f (), g ())Sie können auch die Rückgabeberechnungen für die Rendite angeben.
Beispiel 1:
Der Asyncio.Came. Coroutinen werden durch diese Funktion gleichzeitig als Parameter ausgeführt.
Importzeit
Async def wishes ():
print ("Hallo")
AwaitaSyncio.Schlaf (1)
drucken ("einen schönen Tag haben")
Async def Main ():
Beginnen Sie = Zeit.Zeit()
AwaitaSyncio.Gathere (Wishes (), Wishes ())
verstrichen = Zeit.Time () - Beginnen Sie
print (f "__name__ ausgeführt in verblüfft: 0.2f Sekunden."))
Asyncio.run (main ())
Hier haben wir zwei Module importiert: Asyncio und die Zeit von Python. Dann haben wir eine Funktion mit dem Namen "Wünsche" definiert. Wir haben die asynchrische Funktionsdefinition festgelegt. Die asynchronisierte Definition enthält nur asynchrone Code; Alle anderen Code sind synchron. In der Funktion der Async Def Wishes haben wir die String -Werte gedruckt. Der Asyncio.Die Schlaffunktion wurde aufgerufen und der Wert für die Aufhängung des ausgewählten Thread. Warten Sie auf die Ereignisschleife während eines Funktionsaufrufs zurück.
Danach konstruierten wir eine andere asynchronisierte Def -Funktion als main (). In dieser Funktion setzen wir die Variable, in der die Zeitfunktion aus dem Python -Zeitmodul aufgerufen wird. Mit dem Keyword des Wartedurchgangs haben wir den Asyncio definiert.Sammeln Sie die Funktion, um ein Ergebnis der Funktionswünsche zu sammeln. Wir haben auch den Zeitverlauf für die Ausführung des Hauptcodes aufgezeichnet.
In der Ausgabe haben wir die Coroutinen zweimal gleichzeitig aus der Funktion wishes () generiert. Die Ausgabe des zuvor erwähnten Codes wird im folgenden Bild erfolgreich angezeigt:
Beispiel 2:
Die Ausführung mehrerer Co-Routinen kann dynamisch unter Verwendung der Asyncio-Sammelmethode geplant werden, wie in diesem Beispiel gezeigt. Nach der erfolgreichen Sammlung aller Co-Routine-Ergebnisse liefert der Warte-Aufruf die Werte als Ergebnisse und druckt sie aus.
Async def add (a: int, b: int):
Return a + b
Async def get_result ():
Eingänge = [(4, 5), (6, 6), (7, 8), (9, 4)]
Aufgaben = [Asyncio.create_task (add (a, b)) für a, b in Eingängen]
Ergebnis = asyncio.versammeln (*Aufgaben)
print ("Ergebnis:")
drucken (erwarten Sie Ergebnis)
Asyncio.run (get_result ())
In diesem speziellen Beispiel haben wir das Asyncio -Modul zur Verwendung des Asyncio eingeschlossen.Funktion sammeln. Dann haben wir eine asynchronisierte Funktion für die Addition definiert. Wir haben die asynchronisierende Funktion hinzufügen und die beiden Variablen A und B mit dem INT -Datentyp auf die Funktion hinzufügen gesetzt. Mit dem Befehl return haben wir diese Variablen mit dem Plus -Operator hinzugefügt.
Nachdem wir die Coroutine eingestellt hatten, haben wir eine weitere Funktion erstellt, um die Ereignisschleife in der Coroutine zu planen. Die Funktion heißt "get_result", wo wir die Liste mit den variablen Eingängen initialisiert haben. Danach haben wir die Aufgabenliste in der Aufgabenvariablen erstellt. Mit dem Asyncio.Sammeln Sie die Funktion, wir haben das Ergebnis der Aufgabenliste gesammelt, indem wir die Zeigeraufgabe an diese Funktion übergeben haben. Wir haben das Ergebnis endlich gedruckt. Die folgende Aufgabenliste erfolgt aus dem vorherigen Programm:
Beispiel 3:
Wir haben das Ergebnis der zukünftigen Aufgabe gesammelt, indem wir die zukünftige Aufgabe im Asyncio übergeben haben.Funktion sammeln. Future bezeichnet eine Berechnung, die derzeit ausgeführt wird oder die in Zukunft geplant sein wird. Ein eventuelles Ergebnis eines asynchronen Verfahrens wird durch ein einzigartiges, auf niedrigem Niveau wartbares Objekt dargestellt.
von Asyncio importieren die Zukunft
Async def function1 (Zukunft):
print ("Funktion1 schläft 3 Sekunden lang")
Warten Sie Asyncio.Schlaf (3)
print ("Funktion1 Lösung der Zukunft")
Zukunft.Erledigt()
Zukunft.set_result ("Zukunft ist behoben")
Async def function2 (Zukunft):
print ("Funktion2 wird auf die Zukunft warten")
auf die Zukunft warten
print ("Funktion2 findet die Zukunft behoben")
Async def Main ():
Future = Future ()
Ergebnisse = AwaitaSyncio.Sammeln (Funktion2 (Zukunft), Funktion1 (Zukunft))
Wenn __name __ == "__ main___":
Asyncio.run (main ())
print ("Hauptgeräte")
Hier haben wir zum ersten Mal das Asyncio -Modul und das zukünftige Modul aus dem Asyncio aufgenommen. Dann haben wir die Coroutine als "function1" definiert und die Zukunft bestanden. Dann haben wir uns in dieser Coroutine die Schlaffunktion für die Aufhängung der Coroutine bezeichnet. Wir haben in Zukunft den Done System Call und das set_result -Systemaufrufe angerufen. Dort haben wir eine andere Korutine, die als "function2" bezeichnet wird, und es nimmt auch die Zukunft als Argument an. Wir haben in Zukunft den Befehl "Await" angerufen, um gelöst zu werden.
Danach haben wir die asynchrische Hauptdefinition, die wir als zukünftige Funktion bezeichneten, und erzielen das Ergebnis aus der Zukunft durch den Asyncio.Methode sammeln. Am Ende haben wir die Anweisung gedruckt, als die Hauptfunktion beendet wurde. Die Ausgabe des zuvor erwähnten Codes wird im folgenden Bild erfolgreich angezeigt:
Abschluss
Gathere ist stark, wie Sie sehen können. Wir können mehrere Ressourcen gleichzeitig anfordern, was ein typisches Ereignis in den Webprogrammen ist. Mit Hilfe des Python Asyncio.Sammeln Sie ein integriertes Modul, in diesem Tutorial wurde eine asynchrone Programmierung vorgestellt. Wir haben die Ergebnisse von Coroutinen, Aufgaben und Futures gesammelt. Ein gleichzeitiger Code ist möglicherweise die beste Wahl, wenn Sie die Leistung für bestimmte Aktivitäten optimieren müssen, da wir zuvor besprochen haben.Methoden sammeln.