Sincronía y Concurrencia en Python: Teoría y Práctica

Resumen

¿Cómo realizar operaciones asíncronas en programación?

En el mundo de la programación, la ejecución asíncrona de tareas es una técnica esencial que permite realizar múltiples operaciones de manera eficiente. Al abordar la programación asíncrona, podemos mejorar el rendimiento de nuestras aplicaciones y garantizar que se mantenga responsiva incluso en tareas que consumen tiempo. Este artículo te guiará en la comprensión y aplicación de operaciones asíncronas, basándose en un transcript de una clase práctica.

¿Qué es una operación asíncrona?

Una operación asíncrona es aquella que permite que un programa continúe ejecutándose sin esperar a que la operación se complete. En lugar de bloquear el flujo de ejecución, el código asíncrono sigue adelante y responde al finalizar la tarea inicial a través de callbacks, promesas o async/await en JavaScript.

Ejemplo de función asíncrona con `async` y `await`

A continuación, te mostramos un fragmento de código en JavaScript que ilustra cómo se puede implementar una operación asíncrona:

async function procesarOrden(orden) {
  try {
    const resultado = await realizarOperacionAsincrona(orden);
    console.log('Resultado:', resultado);
  } catch (error) {
    console.error('Error procesando la orden:', error);
  }
}

En este código, realizarOperacionAsincrona es una función ficticia que promete completar una tarea en el futuro, y await se utiliza para esperar a que dicha promesa se resuelva antes de seguir adelante.

¿Por qué es importante la programación asíncrona?

La programación asíncrona es crucial para manipular tareas que pueden tardar en completarse, como operaciones de I/O, sin detener el funcionamiento general de la aplicación. Esto es particularmente esencial en aplicaciones web, donde la experiencia del usuario debe ser prioritaria.

Beneficios de la programación asíncrona

Eficiencia: Permite realizar otras operaciones mientras se espera a que se completen tareas largas.
Mejora del rendimiento: Optimiza el uso de recursos, especialmente en aplicaciones de red y sistemas distribuidos.
Interactividad: Mantiene la aplicación responsiva, mejorando la experiencia del usuario.

¿Cómo verificar la existencia de artículos en inventario?

Un método típico para manejar la verificación en inventarios utilizando operaciones asíncronas es consultar una base de datos o una API y responder basándose en la disponibilidad de artículos.

Código de ejemplo para verificar inventario

Puedes utilizar la siguiente estructura para manejar una lista de inventario:

async function verificarInventario(articulo) {
  const inventario = await obtenerInventario();
  return inventario.includes(articulo);
}

async function obtenerInventario() {
  // Esta función simula obtener datos de una base de datos o API
  return ['articulo1', 'articulo2', 'articulo3'];
}

Aquí, obtenerInventario simula una llamada asíncrona para recuperar información sobre el inventario disponible. verificarInventario comprueba si un artículo concreto existe en el inventario obtenido.

Consejos prácticos para implementar operaciones asíncronas

Mantén el código limpio: Evita el uso de multiple callbacks anidados, utiliza promesas o async/await para mantener la claridad en el flujo del código.
Manejo de errores: Siempre implementa un manejo adecuado de excepciones en funciones asíncronas utilizando try/catch.
Optimiza las llamadas: Minimiza las llamadas asíncronas innecesarias agrupándolas cuando sea posible.

Estos consejos no solo te ayudarán a implementar operaciones asíncronas de manera efectiva, sino que también mejorarán la estructura y el rendimiento de tus aplicaciones. Al dominar la programación asíncrona, estarás mejor preparado para enfrentar el desarrollo de aplicaciones modernas y complejas.

Iván Andrés López Gómez

student•

En este código solo agregue una función logger que ayuda a visualizar mejor cada proceso por orden.

import asyncio, multiprocessing, time, random
from enum import Enum

class Status(Enum):
    START = 'START 🔘'
    PENDING = 'PENDING 🚧'
    CANCELED = 'CANCELED ❌'
    FINISHED = 'FINISHED 🎉'

def logger(order_id: int, status: Status, message: str):
     print(f'[order_id: {order_id}], status: {status.value}, message: {message}')

