Beliebte asyncio-Methoden

4.1 Methode run()

Das Modul asyncio bietet viele Methoden und Funktionen zur Erstellung und Verwaltung von asynchronen Programmen. Hier sind einige der beliebtesten und am häufigsten verwendeten Methoden und Funktionen des asyncio-Moduls.

Heute schauen wir uns die 4 häufigsten an:

• run()
• sleep()
• wait()
• gather()

Und nun die Details:

Methode asyncio.run(coroutine)

Diese Methode wird verwendet, um ein asynchrones Programm zu starten. Sie ist besonders nützlich, wenn du asynchronen Code aus einem synchronen Kontext heraus ausführen möchtest, zum Beispiel aus dem Hauptthread des Programms.

Die Methode asyncio.run() startet die Haupt-Coroutine und verwaltet die Erstellung und das Schließen des Ereignisloops. Diese Methode erstellt automatisch einen neuen Ereignisloop und beendet ihn, wenn die Coroutine abgeschlossen ist.

Signatur:

asyncio.run(async_function(), *, debug=False)
        

• async_function: Die Coroutine, die ausgeführt werden soll.
• debug: Optionaler Parameter, der den Debug-Modus für den Ereignisloop aktiviert.

Beispielverwendung:

import asyncio

async def main():
    print('Hello')
    await asyncio.sleep(1)
    print('World')
            
asyncio.run(main())
        

Einschränkungen

Kann nicht innerhalb eines anderen Ereignisloops aufgerufen werden:

asyncio.run() sollte nur aus synchronem Code aufgerufen werden, da es seinen eigenen Ereignisloop erstellt und beendet. Der Versuch, es innerhalb eines bereits existierenden Ereignisloops aufzurufen, führt zu einem Fehler.

Nur für die oberste Ebene geeignet:

Diese Methode ist für den Start des Haupteinstiegs in das Programm gedacht und sollte nicht für verschachtelte Aufrufe von asynchronen Funktionen verwendet werden.

4.2 Methode sleep()

Diese Methode wird verwendet, wenn du die Ausführung einer Coroutine für eine bestimmte Zeit anhalten möchtest, ohne die Ausführung anderer Coroutines zu blockieren.

Die Methode asyncio.sleep() im Modul asyncio wird verwendet, um die Ausführung der aktuellen Coroutine für eine festgelegte Anzahl von Sekunden zu unterbrechen.

Diese Methode unterscheidet sich von der ähnlichen time.sleep()-Methode dadurch, dass sie anderen Aufgaben ermöglicht, während der Unterbrechung ausgeführt zu werden. Dadurch ist sie nützlich für das Schreiben von asynchronen Programmen, die Verzögerungen oder Wartezeiten erfordern, ohne den Hauptthread zu blockieren.

Signatur:

asyncio.sleep(delay, result=None)
        

• delay: Die Verzögerungszeit in Sekunden (kann eine Gleitkommazahl sein).
• result: Optionales Ergebnis, das nach Abschluss der Verzögerung zurückgegeben wird.

Anwendungsbeispiel:

import asyncio

async def main():
    print('Start sleeping')
    await asyncio.sleep(2)
    print('Wake up')
            
asyncio.run(main())
        

In diesem Beispiel wird die Coroutine main für 2 Sekunden unterbrochen, sodass andere Aufgaben in dieser Zeit ausgeführt werden können. Anschließend wird sie fortgesetzt und druckt "Wake up".

4.3 Methode wait()

Diese Methode ist nützlich, wenn du auf den Abschluss mehrerer asynchroner Operationen warten musst, aber mehr Kontrolle über den Warteprozess haben möchtest.

Die Methode asyncio.wait() im Modul asyncio ermöglicht es, auf den Abschluss mehrerer asynchroner Aufgaben oder Coroutines zu warten. Man kann auf das Ende aller Aufgaben, die erste abgeschlossene Aufgabe oder das Ende einer beliebigen Aufgabe mit einem Fehler warten.

Im Gegensatz zu gather() bietet die Methode wait() mehr Kontrolle über den Warteprozess, indem man Timeout und Abschlussbedingungen festlegen kann.

