0Pricing
Python Academy · Lektion

Asynchrone Kontextmanager und Iteratoren

Implementieren Sie die Protokolle async with und async for.

Asynchrone Kontextmanager und Iteratoren ist eine kostenlose Python Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Python Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Python Academy-Kurs umfasst insgesamt 4 Lektionen.

async with-Anweisung

Verwenden Sie async with für Kontextmanager, deren Einrichtung oder Abbau das Warten auf E/A-Vorgänge erfordert. Das verwaltete Objekt muss __aenter__ und __aexit__ implementieren.

import asyncio

class AsyncFile:
    async def __aenter__(self):
        print("open")
        return self
    async def __aexit__(self, *args):
        print("close")

async def main():
    async with AsyncFile() as f:
        print("using")

asyncio.run(main())

__aenter__ und __aexit__

Beide sind Koroutinen. Beim Eintritt wird __aenter__ erwartet, beim Verlassen __aexit__ – auch wenn eine Ausnahme aufgetreten ist.

import asyncio

class DBSession:
    async def __aenter__(self):
        self.conn = await async_connect()
        return self.conn

    async def __aexit__(self, exc_type, exc_val, exc_tb):
        if exc_type:
            await self.conn.rollback()
        else:
            await self.conn.commit()
        await self.conn.close()
        return False

@asynccontextmanager

contextlib.asynccontextmanager ermöglicht es Ihnen, asynchrone Kontextmanager als asynchrone Generatorfunktionen zu schreiben.

from contextlib import asynccontextmanager
import asyncio

@asynccontextmanager
async def managed_resource():
    print("acquire")
    try:
        yield {"status": "ready"}
    finally:
        print("release")

async def main():
    async with managed_resource() as r:
        print(r["status"])

asyncio.run(main())

async for-Anweisung

async for durchläuft ein asynchrones Iterable – also ein Objekt, das __aiter__ und __anext__ implementiert. Jede Iteration kann E/A-Vorgänge umfassen.

import asyncio

class AsyncCounter:
    def __init__(self, n): self.n, self.i = n, 0
    def __aiter__(self): return self
    async def __anext__(self):
        if self.i >= self.n: raise StopAsyncIteration
        await asyncio.sleep(0)
        self.i += 1
        return self.i

async def main():
    async for val in AsyncCounter(3):
        print(val)

asyncio.run(main())

Asynchrone Generatoren

Eine async def-Funktion, die yield enthält, ist ein asynchroner Generator. Verwenden Sie async for, um ihn zu durchlaufen.

import asyncio

async def ticker(n):
    for i in range(n):
        await asyncio.sleep(1)
        yield i

async def main():
    async for val in ticker(3):
        print(val)   # 0, 1, 2 with 1-s pauses

asyncio.run(main())

aiofiles für asynchrone Datei-E/A

Die Bibliothek aiofiles kapselt Dateioperationen in asynchronen Kontextmanagern und asynchronen Iteratoren.

# pip install aiofiles
import aiofiles, asyncio

async def main():
    async with aiofiles.open("data.txt", "r") as f:
        async for line in f:
            print(line.strip())

aiohttp-Client-Sitzung

aiohttp.ClientSession ist ein asynchroner Kontextmanager zum Ausführen gleichzeitiger HTTP-Anfragen.

# pip install aiohttp
import aiohttp, asyncio

async def fetch(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as resp:
            return await resp.json()

asyncio.run(fetch("https://api.example.com/data"))

Mehrere asynchrone Kontextmanager

Reihen Sie mehrere async with-Klauseln in einer Zeile aneinander (Python-3.10+-Form mit Klammern).

import asyncio

async def main():
    async with (
        open_db() as db,
        open_cache() as cache,
    ):
        data = await db.fetch("SELECT 1")
        await cache.set("key", data)

AsyncExitStack

contextlib.AsyncExitStack verwaltet eine dynamische Menge asynchroner Kontextmanager.

from contextlib import AsyncExitStack
import asyncio

async def main():
    async with AsyncExitStack() as stack:
        conn1 = await stack.enter_async_context(connect("db1"))
        conn2 = await stack.enter_async_context(connect("db2"))
        await process(conn1, conn2)

Asynchronen Code mit pytest-asyncio testen

Mit pytest-asyncio können Sie asynchrone Testfunktionen mit dem Marker @pytest.mark.asyncio schreiben.

# pip install pytest-asyncio
import pytest, asyncio

async def fetch(): return 42

@pytest.mark.asyncio
async def test_fetch():
    result = await fetch()
    assert result == 42

Zusammenfassung des Protokolls für asynchrone Iteratoren

Ein Objekt ist ein asynchrones Iterable, wenn es __aiter__ besitzt. Es ist ein asynchroner Iterator, wenn es zusätzlich __anext__ besitzt. Asynchrone Generatoren implementieren automatisch beide Methoden.

import asyncio

async def gen():
    yield 1
    yield 2

async def main():
    g = gen()
    print(await g.__anext__())   # 1
    print(await g.__anext__())   # 2

Wissenscheck

Welche Dunder-Methoden muss ein Objekt implementieren, um mit async with verwendet werden zu können?

Zusammenfassung

Verwenden Sie async with für Ressourcen, die eine asynchrone Einrichtung oder einen asynchronen Abbau benötigen. Verwenden Sie async for für Iterables, die Werte asynchron liefern. Asynchrone Generatoren vereinfachen die Erstellung asynchroner Iteratoren. Bibliotheken wie aiofiles und aiohttp stellen asynchrone Datei- und HTTP-Operationen bereit.

Häufig gestellte Fragen

Ist die Lektion „Asynchrone Kontextmanager und Iteratoren“ kostenlos?

Ja — der vollständige Text von „Asynchrone Kontextmanager und Iteratoren“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Python Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Python Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Asynchrone Kontextmanager und Iteratoren“?

Implementieren Sie die Protokolle async with und async for. Du übst Python Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Python Academy zu starten?

Keine Vorkenntnisse erforderlich. Python Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Asynchrone Kontextmanager und Iteratoren“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Python Academy-Lektion Code schreiben und ausführen?

Ja. Jede Python Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Coroutinen und die Ereignisschleife
  2. await, Tasks und Zusammenfassen
  3. Asynchrone Kontextmanager und Iteratoren
  4. Asynchrone I/O-Muster in der Praxis
← Zurück zu Python Academy