async def check_inventory(order_id, item):
    logger(order_id, Status.START, f'Verificado Inventario para item {item}')
    await asyncio.sleep(random.randint(3,6))
    
    logger(order_id, Status.START, f'Inventario verificado para {item}')
    print("------------------------------------------------------------------------------------")
    #simulando disponibilidad
    return [item, random.choice([True, False])]

async def process_payment(order_id):
    logger(order_id, Status.PENDING, 'Enviando a procesar pago')
    await asyncio.sleep(random.randint(2,3))
    logger(order_id, Status.FINISHED, 'Pago procesado correctamente')
    print("------------------------------------------------------------------------------------")
    return True

#Funcion intensiva en CPU para calcular el costo total del pedido
def calculate_total(order_id, items):
    logger(order_id, Status.START, f'Calculado el costo total para {len(items)} articulos..')
    time.sleep(5)
    total = sum(item['price'] for item in items)
    logger(order_id, Status.START, f'Costo total de la orden es: {total}')
    print("------------------------------------------------------------------------------------")
    return total

async def process_order(order_id, items):
    print(f'[order_id: {order_id}], status: START, message: iniciando proceso')
    logger(order_id, Status.START, 'Iniciando proceso')
    inventory_checks = [check_inventory(order_id, item['name']) for item in items]
    inventory_result = await asyncio.gather(*inventory_checks)
    result = [item for item in inventory_result if item[1] == False]
    if result:
        logger(order_id, Status.CANCELED, f'Productos {result[0][0]} no disponibles')
        return
        
    with multiprocessing.Pool() as pool:
        total = pool.apply(calculate_total, (order_id, items,))

    #procesar pago 
    payment_result = await process_payment(order_id)
    
    if payment_result:
        logger(order_id, Status.FINISHED, f'Procesado correctamente total {total}')
    else:
        logger(order_id, Status.CANCELED, f'El pago no puedo ser completado')
    print("------------------------------------------------------------------------------------")
        
async def main():
    orders = [
        {'order_id': 1, 'items': [{'name': 'Laptop', 'price': 1000}, {'name': 'Mouse', 'price': 50}]},
        {'order_id': 2, 'items': [{'name': 'Teclado', 'price': 80}, {'name': 'Monitor', 'price': 300}]},
        {'order_id': 3, 'items': [{'name': 'Smartphone', 'price': 700}, {'name': 'Funda', 'price': 20}]}
    ]

    #Procesar múltiples órdenes concurrentemente
    tasks = [process_order(order['order_id'], order['items']) for order in orders]
    await asyncio.gather(*tasks)
    
## creación de event loop

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

Raul Fernandez

student•

Como no quedaron claros los conceptos explicados en las últimas clases, decidí hacer la siguiente nota con ayuda de IA.

Ejecución Secuencial vs. Concurrencia

1. Ejecución Secuencial

Las tareas se ejecutan una tras otra, sin superposición ni interrupciones.
Ejemplo: Un programa lee un archivo, procesa su contenido y escribe el resultado de forma secuencial. Cada paso espera a que el anterior termine antes de comenzar.

Concepto Erróneo: La ejecución secuencial es siempre ineficiente. En realidad, para tareas simples o dependientes del cómputo, puede ser perfectamente adecuada.

2. Concurrencia

La concurrencia es la capacidad de gestionar múltiples tareas intercalando su ejecución. Esto no significa necesariamente que las tareas se ejecuten al mismo tiempo; pueden alternarse.
La concurrencia puede lograrse en un procesador de un solo núcleo dividiendo el tiempo entre las tareas o en sistemas multicore ejecutando hilos o procesos concurrentemente.
Los núcleos lógicos (habilitados por tecnologías como Hyper-Threading) permiten que un único núcleo físico ejecute múltiples hilos concurrentemente al utilizar recursos inactivos.

Concepto Erróneo: La concurrencia siempre significa que las tareas se ejecutan al mismo tiempo. Se trata de la gestión de tareas, no de la ejecución simultánea.

3. Asincronismo

La programación asíncrona permite que las tareas continúen sin esperar a que otras terminen. Se utiliza comúnmente para operaciones dependientes de E/S donde, de lo contrario, la CPU permanecería inactiva.
Opera principalmente en un solo hilo utilizando un bucle de eventos para gestionar operaciones no bloqueantes (por ejemplo, en asyncio de Python o JavaScript).

