Digamos que tenemos una función ficticia:

async def foo(arg):
    result = await some_remote_call(arg)
    return result.upper()

Cuál es la diferencia entre:

import asyncio    

coros = []
for i in range(5):
    coros.append(foo(i))

loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(coros))

Y:

import asyncio

futures = []
for i in range(5):
    futures.append(asyncio.ensure_future(foo(i)))

loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(futures))

Nota : El ejemplo devuelve un resultado, pero este no es el foco de la pregunta. Cuando el valor de retorno importa, use en gather()lugar de wait().

Independientemente del valor de retorno, busco claridad ensure_future(). wait(coros)y wait(futures)ambos ejecutan las corrutinas, entonces, ¿cuándo y por qué debería incluirse una corrutina ensure_future?

Básicamente, ¿cuál es la forma correcta (tm) de ejecutar un montón de operaciones sin bloqueo usando Python 3.5 async?

Para obtener crédito adicional, ¿qué sucede si quiero agrupar las llamadas? Por ejemplo, necesito llamar some_remote_call(...)1000 veces, pero no quiero aplastar el servidor web / base de datos / etc.con 1000 conexiones simultáneas. Esto es factible con un hilo o grupo de procesos, pero ¿hay alguna forma de hacerlo asyncio?

Actualización 2020 (Python 3.7+) : no use estos fragmentos. En su lugar use:

import asyncio

async def do_something_async():
    tasks = []
    for i in range(5):
        tasks.append(asyncio.create_task(foo(i)))
    await asyncio.gather(*tasks)

def do_something():
    asyncio.run(do_something_async)

También considere usar Trio , una alternativa sólida de terceros a asyncio.

Una corrutina es una función generadora que puede generar valores y aceptar valores del exterior. El beneficio de usar una corrutina es que podemos pausar la ejecución de una función y reanudarla más tarde. En el caso de una operación de red, tiene sentido pausar la ejecución de una función mientras esperamos la respuesta. Podemos usar el tiempo para ejecutar algunas otras funciones.

Un futuro es como los Promiseobjetos de Javascript. Es como un marcador de posición para un valor que se materializará en el futuro. En el caso mencionado anteriormente, mientras esperamos en la E / S de la red, una función puede darnos un contenedor, una promesa de que llenará el contenedor con el valor cuando se complete la operación. Nos aferramos al objeto futuro y cuando se cumple, podemos llamar a un método para recuperar el resultado real.

Respuesta directa: no es necesario ensure_futuresi no necesita los resultados. Son buenos si necesita los resultados o recuperar las excepciones ocurridas.

Créditos adicionales: elegiría run_in_executory pasaría una Executorinstancia para controlar el número máximo de trabajadores.

Explicaciones y códigos de muestra

En el primer ejemplo, está utilizando corrutinas. La waitfunción toma un montón de corrutinas y las combina. Entonces wait()termina cuando se agotan todas las corrutinas (completadas / terminadas de devolver todos los valores)

loop = get_event_loop() # 
loop.run_until_complete(wait(coros))

El run_until_completemétodo se aseguraría de que el bucle esté vivo hasta que finalice la ejecución. Observe cómo no obtiene los resultados de la ejecución asíncrona en este caso.

En el segundo ejemplo, está utilizando la ensure_futurefunción para ajustar una corrutina y devolver un Taskobjeto que es una especie de Future. La corrutina está programada para ejecutarse en el bucle de eventos principal cuando llame ensure_future. El objeto futuro / tarea devuelto aún no tiene un valor, pero con el tiempo, cuando finalizan las operaciones de red, el objeto futuro contendrá el resultado de la operación.

from asyncio import ensure_future

futures = []
for i in range(5):
    futures.append(ensure_future(foo(i)))

loop = get_event_loop()
loop.run_until_complete(wait(futures))

Entonces, en este ejemplo, estamos haciendo lo mismo excepto que estamos usando futuros en lugar de solo usar corrutinas.

Veamos un ejemplo de cómo usar asyncio / coroutines / futuros:

import asyncio


async def slow_operation():
    await asyncio.sleep(1)
    return 'Future is done!'


def got_result(future):
    print(future.result())

    # We have result, so let's stop
    loop.stop()


loop = asyncio.get_event_loop()
task = loop.create_task(slow_operation())
task.add_done_callback(got_result)

# We run forever
loop.run_forever()

Aquí, hemos utilizado el create_taskmétodo en el loopobjeto. ensure_futureprogramaría la tarea en el bucle de eventos principal. Este método nos permite programar una corrutina en un ciclo que elijamos.

También vemos el concepto de agregar una devolución de llamada usando el add_done_callbackmétodo en el objeto de tarea.

A Taskes donecuando la corrutina devuelve un valor, genera una excepción o se cancela. Existen métodos para comprobar estos incidentes.

He escrito algunas publicaciones de blog sobre estos temas que podrían ayudar:

