¿Cuándo usar y cuándo no usar Python 3.5 `await`?

De forma predeterminada, todo su código es sincrónico. Puede hacerlo asíncrono definiendo funciones async defy "llamando" a estas funciones con await. Una pregunta más correcta sería "¿Cuándo debo escribir código asincrónico en lugar de sincrónico?". La respuesta es "Cuando puedas beneficiarte de ello". En los casos en que trabaje con operaciones de E/S como señaló, generalmente se beneficiará:

# Synchronous way:
download(url1)  # takes 5 sec.
download(url2)  # takes 5 sec.
# Total time: 10 sec.

# Asynchronous way:
await asyncio.gather(
    async_download(url1),  # takes 5 sec. 
    async_download(url2)   # takes 5 sec.
)
# Total time: only 5 sec. (+ little overhead for using asyncio)

Por supuesto, si creó una función que usa código asincrónico, esta función también debería ser asincrónica (debe definirse como async def). Pero cualquier función asincrónica puede utilizar libremente código síncrono. No tiene sentido convertir código síncrono a asíncrono sin algún motivo:

# extract_links(url) should be async because it uses async func async_download() inside
async def extract_links(url):  

    # async_download() was created async to get benefit of I/O
    html = await async_download(url)  

    # parse() doesn't work with I/O, there's no sense to make it async
    links = parse(html)  

    return links

Una cosa muy importante es que cualquier operación sincrónica larga (> 50 ms, por ejemplo, es difícil decirlo exactamente) congelará todas sus operaciones asincrónicas durante ese tiempo:

async def extract_links(url):
    data = await download(url)
    links = parse(data)
    # if search_in_very_big_file() takes much time to process,
    # all your running async funcs (somewhere else in code) will be frozen
    # you need to avoid this situation
    links_found = search_in_very_big_file(links)

Puede evitar que llame a funciones síncronas de larga ejecución en procesos separados (y espere el resultado):

executor = ProcessPoolExecutor(2)

async def extract_links(url):
    data = await download(url)
    links = parse(data)
    # Now your main process can handle another async functions while separate process running    
    links_found = await loop.run_in_executor(executor, search_in_very_big_file, links)

Un ejemplo más: cuando necesitas usarlo requestsen asyncio. requests.getes solo una función síncrona de larga duración, a la que no debes llamar dentro del código asíncrono (nuevamente, para evitar la congelación). Pero tarda mucho debido a la E/S, no a causa de cálculos prolongados. En ese caso, puedes usar ThreadPoolExecutoren lugar de ProcessPoolExecutorpara evitar algunos gastos generales de multiprocesamiento:

executor = ThreadPoolExecutor(2)

async def download(url):
    response = await loop.run_in_executor(executor, requests.get, url)
    return response.text

Oct 28 '2015 19:10 Mikhail Gerasimov