Hauptmerkmale der Methode asyncio.wait()

Signatur:

asyncio.wait(fs, *, timeout=None, return_when=ALL_COMPLETED)
        

Wo:

• fs: Sammlung von Future-Objekten oder Coroutines, auf die gewartet werden soll.
• timeout: Optionaler Parameter, der die maximale Wartezeit in Sekunden angibt. Wenn die Zeit abgelaufen ist, gibt die Methode die Aufgaben zurück, die bis zu diesem Zeitpunkt abgeschlossen wurden.
• return_when: Bedingung, die angibt, wann die Methode beendet werden soll. Mögliche Werte:
  • ALL_COMPLETED: Die Methode gibt das Ergebnis zurück, wenn alle Aufgaben abgeschlossen sind (Standard).
  • FIRST_COMPLETED: Die Methode gibt das Ergebnis zurück, wenn die erste Aufgabe abgeschlossen ist.
  • FIRST_EXCEPTION: Die Methode gibt das Ergebnis zurück, wenn eine beliebige Aufgabe mit einer Ausnahme abgeschlossen ist.

Wartet auf den Abschluss mehrerer Aufgaben oder Coroutines. Es kann Wartezeiten und Abschlussbedingungen angeben.

import asyncio

async def say(what, delay):
    await asyncio.sleep(delay)
    return what
            
async def main():
    task1 = asyncio.create_task(say('hello', 1)) 
    task2 = asyncio.create_task(say('world', 2))
    done, pending = await asyncio.wait([task1, task2], timeout=1.5)
    for task in done:
        print(task.result())
            
asyncio.run(main())
        

Im obigen Beispiel wird jede Coroutine say() mit einem Task-Objekt umwickelt, indem die Methode create_task() aufgerufen wird. Anschließend wird eine Liste dieser Tasks an die Methode wait() übergeben. Task-Objekte ermöglichen es, Coroutines parallel auszuführen, ohne darauf zu warten, dass eine abgeschlossen ist, bevor die nächste gestartet wird.

Die Methode wait wird nur anderthalb Sekunden warten, bevor sie ein Tuple von Tasks zurückgibt: Der erste Wert des Tuples enthält die Aufgaben, die abgeschlossen wurden (done), der zweite - diejenigen, die sich noch im Prozess befinden (pending).

4.4 Methode gather()

Diese Methode ist besonders nützlich, wenn du mehrere asynchrone Operationen parallel starten und deren Ergebnisse als Liste erhalten möchtest.

Die Methode asyncio.gather() im Modul asyncio wird verwendet, um mehrere asynchrone Aufgaben parallel auszuführen und deren Ergebnisse als Liste zurückzugeben. Dies ist eine praktische Möglichkeit, Coroutines oder Aufgaben zu gruppieren und deren Abschluss abzuwarten.

Hauptmerkmale der Methode asyncio.gather()

Signatur:

asyncio.gather(*coros_or_futures, return_exceptions=False)
        

Wo:

• coros_or_futures: Coroutines oder Future-Objekte, die ausgeführt werden sollen.
• return_exceptions: Boolean-Wert, der angibt, ob Ausnahmen als Ergebnisse zurückgegeben werden sollen. Standardmäßig False.

Beispielverwendung:

import asyncio

async def say_after(delay, what):
    await asyncio.sleep(delay)
    return what
            
async def main():
    results = await asyncio.gather(
        say_after(1, 'hello'),
        say_after(2, 'world')
    )
    print(results)
            
asyncio.run(main())
        

Dieses Beispiel zeigt, wie asyncio.gather verwendet werden kann, um mehrere Aufgaben parallel auszuführen, von denen jede eine eigene Verzögerung hat. Die Ergebnisse aller Aufgaben werden als Liste zurückgegeben. Im Gegensatz zu wait wartet gather nicht nur auf den Abschluss der Aufgaben, sondern sammelt auch die Ergebnisse aller Coroutines, was es praktisch macht, wenn das Ergebnis jeder Aufgabe wichtig ist.