Metodi popolari di asyncio

4.1 Metodo run()

Il modulo asyncio offre molti metodi e funzioni per creare e gestire programmi asincroni. Ecco alcuni dei metodi e funzioni più popolari e frequentemente usati del modulo asyncio.

Oggi esploriamo i 4 più comuni:

• run()
• sleep()
• wait()
• gather()

E ora con i dettagli:

Metodo asyncio.run(coroutine)

Questo metodo è utilizzato per avviare un programma asincrono. È particolarmente utile quando vuoi eseguire codice asincrono da un contesto sincrono, come ad esempio dal thread principale del programma.

Il metodo asyncio.run() avvia la coroutine principale e gestisce la creazione e la chiusura del ciclo eventi. Questo metodo crea automaticamente un nuovo ciclo eventi e lo chiude al completamento della coroutine.

Firma:

asyncio.run(async_function(), *, debug=False)
        

• async_function: La coroutine che deve essere eseguita.
• debug: Parametro opzionale che abilita la modalità debug per il ciclo eventi.

Esempio di utilizzo:

import asyncio

async def main():
    print('Ciao')
    await asyncio.sleep(1)
    print('Mondo')
            
asyncio.run(main())
        

Limitazioni

Non può essere chiamato dall'interno di un altro ciclo eventi:

asyncio.run() deve essere chiamato solo da codice sincrono, poiché crea e chiude il proprio ciclo eventi. Se provi a chiamarlo dall'interno di un ciclo eventi già esistente, causerà un errore.

Adatto solo per il livello superiore:

Questo metodo è progettato per avviare il punto di ingresso principale del programma e non dovrebbe essere usato per chiamate annidate di funzioni asincrone.

4.2 Metodo sleep()

Questo metodo è utilizzato quando hai bisogno di sospendere l'esecuzione di una coroutine per un periodo di tempo specifico, senza bloccare l'esecuzione di altre coroutine.

Il metodo asyncio.sleep() nel modulo asyncio è utilizzato per sospendere l'esecuzione della coroutine corrente per un tempo determinato in secondi.

Questo metodo differisce dal metodo simile time.sleep() in quanto consente ad altri task di eseguire durante la sospensione. Questo lo rende utile per scrivere programmi asincroni che richiedono ritardi o attese senza bloccare il thread principale.

Firma:

asyncio.sleep(delay, result=None)
        

• delay: Il tempo di ritardo in secondi (può essere un numero decimale).
• result: Risultato opzionale che sarà restituito dopo il completamento del ritardo.

Esempio di applicazione:

import asyncio

async def main():
    print('Inizio dormire')
    await asyncio.sleep(2)
    print('Svegliati')
            
asyncio.run(main())
        

In questo esempio, la coroutine main viene sospesa per 2 secondi, permettendo ad altre attività di eseguire nel frattempo, poi continua e stampa "Svegliati".

4.3 Metodo wait()

Questo metodo è utile quando devi aspettare il completamento di diverse operazioni asincrone, ma desideri un controllo più fine sul processo di attesa.

Il metodo asyncio.wait() nel modulo asyncio permette di attendere il completamento di diversi task asincroni o coroutine. Può attendere il completamento di tutti i task, del primo task completato, o del completamento di un task con errore.

A differenza di gather(), il metodo wait() offre un maggiore controllo sul processo di attesa, permettendo di impostare timeout e condizioni di completamento.

Caratteristiche principali del metodo asyncio.wait()

Firma:

asyncio.wait(fs, *, timeout=None, return_when=ALL_COMPLETED)
        

Dove:

• fs: Collezione di oggetti Future o coroutine che devono essere attesi.
• timeout: Parametro opzionale, che specifica il tempo massimo di attesa in secondi. Se il tempo di attesa scade, il metodo restituisce i task che sono stati completati fino a quel momento.
• return_when: Condizione che definisce quando il metodo deve concludersi. Valori possibili:
  • ALL_COMPLETED: Il metodo restituisce il risultato quando tutti i task sono completati (predefinito).
  • FIRST_COMPLETED: Il metodo restituisce il risultato quando il primo task è completato.
  • FIRST_EXCEPTION: Il metodo restituisce il risultato quando un task è completato con un'eccezione.

Attende il completamento di diversi task o coroutine. È possibile specificare il tempo di attesa e le condizioni di completamento.

import asyncio

async def say(what, delay):
    await asyncio.sleep(delay)
    return what
            
async def main():
    task1 = asyncio.create_task(say('ciao', 1)) 
    task2 = asyncio.create_task(say('mondo', 2))
    done, pending = await asyncio.wait([task1, task2], timeout=1.5)
    for task in done:
        print(task.result())
            
asyncio.run(main())
        

Nell'esempio sopra, avvolgiamo ogni coroutine say() in un oggetto Task con la chiamata del metodo create_task(), e poi passiamo l'elenco di questi task al metodo wait(). Gli oggetti Task consentono di eseguire le coroutine in parallelo, senza aspettare il completamento di una prima di avviarne un'altra.

Il metodo wait attenderà solo un secondo e mezzo per completare i task, dopodiché restituirà una tupla di task: il primo valore della tupla conterrà i task che sono stati completati (done), il secondo quelli ancora in corso (pending).

4.4 Metodo gather()

Questo metodo è particolarmente utile quando hai bisogno di eseguire diverse operazioni asincrone in parallelo e ottenere i loro risultati come lista.

Il metodo asyncio.gather() nel modulo asyncio è utilizzato per eseguire diversi task asincroni in parallelo e restituire i loro risultati come lista. È un modo pratico per raggruppare coroutine o task e attendere il loro completamento.

Caratteristiche principali del metodo asyncio.gather()

Firma:

asyncio.gather(*coros_or_futures, return_exceptions=False)
        

Dove:

• coros_or_futures: Coroutine o oggetti Future che devono essere eseguiti.
• return_exceptions: Valore booleano che indica se le eccezioni devono essere restituite come risultati. Predefinito False.

Esempio di utilizzo

import asyncio

async def say_after(delay, what):
    await asyncio.sleep(delay)
    return what
            
async def main():
    results = await asyncio.gather(
        say_after(1, 'ciao'),
        say_after(2, 'mondo')
    )
    print(results)
            
asyncio.run(main())
        

Questo esempio mostra come asyncio.gather può essere utilizzato per eseguire in parallelo diversi task, ognuno con il proprio ritardo. I risultati di tutti i task sono restituiti come lista. A differenza di wait, gather non si limita ad aspettare il completamento dei task, ma raccoglie i risultati di tutte le coroutine, rendendolo utile per i casi in cui è importante il risultato di ogni task.