Concepto Erróneo: El asincronismo siempre involucra múltiples hilos. Aunque los hilos pueden mejorar el rendimiento asíncrono, no son un requisito.

Nota al margen: ¿Qué es un bucle de eventos? Un bucle de eventos es un constructo de programación que espera y distribuye eventos o mensajes. En la programación asíncrona, gestiona tareas y callbacks de manera no bloqueante.

4. Multitarea

La multitarea implica gestionar múltiples hilos o procesos, intercalando su ejecución. En procesadores de un solo núcleo, esto se logra cambiando rápidamente entre tareas (división del tiempo).
En procesadores multicore, los hilos pueden ejecutarse en paralelo en diferentes núcleos físicos o lógicos.

Concepto Erróneo: La multitarea siempre mejora el rendimiento. Cambiar entre tareas conlleva una sobrecarga, por lo que una multitarea mal diseñada puede ralentizar la ejecución.

5. Paralelismo

El paralelismo implica ejecutar múltiples tareas o hilos simultáneamente en múltiples núcleos físicos.
Ideal para tareas dependientes del cómputo como simulaciones, procesamiento de datos o aprendizaje automático.

Concepto Erróneo: El paralelismo siempre es mejor que la concurrencia. Algunas cargas de trabajo se benefician más de una intercalación eficiente de tareas que de la verdadera ejecución paralela.

Nota al margen: Núcleos físicos vs. núcleos lógicos* Un núcleo físico es un núcleo de hardware real en un procesador.

Un núcleo lógico (vía Hyper-Threading) permite que un núcleo físico maneje múltiples hilos utilizando recursos inactivos dentro del núcleo.

Tabla Resumen: Tipos de Concurrencia

|---|---|---|---|---|---|

**|Asincronismo|**Monohilo, no bloqueante, utiliza bucles de eventos para manejar tareas.Tareas dependientes de E/S como archivos/red.|No requiere múltiples hilos; se basa en callbacks/promesas y bucles de eventos.|Tanto el asincronismo como la multitarea permiten manejar múltiples tareas eficientemente.|

|**Multitarea|**Gestiona múltiples tareas intercalando (división del tiempo) o ejecutándolas en paralelo.Ejecutar múltiples aplicaciones, capacidad de respuesta de GUI.|Puede implicar división del tiempo en procesadores de un solo núcleo o ejecución paralela en multicore.|Tanto la multitarea como el paralelismo pueden usar hilos o procesos para la concurrencia.|

|**Paralelismo|**Ejecuta múltiples tareas simultáneamente en múltiples núcleos. Tareas dependientes del cómputo como simulaciones, modelos de ML. |Requiere múltiples núcleos; logra verdadera ejecución simultánea. |Tanto el paralelismo como la multitarea manejan múltiples tareas y pueden beneficiarse de sistemas multicore.|

Explicación Gráfica

Aquí hay una representación visual de los conceptos:

Ejecución Secuencial:Tarea A: [-----] Tarea B: [-----] Tarea C: [-----]
Concurrencia (Un Solo Núcleo):Tarea A: [--][--][--] Tarea B: [--][--][--] Tarea C: [--][--]
Paralelismo (Múltiples Núcleos):Núcleo 1 (Tarea A): [-----] Núcleo 2 (Tarea B): [-----] Núcleo 3 (Tarea C): [-----]

Ejemplos de Código en Python

1. Ejecución Secuencial

import time

def tarea(nombre, duracion): print(f"Iniciando {nombre}") time.sleep(duracion) print(f"Finalizado {nombre}")

# Tareas ejecutadas una tras otra tarea("Tarea 1", 2) tarea("Tarea 2", 2) tarea("Tarea 3", 2)

2. Concurrencia (Asyncio)

import time

def tarea(nombre, duracion):
    print(f"Iniciando {nombre}")
    time.sleep(duracion)
    print(f"Finalizado {nombre}")

# Tareas ejecutadas una tras otra
tarea("Tarea 1", 2)
tarea("Tarea 2", 2)
tarea("Tarea 3", 2)

3. Multitarea (Threading)

import threading
import time

def tarea(nombre, duracion):
    print(f"Iniciando {nombre}")
    time.sleep(duracion)
    print(f"Finalizado {nombre}")

hilos = []

