asyncio Python: Asynchrone Programmierung meistern

Was ist asynchrone Programmierung und warum braucht man sie?

Asynchrone Programmierung ermöglicht es, mehrere Operationen gleichzeitig auszuführen, ohne auf den Abschluss jeder einzelnen warten zu müssen. Dies ist entscheidend für die Entwicklung leistungsstarker Anwendungen, die bei langsamen Operationen nicht blockieren.

Die wichtigsten Vorteile der Asynchronität

Asynchronität ist besonders effektiv in folgenden Szenarien:

• Netzwerkanfragen (HTTP-Requests, Arbeit mit REST APIs)
• Dateisystemoperationen (Lesen und Schreiben großer Dateien)
• Datenbankinteraktionen (SQL-Abfragen, NoSQL-Operationen)
• WebSocket-Verbindungen und Echtzeitanwendungen
• Webseiten-Parsing und Data Scraping
• Verarbeitung von Nachrichtenwarteschlangen

Einführung in die asyncio-Bibliothek

asyncio ist die Standardbibliothek von Python zum Schreiben asynchronen Codes, die auf einer Ereignisschleife (Event Loop) basiert. Die Bibliothek ist seit Python 3.4 Teil der Standardbibliothek und wurde in den Versionen 3.7+ erheblich verbessert.

Schlüsselfunktionen von asyncio

Mit asyncio kannst du:

• Coroutinen erstellen und verwalten
• Mehrere asynchrone Aufgaben parallel ausführen
• Tausende gleichzeitige Verbindungen effizient verarbeiten
• Mit asynchronen Bibliotheken und Frameworks integrieren

Grundlegende Konzepte von asyncio

Coroutinen (Coroutines)

Eine Coroutine ist eine spezielle Funktion, die pausiert und später fortgesetzt werden kann. In Python werden Coroutinen mit dem Schlüsselwort async def definiert.

import asyncio

async def greet():
    print("Hallo!")
    await asyncio.sleep(1)
    print("1 Sekunde ist vergangen.")

# Coroutine starten
asyncio.run(greet())

Das Schlüsselwort await

await wird verwendet, um die Ausführung einer Coroutine zu pausieren, bis eine andere asynchrone Operation abgeschlossen ist. Dies ist der zentrale Mechanismus, um die Kontrolle an die Event Loop zurückzugeben.

async def delayed_message():
    print("Ausführung gestartet")
    await asyncio.sleep(2)
    print("Nachricht nach 2 Sekunden")

asyncio.run(delayed_message())

Event Loop (Ereignisschleife)

Die Event Loop ist das Herzstück von asyncio – der Mechanismus, der die Ausführung aller asynchronen Aufgaben steuert. Seit Python 3.7 wird empfohlen, asyncio.run() zum Starten von asynchronem Code zu verwenden.

# Moderne Methode (Python 3.7+)
asyncio.run(main_coroutine())

# Veraltete Methode (vor Python 3.7)
loop = asyncio.get_event_loop()
loop.run_until_complete(main_coroutine())

Asynchrone Aufgaben erstellen und verwalten

Parallele Aufgabenausführung

Asynchroner Code entfaltet seine volle Stärke bei der parallelen Ausführung mehrerer Aufgaben:

async def task(name, delay):
    print(f"Aufgabe {name} gestartet")
    await asyncio.sleep(delay)
    print(f"Aufgabe {name} abgeschlossen nach {delay} Sekunden")
    return f"Ergebnis von {name}"

async def main():
    # Methode 1: asyncio.gather()
    results = await asyncio.gather(
        task("A", 2),
        task("B", 1),
        task("C", 3)
    )
    print("Alle Ergebnisse:", results)

asyncio.run(main())

Aufgaben mit asyncio.create_task() erstellen

Für mehr Kontrolle über die Ausführung verwende asyncio.create_task():

async def main():
    # Aufgaben erstellen
    task_a = asyncio.create_task(task("A", 2))
    task_b = asyncio.create_task(task("B", 1))
    task_c = asyncio.create_task(task("C", 3))
    
    # Auf deren Abschluss warten
    await task_a
    await task_b
    await task_c

asyncio.run(main())

Asynchrone HTTP-Anfragen

Installation und Verwendung