Asynchrone Kontextmanager

9.1 Kontextmanager

Erinnerst du dich, wie wir den Operator with benutzt haben, um den Zugriff auf eine Ressource zu kontrollieren? Damit konnten wir genau verfolgen, wann eine Ressource zu verwenden begann und wann dieser Prozess endete. Dasselbe kannst du auch für „asynchrone Ressourcen“ tun.

Asynchrone Kontextmanager (AsyncContextManager) werden zur Verwaltung von Ressourcen in der asynchronen Programmierung verwendet und stellen sicher, dass Ressourcen in asynchronen Funktionen korrekt geöffnet und geschlossen werden. Sie funktionieren ähnlich wie normale Kontextmanager, sind jedoch für die Verwendung in asynchronen Funktionen mit den Schlüsselwörtern async with gedacht.

Ich werde nicht ausführlich darüber sprechen, da du in naher Zukunft sicherlich keine eigenen asynchronen Kontextmanager erstellen wirst, und bis du dich entscheidest, dies zu tun, wirst du sowieso alles vergessen haben. Aber ich möchte dich mit dem Konzept vertraut machen.

Erstellen eines asynchronen Kontextmanagers

Asynchrone Kontextmanager werden mit den Methoden __aenter__ und __aexit__ definiert. Diese Methoden sind den Methoden __enter__ und __exit__ in normalen Kontextmanagern ähnlich, jedoch sind sie asynchron.

• __aenter__(): Asynchrone Methode, die beim Eintritt in den Kontext aufgerufen wird.
• __aexit__(exc_type, exc, tb): Asynchrone Methode, die beim Verlassen des Kontextes aufgerufen wird. Sie nimmt drei Argumente an: den Ausnahmetyp, die Ausnahme selbst und das (traceback).

Beispiel für die Erstellung eines asynchronen Kontextmanagers

import asyncio

class AsyncContextManager:
    async def __aenter__(self):
        print("Enter context")
        return self
        
    async def __aexit__(self, exc_type, exc, tb):
        print("Exit context")
        
async def main():
    async with AsyncContextManager():
        print("Inside context")
        
asyncio.run(main())

So wird dieser Code ausgeführt:

1. Die Funktion main() wird asynchron gestartet
2. Die Funktion main() beginnt mit der Ausführung
3. Ein Objekt vom Typ AsyncContextManager wird erstellt
4. Bei dem Objekt AsyncContextManager wird die Methode __aenter__() aufgerufen
5. print("Enter context") wird ausgegeben
6. Der Code print("Inside context") wird ausgeführt
7. Bei dem Objekt AsyncContextManager wird die Methode __aexit__() aufgerufen
8. Die Ausführung der Funktion main() endet

9.2 Anwendungsbeispiele

Im obigen Beispiel ist es nicht zwingend erforderlich, die asynchrone Version des Kontextmanagers zu verwenden – der Code funktioniert auch, wenn er synchron gemacht wird.

Aber ein asynchroner Manager ist notwendig, wenn innerhalb des Blocks with eine asynchrone Funktion aufgerufen wird oder der Operator await verwendet wird.

Asynchroner Kontextmanager für Dateioperationen

In diesem Beispiel wird die Bibliothek aiofiles für das asynchrone Lesen und Schreiben von Dateien verwendet. Der asynchrone Kontextmanager aiofiles.open ermöglicht das sichere Öffnen und Schließen von Dateien in einem asynchronen Kontext.

import aiofiles
import asyncio
            
async def main():
    async with aiofiles.open('example.txt', mode='w') as file:
        await file.write('Hello, world!')
            
asyncio.run(main())

Asynchroner Kontextmanager für Netzwerkoperationen

In diesem Beispiel wird die Bibliothek aiohttp für die Ausführung von asynchronen HTTP-Anfragen verwendet. Die asynchronen Kontextmanager ClientSession und session.get sorgen für eine korrekte Verwaltung der Verbindungen.

import aiohttp
import asyncio
            
async def fetch(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            return await response.text()
            
async def main():
    html = await fetch('https://example.com')
    print(html)
            
asyncio.run(main())

Asynchrone Kontextmanager bieten die automatische Verwaltung von Ressourcen, wie Dateien, Netzwerkverbindungen und anderen Ressourcen, die geöffnet und geschlossen werden müssen.

Die Methoden __aenter__ und __aexit__ ermöglichen die Ausführung asynchroner Operationen beim Eintritt und Austritt aus dem Kontext und ermöglichen die parallele Ausführung von Aufgaben. Die Verwendung asynchroner Kontextmanager hilft, Ressourcenlecks zu vermeiden und stellt sicher, dass alle Ressourcen korrekt freigegeben werden.