# Crear hilos para cada tarea
for i in range(1, 4):
    hilo = threading.Thread(target=tarea, args=(f"Tarea {i}", 2))
    hilos.append(hilo)
    hilo.start()

# Esperar a que todos los hilos terminen
for hilo in hilos:
    hilo.join()

4. Paralelismo (Multiprocessing)

import multiprocessing
import time

def tarea(nombre, duracion):
    print(f"Iniciando {nombre}")
    time.sleep(duracion)
    print(f"Finalizado {nombre}")

if __name__ == "__main__":
    procesos = []

    # Crear procesos para cada tarea
    for i in range(1, 4):
        proceso = multiprocessing.Process(target=tarea, args=(f"Tarea {i}", 2))
        procesos.append(proceso)
        proceso.start()

    # Esperar a que todos los procesos terminen
    for proceso in procesos:
        proceso.join()

Resumen

Secuencial: Simple pero puede ser ineficiente para cargas de trabajo dependientes de E/S.
Asincronismo: Eficiente para tareas dependientes de E/S, se basa en bucles de eventos.
Multitarea: Intercala tareas, adecuada para cargas que toler

Alexis Dorado Muñoz

student•

Muchas gracias por tu aporte

Andres David Caicedo Marquez

student•

Muchas gracias por tomarte tu tiempo de este resumen.

Orlando Murcia Perdomo

student•

Fidel Ortega Guzman

student•

muy bien

Alexis Dorado Muñoz

student•

Gracias por tu aporte

Emilio Sala

student•

esta clase parece que solo esta copiando codigo hecho de antemano. si uno quisiera hacerlo normalmente iniciaría por el main para luego ir creando las funciones más específicas

LEONARD CUENCA

student•

Estoy de acuerdo, cuando hacen clases muy extensas no permite captar la idea principal ya que es mucha información.

Yo lo que hice fue preguntarle a geminis que me explique cada elemento con ejemplos práticos y luego un ejemplo con todo los elementos.

Aun así este tema es avanzando deberia explicarlo en un curso a parte.

Andres David Caicedo Marquez

student•

Entiendo tu punto. Sin embargo, lo hermoso de la programación —al menos para algunos— es que permite construir el código desde nuestra propia lógica. En este caso, seguimos la lógica de la profesora que nos guía a través del proceso.

Este código está preparado: primero, porque ella seguramente ya lo ha implementado muchas veces con productos reales; y segundo, porque necesitan que el video sea breve y directo, con la información justa para los estudiantes.

Pero tú y yo sabemos que, detrás de cada solución funcional, hay cientos de errores previos. Como en las películas, no se muestran los intentos fallidos, solo el resultado final.

Lo valioso de que no nos muestren los errores —o de enfrentarnos a ellos nosotros mismos— es que así experimentamos una situación más cercana al mundo laboral real. Aprendemos a entender cómo "piensa" la máquina para identificar por qué no nos da el resultado esperado. Ese es el verdadero aprendizaje.

Andrés Ríos

student•

No entiendo de qué nos sirve una clase de 23 minutos copiando un código de memoria o leyendo un guion en el que la profesora solo comenta lo que esta copiando para no subir una video sin audio.

A mi en particular no me importa si copias y pegas el codigo directamente, como programador gracias a la experiencia que tengo en estos meses escribiendo y escribiendo codigo me he dado cuenta que el escribir codigo per se es lo mas irrelevante y sencillo de la tarea de programar. A mi parecer una buena clase habría sido plantear un problema y de ahi desarrollar la logica de qué quieres hacer, cómo y el qué le vas a indicar a python. ¿Qué excepciones pueden ocurrir? ¿Cómo debería tratarlas? ¿Termino la ejecucion o hago un bucle hasta que un valor adecuado sea introducido?

Por qué uso este metodo o solucion en vez de otro, cuál es el pensamiento detrás. Yo no pido una clase de una hora dando y pensando en cada caso exhaustivamente. pero sí una clase en la que solucionas un problema enseñando la logica que hay detras, como si no escribes una linea de codigo. Lo mas importante es enseñar esa logica, qué es cada cosa que usas. No simplemente darla como algo que existe por derecho divino y que se usa aca sin preguntarte nada.

