Python Academy · leksjon

Asynkrone kontekstbehandlere og iteratorer

Implementer protokollene for async with og async for.

Leksjon 3 av 413 trinn

Asynkrone kontekstbehandlere og iteratorer er en gratis leksjon i Python Academy på CoddyKit. Dette er leksjon 3 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Python Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Python Academy inneholder totalt 4 leksjoner.

async with-setningen

Bruk async with for kontekstbehandlere der oppsett eller nedrigging innebærer venting på I/O. Det administrerte objektet må implementere __aenter__ og __aexit__.

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 og aexit

Begge er korutiner. __aenter__ avventes ved inngang, og __aexit__ avventes ved utgang, selv om det oppstod et unntak.

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 lar deg skrive asynkrone kontekstbehandlere som asynkrone generatorfunksjoner.

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-setningen

async for itererer over en asynkron itererbar verdi – en verdi som implementerer __aiter__ og __anext__. Hver iterasjon kan innebære I/O.

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())

Asynkrone generatorer

En async def-funksjon som inneholder yield, er en asynkron generator. Bruk async for for å hente verdier fra den.

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 for asynkron fil-I/O

Biblioteket aiofiles pakker inn filoperasjoner i asynkrone kontekstbehandlere og asynkrone iteratorer.

# 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-klientøkt

aiohttp.ClientSession er en asynkron kontekstbehandler for å utføre samtidige HTTP-forespørsler.

# 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"))

Flere asynkrone kontekstbehandlere

Stable flere async with-ledd på én linje ved å bruke den parentesiserte formen i Python 3.10 eller nyere.

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 administrerer et dynamisk sett med asynkrone kontekstbehandlere.

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)

Testing av asynkron kode med pytest-asyncio

pytest-asyncio lar deg skrive asynkrone testfunksjoner med markøren @pytest.mark.asyncio.

# 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

Oppsummering av protokollen for asynkrone iteratorer

Et objekt er asynkront itererbart hvis det har __aiter__. Det er en asynkron iterator hvis det også har __anext__. Asynkrone generatorer implementerer begge automatisk.

import asyncio

async def gen():
    yield 1
    yield 2

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

Hurtigsjekk

Hvilke dunder-metoder må et objekt implementere for å kunne brukes med async with?

Besvar den i den interaktive leksjonen

Oppsummering

Bruk async with for ressurser som trenger asynkront oppsett eller nedrigging. Bruk async for for itererbare verdier som produserer verdier asynkront. Asynkrone generatorer gjør det enklere å opprette asynkrone iteratorer. Biblioteker som aiofiles og aiohttp tilbyr asynkrone fil- og HTTP-operasjoner.

Gratis å komme i gang

Lær deg Python med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 76
Leksjoner: 320

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Asynkrone kontekstbehandlere og iteratorer» gratis?

Ja – hele teksten i «Asynkrone kontekstbehandlere og iteratorer» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Python Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Python Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Asynkrone kontekstbehandlere og iteratorer»?

Implementer protokollene for async with og async for. Du øver på Python Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Python Academy?

Ingen tidligere erfaring er nødvendig. Python Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.

Hvor lang tid tar leksjonen «Asynkrone kontekstbehandlere og iteratorer»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Python Academy-leksjonen?

Ja. Alle Python Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Korutiner og hendelsesløkken
await, oppgaver og innsamling
Asynkrone kontekstbehandlere og iteratorer
Mønstre for asynkron I/O i produksjon

← Tilbake til Python Academy