Uso de import asyncio en Python: aprende los mejores trucos

A que alguna vez te has sentido atrapado esperando a que una tarea lenta termine para que tu código pueda seguir ejecutándose. Es frustrante, lo sabemos, pero es algo bastante común en programación, principalmente cuando trabajamos con operaciones de entrada/salida, como por ejemplo llamadas a bases de datos o consultas en APIs. Pero no te preocupes, que Python tiene una solución muy simple: asyncio y su importación, import asyncio. El día de hoy te queremos mostrar en qué consiste este módulo de import asyncio y cómo funciona.

¿Qué es import asyncio?

El asyncio es una biblioteca que viene integrada en Python y que nos permite trabajar con programación asíncrona gracias a la sintaxis async/await. Import asyncio es la forma en la que se importa este módulo para poder ser usado dentro de Python. Con el módulo de import asyncio puedes manejar varias tareas al mismo tiempo sin tener que bloquear la ejecución del programa, lo que bridna mayor velocidad y eficiencia en aplicaciones como servidores web, gestión de colas de tareas o comunicación en redes.

¿Por qué asyncio es especial?

Es simple, porque:

• Permite ejecutar múltiples tareas al mismo tiempo sin usar hilos o procesos adicionales.
• Está diseñado para operaciones de entrada/salida, como leer archivos o conectarte a un servidor remoto.
• Ofrece APIs de alto y bajo nivel para controlar bucles de eventos, tareas y subprocesos.

Con asyncio puedes olvidarte de esos tediosos bloqueos en tu código y centrarte en escribir soluciones rápidas y que funcionen.

¿Cómo funciona asyncio?

El corazón de asyncio es denominado bucle de elementos. Este es un bucle que actua como director de orquesta, pues gestiona las tareas y asegura que cada una se ejecute en el momento adecuado. Veamos cómo puedes usar este asyncio en tu código:

• Corutinas: el pilar de asyncio: Las corutinas son funciones que pueden pausarse y reanudarse en diferentes puntos y así se permite que el programa pueda realizar otas tareas mientras espera. Puedes definir una corutina con la palabra clave async, del siguiente modo:

import asyncio

async def main():
    print("Hola...")
    await asyncio.sleep(2)
    print("...mundo!")

asyncio.run(main())

En este código la ejecución se pausa con await asyncio.sleep(2) para simular una tarea que tarda 2 segundos. Mientras tanto, el bucle de eventos puede gestionar otras tareas.

• Ejecutando múltiples tareas con gather: Si lo que quieres ejecutar varias tareas al mismo tiempo, el asyncio.gather es una buena opción. Así puedes usarlo:

import asyncio

async def tarea(numero):
    print(f"Tarea {numero} iniciada")
    await asyncio.sleep(2)
    print(f"Tarea {numero} completada")

async def main():
    await asyncio.gather(tarea(1), tarea(2), tarea(3))

asyncio.run(main())

Aquí las tres tareas se ejecutan en paralelo,esto nos ahorra tiempo y mejora la eficiencia del programa.

¿Quieres algunos trucos para usar en import asyncio? ¡Te los tenemos!

• Uso de colas para tareas asíncronas: Las colas son una forma viable para gestionar t areas pendientes. Con asyncio puedes crear y manejar colas asíncronas fácilmente:

import asyncio

async def productor(cola):
    for i in range(5):
        print(f"Produciendo {i}")
        await cola.put(i)
        await asyncio.sleep(1)

async def consumidor(cola):
    while True:
        item = await cola.get()
        print(f"Consumiendo {item}")
        cola.task_done()

async def main():
    cola = asyncio.Queue()
    await asyncio.gather(productor(cola), consumidor(cola))

asyncio.run(main())

En este ejemplo, un productor agrega elementos a la cola mientras un consumidor los procesa simultáneamente.

• Controlando subprocesos con asyncio: Si requieres ejecutar tareas en subprocesos, así lo puedes hacer con asyncio.to_thread:

Si necesitas ejecutar tareas en subprocesos, puedes hacerlo con asyncio.to_thread:

import asyncio

def tarea_pesada(numero):
    print(f"Procesando {numero}...")
    return numero * 2

async def main():
    resultado = await asyncio.to_thread(tarea_pesada, 5)
    print(f"Resultado: {resultado}")

asyncio.run(main())

Esto es útil para integrar operaciones bloqueantes en tu flujo asíncrono.

Algunos buenos consejos a seguir para su uso:

1. Siempre usa asyncio.run para iniciar tu programa: Esto asegura que el bucle de eventos se gestione correctamente.
2. Evita mezclar código síncrono y asíncrono: Usa herramientas como asyncio.to_thread para manejar código bloqueante.
3. Controla excepciones en tareas: Usa try y except para manejar errores dentro de tus corutinas.
4. Cierra el bucle de eventos al terminar: Esto es especialmente importante en aplicaciones complejas con múltiples recursos.

¿Te gustaría seguir aprendiendo sobre Python y otros lenguajes? Únete a nuestro bootcamp en programación para principiantes, en donde te daremos las bases teóricas y prácticas de diferentes lenguajes y temáticas que te permitirán escalar en el mercado laboral de manera más fácil. ¡No te pierdas esta gran oportunidad y únete a la industria tecnológica, la más prolífica del sector!