"No enseñamos cosas básicas, enseñamos cosas fundamentales", dijo Freddy en la PlatziConf. Pues el curso de python con 63 clases hasta la clase 58, mucho derecho divino pocos fundamentos.

Kevin Julián López Bacca

student•

Totalmente de acuerdo mi hermano, yo solo estoy empezando en este mundo pero con la herramientas actuales como dices, lo de menos es escribir código, la lógica de lo que hacemos y el por que me parece algo fundamental, ya entiendo por que muchos programadores recomienda otra plataforma para aprender.

Gildder Guerrero Ramirez

student•

¿Cuál es la principal diferencia entre la concurrencia y el asincronismo en Python?

Elias Demian Lazo

student•

En la concurrencia varias tareas parecen ejecutarse al mismo tiempo, pero no necesariamente lo hacen en paralelo. Mientras que el asincronismo las tareas se suspenden y reanudan explícitamente cuando esperan algo, es decir, que en la concurrencia las tareas se dividen entre hilos o procesos y en el asincronismo las tareas cooperan cediendo el control.

Samuel Bethancourt

student•

Estas clases en donde solo se recrea el código sin mayor explicación, crean frustración. Sería excelente que se tomaran el tiempo de enfocarse un poco más en la lógica atrás de la construcción del código y que los ejemplos de uso sean más claros.

Es totalmente entendible que las clases se deben complementar con recursos adicionales, pero después de ver algo como esto solo te dan ganas de cerrar la PC.

Pero bueno! Hay que sobreponerse a la incomodidad que esto crea, dar feedback, y seguir aprendiendo.

Daniel Ochoa

student•

Hay un error en el código, cuando una orden lo puede ser procesada debes parar la ejecución, se siguió ejecutando y dando la opción de pago de algo que ya se verifico que no había. Esto la verdad estuvo muy mal explicado, no dijiste la razón de porque aplicaste uno u otro método en cada función y paso, solo te dedicaste a comentar un código, más atención a la explicación del porqué y para que de una función...

Andres David Caicedo Marquez

student•

En mi trayecto estudiando, me he dado cuenta de que llegar a tu propia lógica es lo que realmente distingue a un ingeniero o a un verdadero desarrollador. Un desarrollador puede hacer que algo funcione, pero un ingeniero se pregunta por qué funciona, cuándo usarlo y cuál es la mejor solución.

Creo que, como curso para enseñar Python, está bien. Pero si también nos enseñaran a hacernos preguntas sobre los fundamentos y a usarlos en el momento correcto, avanzaríamos no solo como programadores, sino como profesionales capaces de tomar decisiones técnicas bien fundamentadas, sin embargo, creo que para eso esta la universidad o ser muy buen autodidacta.

Rubén Orozco

student•

Realice el ejemplo de la clase, lo único que modifique en código es que cuando no hay disponible un item, la orden no realice los demás procesos (calcular total y procesar orden) y muestre que ocurrió un error.

con este ejemplo de clase se ve mejor los métodos asíncronos y la concurrencia, pero para entenderlo un poquito mas (aun no me queda 100% claro del todo) hice un grafico con esto me ayudo, lo comparto también por si a alguien le sirve.

Y el código tambien

import asyncio
import time
import random
import multiprocessing

#función asincrona para veridicar el inventario
async def check_inventory(item):
    try:
        # print("\n___________________________________________________________")
        print(f"verificando inventario para {item} ...")
        await asyncio.sleep(random.randint(3,6))
        print(f"inventario VERIFICADO para {item}")
        # print("___________________________________________________________")

        #simular disponibilidad del producto
        return random.choice([True, False, True, True])
    except Exception as ex:
        print(ex)

#función para procesar el pago
async def process_payment(order_id):
    try:
        # print("\n___________________________________________________________")
        print(f"Procesando pago para la orden [{order_id}] ...")
        #simular el tiempo de espera del servicio de pago
        await asyncio.sleep(random.randint(3,6))
        print(f"Pago procesado para la orden [{order_id}]")
        # print("___________________________________________________________")
        return True
    except Exception as ex:
        print(ex)

#Funcion intensiva en CPU para calcular el costo total del pedido
def calculate_total(items):
    try:
        # print("\n___________________________________________________________")
        print(f"Calculando costo total para {len(items)} articulos ...")
        time.sleep(5)
        total = sum(item['price'] for item in items)
        print(f"Costo total calculado: {total}")
        # print("___________________________________________________________")
        return total
    except Exception as ex:
        print(ex)

