Métodos populares de asyncio

4.1 Método run()

El módulo asyncio proporciona muchos métodos y funciones para crear y gestionar programas asíncronos. Aquí te van algunos de los métodos y funciones más populares y frecuentemente usados del módulo asyncio.

Hoy vamos a ver los 4 más comunes:

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

Ahora con más detalles:

Método asyncio.run(coroutine)

Este método se usa para iniciar un programa asíncrono. Es especialmente útil cuando quieres ejecutar código asíncrono desde un contexto sincrónico, por ejemplo, desde el hilo principal del programa.

El método asyncio.run() inicia la corutina principal y gestiona la creación y clausura del ciclo de eventos. Este método automáticamente crea un nuevo ciclo de eventos y lo termina una vez que la corutina ha finalizado.

Signatura:

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

• async_function: La corutina que necesitas ejecutar.
• debug: Parámetro opcional que activa el modo de depuración para el ciclo de eventos.

Ejemplo de uso:

import asyncio

async def main():
    print('Hello')
    await asyncio.sleep(1)
    print('World')
            
asyncio.run(main())
        

Limitaciones

No puede ser llamado desde otro ciclo de eventos:

asyncio.run() debe ser llamado solo desde código sincrónico, ya que crea y termina su propio ciclo de eventos. Intentar llamarlo desde un ciclo de eventos ya existente lanzará un error.

Adecuado solo para el nivel superior:

Este método está diseñado para iniciar la entrada principal del programa y no debe usarse para llamadas anidadas de funciones asíncronas.

4.2 Método sleep()

Este método se usa cuando necesitas suspender la ejecución de una corutina por un tiempo determinado, sin bloquear la ejecución de otras corutinas.

El método asyncio.sleep() en el módulo asyncio se utiliza para pausar la ejecución de la corutina actual por un número dado de segundos.

Este método se diferencia del método time.sleep() en que permite que otras tareas se ejecuten durante la pausa. Esto lo hace útil para escribir programas asíncronos que requieren demoras o esperas sin bloquear el hilo principal.

Signatura:

asyncio.sleep(delay, result=None)
        

• delay: Tiempo de demora en segundos (puede ser un número decimal).
• result: Resultado opcional que será devuelto tras la finalización de la demora.

Ejemplo de aplicación:

import asyncio

async def main():
    print('Start sleeping')
    await asyncio.sleep(2)
    print('Wake up')
            
asyncio.run(main())
        

En este ejemplo, la corutina main se suspende por 2 segundos, permitiendo que otras tareas se ejecuten en ese tiempo, luego continúa y muestra "Wake up".

4.3 Método wait()

Este método es útil cuando necesitas esperar la finalización de varias operaciones asíncronas, pero quieres tener un control más fino sobre el proceso de espera.

El método asyncio.wait() en el módulo asyncio permite esperar la finalización de varias tareas asíncronas o corutinas. Puedes esperar la finalización de todas las tareas, la primera tarea completada o la finalización de cualquier tarea con error.

A diferencia de gather(), el método wait() da más control sobre el proceso de espera, permitiendo establecer un timeout y condiciones de finalización.

Características principales del método asyncio.wait()

Signatura:

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

Donde:

• fs: Colección de objetos Future o corutinas que necesitas esperar.
• timeout: Parámetro opcional, que especifica el tiempo máximo de espera en segundos. Si el tiempo de espera se agota, el método devuelve las tareas que se completaron hasta ese momento.
• return_when: Condición que determina cuándo debe finalizar el método. Valores posibles:
  • ALL_COMPLETED: El método devuelve el resultado, cuando todas las tareas están completadas (por defecto).
  • FIRST_COMPLETED: El método devuelve el resultado, cuando la primera tarea está completada.
  • FIRST_EXCEPTION: El método devuelve el resultado, cuando cualquier tarea completa con una excepción.

Espera la finalización de varias tareas o corutinas. Puedes especificar el tiempo de espera y las condiciones de finalización.

import asyncio

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

En el ejemplo anterior envolvemos cada corutina say() en un objeto Task usando el método create_task(), y luego pasamos la lista de estas tareas al método wait(). Los objetos Task permiten ejecutar corutinas en paralelo, sin esperar que una termine antes de iniciar otra.

El método wait esperará a que se completen las tareas solo durante un segundo y medio, después de lo cual devolverá una tupla de tareas: el primer valor de la tupla contendrá las tareas que se completaron (done), la segunda las que aún están en proceso (pending).

4.4 Método gather()

Este método es especialmente útil cuando necesitas ejecutar varias operaciones asíncronas en paralelo y obtener sus resultados como una lista.

El método asyncio.gather() en el módulo asyncio se utiliza para ejecutar varias tareas asíncronas en paralelo y devolver sus resultados como una lista. Es una forma conveniente de agrupar corutinas o tareas y esperar a que finalicen.

Características principales del método asyncio.gather()

Signatura:

asyncio.gather(*coros_or_futures, return_exceptions=False)
        

Donde:

• coros_or_futures: Corutinas u objetos Future que deben ser ejecutados.
• return_exceptions: Valor booleano que indica si las excepciones deben devolverse como resultados. Por defecto es False.

Ejemplo de uso

import asyncio

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

Este ejemplo muestra cómo asyncio.gather puede ser usado para ejecutar en paralelo varias tareas, cada una con su propio retraso. Los resultados de todas las tareas se devuelven como una lista. A diferencia de wait, gather no solo espera a que las tareas terminen, sino que también recopila los resultados de todas las corutinas, lo que lo hace conveniente para los casos en que el resultado de cada tarea es importante.