Ejemplo simple: necesito hacer dos solicitudes HTTP no relacionadas en paralelo. ¿Cuál es la forma más sencilla de hacer eso? Espero que sea así:

async def do_the_job():
    with aiohttp.ClientSession() as session:
        coro_1 = session.get('http://httpbin.org/get')
        coro_2 = session.get('http://httpbin.org/ip')
        return combine_responses(await coro_1, await coro_2)

En otras palabras, quiero iniciar operaciones de E / S y esperar sus resultados para que se ejecuten efectivamente en paralelo. Esto se puede lograr conasyncio.gather:

async def do_the_job():
    with aiohttp.ClientSession() as session:
        coro_1 = session.get('http://example.com/get')
        coro_2 = session.get('http://example.org/tp')
        return combine_responses(*(await asyncio.gather(coro_1, coro_2)))

A continuación, quiero tener una estructura de dependencia compleja. Quiero comenzar las operaciones cuando tengo todos los requisitos previos para ellos y obtener resultados cuando los necesito. Aquí ayudaasyncio.ensure_future lo que hace que la tarea separada de la rutina sea administrada por el ciclo de eventos por separado:

async def do_the_job():
    with aiohttp.ClientSession() as session:
        fut_1 = asyncio.ensure_future(session.get('http://httpbin.org/ip'))
        coro_2 = session.get('http://httpbin.org/get')
        coro_3 = session.post('http://httpbin.org/post', data=(await coro_2)
        coro_3_result = await coro_3
        return combine_responses(await fut_1, coro_3_result)

¿Es cierto que, para lograr una E / S paralela sin bloqueo con corutinas en mi flujo lógico, tengo que usarasyncio.ensure_future oasyncio.gather (que en realidad usaasyncio.ensure_future)? ¿Hay una manera menos "verbosa"?

¿Es cierto que normalmente los desarrolladores tienen que pensar qué rutinas deberían convertirse en tareas separadas y utilizar las funciones antes mencionadas para obtener un rendimiento óptimo?

¿Hay algún punto en el uso de corutinas sin múltiples tareas en el bucle de eventos?

¿Qué tan "pesadas" son las tareas de bucle de eventos en la vida real? Seguramente, son "más ligeros" que los hilos o procesos del sistema operativo. ¿Hasta qué punto debería esforzarme por un número mínimo posible de tales tareas?