async def process_order(order_id, items):
    try:
        payment_result = False

        # print("\n___________________________________________________________")
        print(f"Iniciando el procesamiento de la orden [{order_id}] ...")
        #Verificar el inventario para cada articulo
        inventory_check = [check_inventory(item['name']) for item in items]  #este crea una lista de funciones a ejecutar
        inventory_results = await asyncio.gather(*inventory_check)  #este indica a asyncio la lista a ejecutar asincronamente

        print(f"fin check_inventory orden [{order_id}]")

        if not all(inventory_results):
            print(f"Orden [{order_id}] cancelada: Producto no está disponible")
        else:
            with multiprocessing.Pool() as pool:
                total = pool.apply(calculate_total, (items, )) #se ejecuta el proceso hasta que termine

            #Procesar el pago
            payment_result = await process_payment(order_id)

        if payment_result:
            print(f"\n🎉 Orden [{order_id}] completada con éxito. Total: {total}\n")
        else:
            # raise Exception(f"\n❌ Error al procesar el pago de la orden [{order_id}]\n")
            print(f"\n❌ Error al procesar el pago de la orden [{order_id}]\n")
        
        # print("___________________________________________________________")
        return total
    except Exception as ex:
        print(ex)

async def main():
    try:
        orders = [
            {'order_id': 1, 'items': [{'name': 'Laptop', 'price': 1000}, {'name': 'Mouse', 'price': 50}, {'name': 'Smartphone', 'price': 700}]},
            {'order_id': 2, 'items': [{'name': 'Teclado', 'price': 80}, {'name': 'Monitor', 'price': 300}]},
            {'order_id': 3, 'items': [{'name': 'Smartphone', 'price': 700}, {'name': 'Funda', 'price': 20}]}
        ]

        #Procesar múltiples órdenes concurrentemente
        tasks = [process_order(order['order_id'] , order['items']) for order in orders]
        await asyncio.gather(*tasks)
    except Exception as ex:
        print(ex)

#creamos el event loop
if __name__ == '__main__':
    asyncio.run(main())

Aaron Cordova

student•

En un sistema de gestión de pedidos, es posible que los cálculos de precios sigan realizándose incluso después de que un pedido ha sido marcado como cancelado debido a procesos asíncronos o de concurrencia. Es común que las operaciones no se detengan inmediatamente, especialmente si hay procesos en segundo plano que aún están ejecutándose. Esto puede dar la impresión de que los cálculos continúan a pesar de la cancelación, lo que podría ser un área a revisar en cuanto a la lógica de negocio y el manejo de estados en el sistema.

Johan Humberto Castillo rios

student•

siento que este curso deberia haber terminado hace 10 clases y estas clases para aca debrian estar mejor explicadas porque es algomuy importante pero solo los usan no explican o formas de uso!!! estoy algo confundido y eso que he buscado otros videos que me complementen

Etlin Ortega

student•

Al principio este modulo puede ser complicado, pero es muy util para efecto de simular en back todo un día de trabajo de un negocio y como impactar una base de datos...wao, me volo la cabeza, los escenarios que se pueden montar simulados.....podre de mis CPUs....jajaja

Miguel Angel Otero Otero

student•

📋 Esquema: Flujo de ejecución de prepararEmpanadas

1. Inicio

Se llama prepararEmpanadas(receta)

2. Bloque try

Intenta ejecutar el proceso completo

📦 Paso 1: await prepararMasa(receta.masa)

Mezclar harina, agua, sal y colorante
Reposar la masa

🍲 Paso 2: await prepararRelleno(receta.relleno)

Sofreír carne, cebolla, ajo, comino, papa rallada
Cocinar hasta que el relleno espese

🔄 Paso 3: await armarEmpanadas(masa, relleno)

Hacer discos de masa
Rellenar y sellar con los dedos

🔥 Paso 4: await freirEmpanadas(empanadas)

Freír en aceite caliente hasta dorar

✅ Si todo sale bien:

console.log('Empanadas listas para servir')

3. Bloque catch

Si algo falla:
console.error('Error en la preparación:', error)

4. Fin