• http://masnun.com/2015/11/13/python-generators-coroutines-native-coroutines-and-async-await.html
• http://masnun.com/2015/11/20/python-asyncio-future-task-and-the-event-loop.html
• http://masnun.com/2015/12/07/python-3-using-blocking-functions-or-codes-with-asyncio.html

Por supuesto, puede encontrar más detalles en el manual oficial: https://docs.python.org/3/library/asyncio.html

Respuesta simple

• La invocación de una función de rutina ( async def) NO la ejecuta. Devuelve objetos de una corrutina, como la función generadora devuelve objetos generadores.
• await recupera valores de corrutinas, es decir, "llama" a la corrutina
• eusure_future/create_task programe la corrutina para que se ejecute en el bucle de eventos en la próxima iteración (aunque sin esperar a que finalicen, como un hilo de demonio).

Algunos ejemplos de código

Primero aclaremos algunos términos:

• función de rutina, la que tienes async def;
• objeto coroutine, lo que obtienes cuando "llamas" a una función coroutine;
• tarea, un objeto envuelto alrededor de un objeto de rutina para ejecutar en el bucle de eventos.

Caso 1, awaiten una corrutina

Creamos dos corrutinas, awaituna, y usamos create_taskpara ejecutar la otra.

import asyncio
import time

# coroutine function
async def p(word):
    print(f'{time.time()} - {word}')


async def main():
    loop = asyncio.get_event_loop()
    coro = p('await')  # coroutine
    task2 = loop.create_task(p('create_task'))  # <- runs in next iteration
    await coro  # <-- run directly
    await task2

if __name__ == "__main__":
    loop = asyncio.get_event_loop()
    loop.run_until_complete(main())

obtendrás resultado:

1539486251.7055213 - await
1539486251.7055705 - create_task

Explique:

task1 se ejecutó directamente y task2 se ejecutó en la siguiente iteración.

Caso 2, ceder el control al bucle de eventos

Si reemplazamos la función principal, podemos ver un resultado diferente:

async def main():
    loop = asyncio.get_event_loop()
    coro = p('await')
    task2 = loop.create_task(p('create_task'))  # scheduled to next iteration
    await asyncio.sleep(1)  # loop got control, and runs task2
    await coro  # run coro
    await task2

obtendrás resultado:

-> % python coro.py
1539486378.5244057 - create_task
1539486379.5252144 - await  # note the delay

Explique:

Al llamar asyncio.sleep(1), el control se devolvió al bucle de eventos, y el bucle verifica que las tareas se ejecuten y luego ejecuta la tarea creada por create_task.

Tenga en cuenta que primero invocamos la función de corrutina, pero no a awaitella, por lo que solo creamos una sola corrutina y no la ejecutamos. Luego, volvemos a llamar a la función de rutina y la envolvemos en una create_taskllamada, creat_task programará la rutina para que se ejecute en la siguiente iteración. Entonces, en el resultado, create taskse ejecuta antes await.

En realidad, el punto aquí es devolver el control al bucle, podría usar asyncio.sleep(0)para ver el mismo resultado.

Bajo el capó

loop.create_tasken realidad llama asyncio.tasks.Task(), que llamará loop.call_soon. Y loop.call_soonpondrá la tarea en loop._ready. Durante cada iteración del ciclo, comprueba todas las devoluciones de llamada en loop._ready y lo ejecuta.

asyncio.wait, asyncio.ensure_futurey de asyncio.gatherhecho llamar loop.create_taskdirecta o indirectamente.

También tenga en cuenta en los documentos :

Las devoluciones de llamada se llaman en el orden en que se registran. Cada devolución de llamada se llamará exactamente una vez.

Un comentario de Vincent vinculado a https://github.com/python/asyncio/blob/master/asyncio/tasks.py#L346 , que muestra que te wait()envuelve las corrutinas ensure_future().

En otras palabras, necesitamos un futuro, y las corrutinas se transformarán silenciosamente en ellos.

Actualizaré esta respuesta cuando encuentre una explicación definitiva de cómo agrupar corutinas / futuros.

Del BDFL [2013]

Tareas

• Es una corrutina envuelta en un futuro
• class Task es una subclase de la clase Future
• ¡Así que también funciona con await !

• ¿En qué se diferencia de una corrutina simple?
• Puede progresar sin esperarlo
  • Siempre que espere algo más, es decir
    • espera [algo_más]

Con esto en mente, ensure_futuretiene sentido como un nombre para la creación de un Grupo a que el resultado de que el futuro será computada si está o no esperan que (siempre y cuando usted espera algo). Esto permite que el ciclo de eventos complete su tarea mientras espera otras cosas. Tenga en cuenta que en Python 3.7 create_taskes la forma preferida de asegurar un futuro .

Nota: Cambié "rendimiento de" en las diapositivas de Guido a "esperar" aquí la modernidad.