Asynchron für Schleife in Python
Dieses Tutorial enthält alle Einzelheiten zu asynchronen for-Schleifen in Python. Wir werden die asynchrone Funktion, die asynchrone for-Schleife und die sleep-Konzepte besprechen.
Als nächstes besprechen wir die Python-Bibliothek asyncio und die Funktionen, die zum Ausführen von asynchronem Code erforderlich sind. Abschließend sehen wir uns ein paar Beispiele in Python an, um das Konzept vollständig zu verstehen.
Asynchrone Funktion in Python
Asynchrone Funktionen helfen, schwere Aufgaben (wie Batch-Programme, vielleicht sind wir daran interessiert, Prozesse im Hintergrund auszuführen) parallel zu anderen Funktionen desselben Programms auszuführen. Es ist möglich, Funktionen parallel auszuführen, wenn Funktionen nicht oder nicht vollständig voneinander abhängig sind.
Eine synchrone Funktion gibt die Kontrolle zurück, sobald die Aufgabe abgeschlossen ist, während eine asynchrone Funktion die Kontrolle zurückgibt, um andere Funktionen/Code parallel auszuführen, und nach einiger Zeit die Kontrolle zurückerhält. Auf diese Weise wird nicht nur die schwere Aufgabe erledigt, sondern auch viele andere Aufgaben parallel erledigt.
Technisch gesehen blockiert eine synchrone Funktion die Steuerung der main-Funktion, während eine asynchrone Funktion ausgeführt wird, ohne die main-Funktion zu blockieren. Auf diese Weise kann die Funktion main mehrere asynchrone Funktionen parallel ausführen.
Asynchrone for-Schleife in Python
Bei synchronen Schleifen werden sie ohne Pause/Kontrolle ausgeführt; Um sie jedoch asynchron zu machen, müssen wir sie in einer asynchronen Funktion definieren. Außerdem müssen wir in diesem Prozess für einige Zeit schlafen, um die Kontrolle über eine andere Funktion zu übernehmen.
Verwenden Sie die sleep-Anweisung
Ein Prozess/Thread/eine Funktion kann für einige Zeit schlafen gehen; Sie können es als Pause betrachten. Der Zweck ist jedoch, die Kontrolle für einige Zeit zu verlieren.
Als Ergebnis erhält eine andere Funktion die Steuerung. Nach einiger Zeit geht die Steuerung zurück und die Funktion wird fortgesetzt.
Jetzt ist es an der Zeit, sich der Implementierung in Python zuzuwenden. Wir werden den Syntaxteil Schritt für Schritt besprechen und am Ende den vollständigen Code zeigen.
Python-Bibliothek und -Funktionen
Das asyncio ist eine Bibliothek in Python, um nebenläufige Programme/Funktionen mit der async/await-Syntax zu schreiben. Das async ist das Schlüsselwort, das (um die asynchronen Funktionen zu erstellen) am Anfang jeder Funktion verwendet wird.
Die Syntax lautet:
async def fun_a(t):
Hier wird async hinzugefügt, um diese Funktion als asynchrone Funktion zu deklarieren.
Die Funktion sleep kann die Ausführung einer Coroutine für eine gewisse Zeit unterbrechen. Coroutinen sind die Prozesse/Funktionen, die während der Ausführung eine Pipeline-Struktur erstellen.
Diese Funktion überlässt die CPU freiwillig für eine andere kooperative Aufgabe durch das Schlüsselwort await. Die Syntax der Funktion sleep lautet:
await asyncio.sleep(1)
Hinweis: Das Schlüsselwort
awaitist erforderlich, um jede asynchrone Funktion aufzurufen, egal ob aus der Bibliothek oder einer benutzerdefinierten Funktion.
Das Schlüsselwort await gibt die Kontrolle an die Ereignisschleife zurück. Sie können bedenken, dass, wenn eine asynchrone Funktion mit dem Befehl await aufgerufen wird, die Anweisung sleep (innerhalb der for-Schleife) den kooperativen Prozess bis zum Schlafen steuert.
Die gather-Funktion kombiniert mehrere kooperative Prozesse (technisch eine Coroutine bildend), um als eine Einheit zu laufen. Diese Funktion gibt ein Tupel von Ergebnissen in der Reihenfolge der Funktionen zurück, die im gather-Aufruf geschrieben wurden.
Die Syntax lautet:
results = await asyncio.gather(fun_a(5), fun_b(5))
Hier erstellen wir eine Pipeline aus fun_a und fun_b, damit sie gleichzeitig ausgeführt werden können.
Die Ereignisschleife ist der Hauptbestandteil jeder asynchronen Anwendung. Ereignisschleifen führen asynchrone Funktionen aus.
Die Methode get_event_loop() prüft, ob set_event_loop noch nicht aufgerufen wurde, und erstellt eine Ereignisschleife und setzt sie als aktuell. Die Syntax lautet:
my_loop = asyncio.get_event_loop()
Wenn dieser Befehl ein zweites Mal ausgeführt wird, wenn die Schleife bereits erstellt wurde, wird er nichts tun. Beim ersten Aufruf wird jedoch keine Schleife erstellt; Daher wird eine asynchrone Schleife erstellt.
Das run_until_complete() wird verwendet, um die Ereignisschleife gleichzeitig auszuführen, wenn die von get_event_loop() zurückgegebene Schleife asynchron ist. Die Syntax lautet:
my_loop.run_until_complete(main())
Diese Anweisung führt den Code gleichzeitig aus, wenn die Funktion main asynchron ist.
Asynchroner Code
Nachdem Sie eine klare Vorstellung vom Konzept und der Python-Bibliothek haben, die zum Ausführen von asynchronen Funktionen/Routinen/Prozessen erforderlich sind, ist es an der Zeit, sich ein vollständiges Codierungsbeispiel anzusehen:
import asyncio
async def fun_a(t):
for i in range(t):
print("fun_a", end=" ")
await asyncio.sleep(1)
return 1
async def fun_b(t):
for i in range(t):
print("fun_b", end=" ")
await asyncio.sleep(1)
return 2
async def main():
results = await asyncio.gather(fun_a(5), fun_b(5))
print(results)
my_loop = asyncio.get_event_loop()
my_loop.run_until_complete(main())
In diesem Code importieren wir ganz oben (in der allerersten Zeile) die Bibliothek asyncio. Diese Bibliothek hat eine erforderliche Funktion zum Aufrufen von asynchronen Funktionen, die gleichzeitig ausgeführt werden sollen; Sie werden bereits mit Syntax besprochen.
Als nächstes haben wir zwei asynchrone Funktionen – fun_a und fun_b, die wir gleichzeitig ausführen wollen. Auch hier wollen wir asynchrone Funktionen von der Hauptfunktion aufrufen. Daher wird main auch als asynchrone Funktion erstellt.
Beachten Sie auch, dass wir 5 an unsere Funktion übergeben, um darin fünfmal Schleifen auszuführen. Später können Sie also die Ausgabe sehen und sich vorstellen, dass die Schleife nicht vollständig ausgeführt wird. jeder geht in einen Schlafzustand und übergibt die Kontrolle an die andere Funktion.
Wir wiederholen diesen Punkt nach der Ausgabe.
Innerhalb der main-Funktion haben wir die gather-Funktion aufgerufen und unsere asynchronen Funktionen übergeben, damit sie parallel laufen können. Die Funktion gather gibt ein Tupel mit zwei Werten zurück, die von unseren asynchronen Zielfunktionen zurückgegeben werden.
Wir kommen endlich zu den letzten beiden Zeilen. In der vorletzten Zeile haben wir die Funktion get_event_loop aufgerufen, um eine Schleife zu erstellen. In der letzten Zeile haben wir mit unserer Schleife die Funktion run_until_complete aufgerufen, um unsere main-Funktion asynchron auszuführen.
Die Ausgabe dieses Codes ist:
fun_a fun_b fun_a fun_b fun_a fun_b fun_a fun_b fun_a fun_b [1, 2]
Beachten Sie zunächst, dass unsere Schleifen nicht vollständig wie herkömmliche Codes ausgeführt werden. stattdessen laufen beide Schleifen gleichzeitig. Sie können das Ergebnis beider Funktionen print-Anweisungen sehen.
Schließlich ist [1, 2] das Tupel, das von der main-Funktion von unseren asynchronen Funktionen empfangen wird. 1 und 2 werden von unseren asynchronen Funktionen zurückgegeben und in der Reihenfolge angeordnet, in der wir diese Funktionen in der gather-Funktion geschrieben haben.