Termina la ejecución del proceso

Ricardo Carrasco

student•

El error que estás encontrando sugiere que hay un problema al intentar usar multiprocessing.Pool en un contexto asíncrono. multiprocessing no se puede usar directamente con asyncio.

Para resolver esto, debes asegurarte de que estás utilizando await con funciones asíncronas. Alternativamente, si deseas ejecutar tareas en paralelo con asyncio, considera usar asyncio.create_task() o asyncio.gather() sin la necesidad de multiprocessing.

Asegúrate de que tu código esté estructurado para utilizar solo una de estas dos herramientas correctamente.

Alexis Dorado Muñoz

student•

Gracias por tu aporte

Jaime David Burbano Montoya

student•

Soy yo, o todo esto está mal? Pr8mero muestra que se canceló la orden 1 y 3, pero luego que está calculando el precio y al finalizar muestra el precio de otra orden y que la orden 2 está cancelada

Andres David Caicedo Marquez

student•

Recuerda que se usó random para simular que un objeto no este, los 3 que si estan funcionan, solo que el simulador hace como si no hubiera un producto para mostrar el mensaje.

Juan Acevedo

student•

Estuvo algo complejo de entender la clase sin embargo entendí un poco el sentido de la clase que era poder combinar archivos asíncronos con el multiproceso y quise hacer el mio propio

CODE:

import asyncio
import multiprocessing
import time
import random

async def descarga(file: str, id:int):
    print(f"Ejecutando descarga del archivo : {file}, id : {id}")
    await asyncio.sleep(random.randint(3,9))
    print(f"Descarga del archivo {file} finalizada con exito ")

async def validacion(file):
    print(f"Verificando {file} archivo...")
    await asyncio.sleep(random.randint(1,4))
    print("Archivo verificado")

def peso_archivo(file_peso):
    print("Calculando peso del archivo...")
    time.sleep(3)
    print("Archivo calculado")
    return file_peso * 300

async def processing(file, peso, id):
    print("Procesando datos")

    await validacion(file)
    await descarga(file, id)

    with multiprocessing.Pool()as pool:
        result = pool.apply(peso_archivo, (peso,))

    print(f"Peso del archivo {file}: {result}")

async def main():
    await asyncio.gather(
        processing("Cars 5", 40, 3),
        processing("PDF", 50, 2),
        processing("APK", 1000, 1)
    )

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

FABIAN PEREZ

student•

Veo muy mal que usen funciones que no se explican previamente.

Oscar Rogelio Heredia Ruiz

student•

import asyncio
import time
import random
import multiprocessing

#Función asíncrona para verificar el iventario

async def check_inventory(item):
    print (f"Verificando iventario de {item}...")
    await asyncio.sleep(random.randint(3, 6))
    print (f"Invenatario verificado de {item}...")

    #Simular disponibilidad del producto
    return random.choice([True, False])

#Función asíncrona para procesar el pago

async def process_payment(order_id):
    print (f"Procesando pago para la orden {order_id}...")
    #Simular tiempo de espera que tiene un servicio de pago
    await asyncio.sleep(random.randint(3, 6))
    print (f"Pago procesando para la orden {order_id}...")
    return True

#Función para calcular el costo total de la orden
def calculate_total(items):
    print(f"Calculando el costo total para {len(items)} articulos...")
    time.sleep(5)
    total = sum(item['price'] for item in items)
    print(f"Costo total: ${total}")
    return total

#Función para manejar la orden

async def process_order(order_id, items):
    print(f"Iniciando el procesamiento de la orden {order_id}...")
    #Verificar el inventario de cada artículo de la orden
    inventory_checks = [check_inventory(item['name']) for item in items]
    inventory_results = await asyncio.gather(*inventory_checks)

    if not all(inventory_results):
        print(f"Orden {order_id} cancelada: no hay suficiente inventario de ")
        return
    
    with multiprocessing.Pool() as pool:
        total = pool.apply(calculate_total, (items, ))
    
    #Procesar el pago asíncronicamente

    payment_result = await process_payment(order_id)

    if payment_result:
        print(f"Orden {order_id} procesada con éxito, Total: ${total}")
    else:
        print(f"Orden {order_id} cancelada: error en el pago")

