Python Academy · Lezione

Coroutine e ciclo degli eventi

Definisca coroutine con async def e le esegua con asyncio.run().

Coroutine e ciclo degli eventi è una lezione Python Academy gratuita su CoddyKit. Questa è la lezione 1 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.

Che cos'è la concorrenza?

Asyncio offre la concorrenza cooperativa: un singolo thread gestisce molte attività passando dall'una all'altra ogni volta che una è in attesa dell'I/O.

# Traditional: blocking I/O holds the whole thread
# Asyncio: while waiting for I/O, run other coroutines

import asyncio

async def main():
    print("Hello")
    await asyncio.sleep(1)   # yield control
    print("World")

asyncio.run(main())

async def — Funzioni coroutine

Le funzioni definite con async def sono funzioni coroutine. Chiamarle restituisce un oggetto coroutine; vengono eseguite solo quando si usa await o vengono pianificate.

import asyncio

async def greet(name):
    return f"Hello, {name}"

result = asyncio.run(greet("Alice"))
print(result)   # Hello, Alice

Il ciclo degli eventi

Il ciclo degli eventi gestisce l'esecuzione delle coroutine. asyncio.run(coro) crea un nuovo ciclo degli eventi, esegue la coroutine fino al completamento e chiude il ciclo.

import asyncio

async def compute():
    await asyncio.sleep(0)
    return 42

value = asyncio.run(compute())
print(value)   # 42

# For advanced use:
loop = asyncio.new_event_loop()
result = loop.run_until_complete(compute())
loop.close()

await mette in pausa l'esecuzione

await expr sospende la coroutine corrente finché expr (un'altra coroutine o un future) non viene completato. Nel frattempo, il ciclo degli eventi esegue altre attività.

import asyncio

async def task(name, delay):
    print(f"{name} starting")
    await asyncio.sleep(delay)
    print(f"{name} done")

async def main():
    await task("A", 2)
    await task("B", 1)   # sequential here

asyncio.run(main())

asyncio.sleep()

asyncio.sleep(seconds) sospende la coroutine corrente per il tempo indicato senza bloccare il ciclo degli eventi.

import asyncio

async def heartbeat():
    while True:
        print("ping")
        await asyncio.sleep(1)

# asyncio.run(heartbeat())  # runs forever

asyncio.run() come punto di ingresso

asyncio.run(coro) è il punto di ingresso standard di livello superiore. Non lo chiami mai dall'interno di un ciclo degli eventi in esecuzione.

import asyncio

async def main():
    print("running")

if __name__ == "__main__":
    asyncio.run(main())

Verificare se ci si trova in un ciclo degli eventi

Utilizzi asyncio.get_running_loop() per rilevare se un ciclo è già in esecuzione (solleva RuntimeError se non lo è).

import asyncio

async def inner():
    loop = asyncio.get_running_loop()
    print(f"Loop: {loop}")

asyncio.run(inner())

Eseguire codice bloccante

Esegua codice vincolato dalla CPU o con I/O bloccante senza bloccare il ciclo degli eventi usando loop.run_in_executor(None, func, *args).

import asyncio, time

def blocking():
    time.sleep(2)
    return "done"

async def main():
    loop = asyncio.get_event_loop()
    result = await loop.run_in_executor(None, blocking)
    print(result)

asyncio.run(main())

Concatenamento delle coroutine

Le coroutine possono eseguire await su altre coroutine, creando una catena. Il controllo scende lungo la catena e risale man mano che ogni livello viene completato.

import asyncio

async def fetch_data():
    await asyncio.sleep(1)
    return {"value": 42}

async def process():
    data = await fetch_data()
    return data["value"] * 2

async def main():
    result = await process()
    print(result)   # 84

asyncio.run(main())

Identificare le coroutine

Utilizzi asyncio.iscoroutine(obj) o asyncio.iscoroutinefunction(func) per esaminare le funzioni asincrone durante l'esecuzione.

import asyncio

async def my_coro():
    pass

print(asyncio.iscoroutinefunction(my_coro))   # True
coro = my_coro()
print(asyncio.iscoroutine(coro))              # True
coro.close()   # clean up the un-awaited coroutine

Modalità di debug di asyncio

Abiliti la modalità di debug per rilevare coroutine senza await, callback lente e altri problemi: imposti PYTHONASYNCIODEBUG=1 oppure passi debug=True a asyncio.run.

import asyncio

async def main():
    pass

asyncio.run(main(), debug=True)

# Or:
# PYTHONASYNCIODEBUG=1 python script.py

Verifica rapida

Che cosa fa asyncio.run(coro)?

Riepilogo

Definisca le coroutine con async def, le esegua con asyncio.run() e le sospenda con await. Il ciclo degli eventi pianifica le coroutine in modo cooperativo, eseguendo le altre mentre una è in attesa dell'I/O.

Domande Frequenti

La lezione «Coroutine e ciclo degli eventi» è gratuita?

Sì — il testo completo di «Coroutine e ciclo degli eventi» è 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 «Coroutine e ciclo degli eventi»?

Definisca coroutine con async def e le esegua con asyncio.run(). 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 1 di 4.

Quanto tempo richiede la lezione «Coroutine e ciclo degli eventi»?

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