Python Academy · Lezione

Context manager e iteratori asincroni

Implementi i protocolli async with e async for.

Context manager e iteratori asincroni è una lezione Python Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Python Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Python Academy include 4 lezioni in totale.

Istruzione async with

Utilizzi async with per i context manager la cui configurazione o pulizia richiede l'attesa di operazioni di I/O. L'oggetto gestito deve implementare __aenter__ e __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 e aexit

Entrambi sono coroutine. __aenter__ viene atteso all'ingresso, mentre __aexit__ viene atteso all'uscita, anche se si è verificata un'eccezione.

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 consente di scrivere context manager asincroni come funzioni generatrici asincrone.

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

Istruzione async for

async for itera su un iterabile asincrono, cioè un oggetto che implementa __aiter__ e __anext__. Ogni iterazione può comportare operazioni di 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())

Generatori asincroni

Una funzione async def che contiene yield è un generatore asincrono. Utilizzi async for per consumarlo.

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 per l'I/O asincrono sui file

La libreria aiofiles racchiude le operazioni sui file in context manager asincroni e iteratori asincroni.

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

Sessione client aiohttp

aiohttp.ClientSession è un context manager asincrono per effettuare richieste HTTP concorrenti.

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

Più context manager asincroni

Raggruppi più clausole async with su un'unica riga, utilizzando la forma tra parentesi di Python 3.10+.

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 gestisce un insieme dinamico di context manager asincroni.

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)

Test del codice asincrono con pytest-asyncio

pytest-asyncio consente di scrivere funzioni di test asincrone con il marker @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

Riepilogo del protocollo degli iteratori asincroni

Un oggetto è un iterabile asincrono se dispone di __aiter__. È un iteratore asincrono se dispone anche di __anext__. I generatori asincroni implementano automaticamente entrambi.

import asyncio

async def gen():
    yield 1
    yield 2

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

Verifica rapida

Quali metodi dunder deve implementare un oggetto per poter essere utilizzato con async with?

Riepilogo

Utilizzi async with per le risorse che richiedono una configurazione o una pulizia asincrona. Utilizzi async for per gli iterabili che producono valori in modo asincrono. I generatori asincroni semplificano la creazione di iteratori asincroni. Librerie come aiofiles e aiohttp forniscono operazioni asincrone native per file e HTTP.

Domande Frequenti

La lezione «Context manager e iteratori asincroni» è gratuita?

Sì — il testo completo di «Context manager e iteratori asincroni» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Python Academy, passa a CoddyKit PRO. Il corso Python Academy include 4 lezioni in totale.

Cosa imparerò in «Context manager e iteratori asincroni»?

Implementi i protocolli async with e async for. Eserciti Python Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Python Academy?

Non è richiesta alcuna esperienza precedente. Python Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Context manager e iteratori asincroni»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Python Academy?

Sì. Ogni lezione Python Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Python Academy