async def main():
     
    orders = [
        {'order_id': 1, 'items': [{'name': 'Laptop', 'price': 1000}, {'name': 'Mouse', 'price': 50}]},
        {'order_id': 2, 'items': [{'name': 'Teclado', 'price': 80}, {'name': 'Monitor', 'price': 300}]},
        {'order_id': 3, 'items': [{'name': 'Smartphone', 'price': 700}, {'name': 'Funda', 'price': 20}]}
    ]
     
    
    #Procesamos cada orden manera concurrente
    tasks = [process_order(order['order_id'], order['items']) for order in orders]
    await asyncio.gather(*tasks)

    #Creamos el evento loop

if __name__ == "__main__":
    asyncio.run(main())
```import asyncioimport timeimport randomimport multiprocessing
\#Función asíncrona para verificar el iventario
async def check\_inventory(item):    print (f"Verificando iventario de {item}...")    await asyncio.sleep(random.randint(3, 6))    print (f"Invenatario verificado de {item}...")
    #Simular disponibilidad del producto    return random.choice(\[True, False])
\#Función asíncrona para procesar el pago
async def process\_payment(order\_id):    print (f"Procesando pago para la orden {order\_id}...")    #Simular tiempo de espera que tiene un servicio de pago    await asyncio.sleep(random.randint(3, 6))    print (f"Pago procesando para la orden {order\_id}...")    return True
\#Función para calcular el costo total de la ordendef calculate\_total(items):    print(f"Calculando el costo total para {len(items)} articulos...")    time.sleep(5)    total = sum(item\['price'] for item in items)    print(f"Costo total: ${total}")    return total
\#Función para manejar la orden
async def process\_order(order\_id, items):    print(f"Iniciando el procesamiento de la orden {order\_id}...")    #Verificar el inventario de cada artículo de la orden    inventory\_checks = \[check\_inventory(item\['name']) for item in items]    inventory\_results = await asyncio.gather(\*inventory\_checks)
    if not all(inventory\_results):        print(f"Orden {order\_id} cancelada: no hay suficiente inventario de ")        return        with multiprocessing.Pool() as pool:        total = pool.apply(calculate\_total, (items, ))        #Procesar el pago asíncronicamente
    payment\_result = await process\_payment(order\_id)
    if payment\_result:        print(f"Orden {order\_id} procesada con éxito, Total: ${total}")    else:        print(f"Orden {order\_id} cancelada: error en el pago")
async def main():         orders = \[        {'order\_id': 1, 'items': \[{'name': 'Laptop', 'price': 1000}, {'name': 'Mouse', 'price': 50}]},        {'order\_id': 2, 'items': \[{'name': 'Teclado', 'price': 80}, {'name': 'Monitor', 'price': 300}]},        {'order\_id': 3, 'items': \[{'name': 'Smartphone', 'price': 700}, {'name': 'Funda', 'price': 20}]}    ]             #Procesamos cada orden manera concurrente    tasks = \[process\_order(order\['order\_id'], order\['items']) for order in orders]    await asyncio.gather(\*tasks)
    #Creamos el evento loop
if \_\_name\_\_ == "\_\_main\_\_":    asyncio.run(main())

Oscar Rogelio Heredia Ruiz

student•

Hay una situación respecto cuando no hay stock de algun articulo, en caso de que no haya stock el programa sigue adelanate y calcula el precio de los otros articulos que si está, en este caso se deberia mostrar como cancelada o poder seguir pero mostrando el articulo que no tiene stock

Jonathan Javier Veas Realpe

student•

Me parece que hay un error en la funcion "process_order" ya que si la orden es cancelada por no disponibilidad de inventario, igual calcula el costo y procesa el pago.

Thomas Restrepo

student•

Tienes toda la razón, yo también lo note, le añadi un else y ya queda mejor la logica del programa

Sincronía y Concurrencia en Python: Teoría y Práctica

¿Cómo realizar operaciones asíncronas en programación?

¿Qué es una operación asíncrona?

Ejemplo de función asíncrona con async y await

¿Por qué es importante la programación asíncrona?

Beneficios de la programación asíncrona

¿Cómo verificar la existencia de artículos en inventario?

Código de ejemplo para verificar inventario

Consejos prácticos para implementar operaciones asíncronas

Ejemplo de función asíncrona con `async` y `await`