Asyncio è un modulo in Python, introdotto in Python 3.4, che fornisce delle API per creare programmi single-threaded in maniera asincrona usando coroutines, multiplexing, e soprattutto, un loop di eventi.
```
import asyncio
async def main(): print(‘Hello’) await asyncio.sleep(1) print(‘World’)
Nell’esempio sopra, `main` è una funzione asincrona (definita con `async def`). Questo significa che `main()` è una coroutine, ovvero una versione speciale di una funzione che può essere pausa e ripresa, permettendo ad altre coroutines di eseguire nel frattempo.
`asyncio.run(main())` è l’istruzione per avviare la nostra funzione. La funzione `asyncio.run()` esegue il passaggio attraverso il loop dell’evento fino al completamento.
La linea `await asyncio.sleep(1)` sospende l’esecuzione della coroutine `main()` per 1 secondo – durante quel secondo, l’interprete di Python eseguirà altre cose.
Ricorda: le coroutines non eseguiranno nulla a meno che tu non le avvii. Nei casi in cui non si desidera avviare immediatamente una coroutine, è possibile utilizzare il metodo `ensure_future`.
```
task = asyncio.ensure_future(coro())
```
La funzione `asyncio.ensure_future()` pianifica l’esecuzione di una coroutine e restituisce un oggetto `Task`, che rappresenta l’esecuzione pianificata.
È anche possibile eseguire più operazioni asincrone in parallelo utilizzando `asyncio.gather()`.
```
import asyncio
async def myCoroutine(i): print(f“Coroutine {i} started”) await asyncio.sleep(i/10) print(f“Coroutine {i} finished”)
loop = asyncio.get_event_loop()
coroutines = [myCoroutine(i) for i in range(20)]
loop.run_until_complete(asyncio.gather(*coroutines))
loop.close()
```
In questo esempio, creiamo 20 coroutines che dormono per un certo periodo prima di dichiarare che hanno finito. Utilizziamo quindi `asyncio.gather()` per eseguirle tutte in parallelo.
Queste sono solo le basi di asyncio, il modulo consente agli sviluppatori Python di sfruttare appieno la programmazione asincrono.
