Python asyncio Future

Resumo : neste tutorial, você aprenderá sobre asyncioobjetos futuros do Python e entenderá como eles funcionam.

Introdução ao futuro assíncrono do Python

Um futuro é um objeto que retorna um valor mais tarde no futuro, mas não agora. Normalmente, um objeto futuro é o resultado de uma operação assíncrona.

Por exemplo, você pode chamar uma API de um servidor remoto e esperar receber o resultado mais tarde. A chamada da API pode retornar um objeto futuro para que você possa aguardá-lo.

Para criar um objeto futuro, você usa a Futureclasse do asynciopacote. Considere o seguinte exemplo:

import asyncio
from asyncio import Future


async def main():
    my_future = Future()
    print(my_future.done())  # False

    my_future.set_result('Bright')

    print(my_future.done())  # True

    print(my_future.result())


asyncio.run(main())Linguagem de código:  Python  ( python )

Como funciona.

Primeiro, importe Futurea classe da asynciobiblioteca:

from asyncio import FutureLinguagem de código:  Python  ( python )

A seguir, crie um novo Futureobjeto na main()corrotina:

my_future = Future()Linguagem de código:  Python  ( python )

Um futuro recém-criado não tem valor porque ainda não existe. Neste estado, o futuro é considerado incompleto, não resolvido ou não realizado.

Em seguida, chame o done()método para verificar o status do objeto futuro:

print(my_future.done())  # FalseLinguagem de código:  Python  ( python )

Ele retorna False.

Depois disso, defina um valor para o objeto futuro chamando o set_result()método:

my_future.set_result('Bright')Linguagem de código:  Python  ( python )

Depois de definir o valor, o futuro estará feito. Chamar o done()método do objeto futuro neste estágio retorna True:

print(my_future.done())  # TrueLinguagem de código:  Python  ( python )

Finalmente, obtenha o resultado do objeto futuro chamando seu result()método:

print(my_future.result())Linguagem de código:  Python  ( python )

Usando Python asyncio future com espera

Ao usar a awaitpalavra-chave com futuro, você pausa o futuro até que ele retorne um valor. O exemplo a seguir mostra como usar a awaitpalavra-chave future with:

from asyncio import Future
import asyncio


async def plan(my_future):
    print('Planning my future...')
    await asyncio.sleep(1)
    my_future.set_result('Bright')


def create() -> Future:
    my_future = Future()
    asyncio.create_task(plan(my_future))
    return my_future


async def main():
    my_future = create()
    result = await my_future

    print(result)


asyncio.run(main())Linguagem de código:  Python  ( python )

Saída:

Planning my future...
BrightLinguagem de código:  Python  ( python )

Como funciona.

Primeiro, defina uma corrotina que aceite um futuro e defina seu valor após 1 segundo:

async def plan(my_future: Future):
    print('Planning my future...')
    await asyncio.sleep(1)
    my_future.set_result('Bright')Linguagem de código:  Python  ( python )

Segundo, defina uma create()função que agende a plan()corrotina como uma tarefa e retorne um objeto futuro:

def create() -> Future:
    my_future = Future()
    asyncio.create_task(plan(my_future))
    return my_futureLinguagem de código:  Python  ( python )

Terceiro, chame a create()função que retorna um futuro, use a palavra-chave wait para esperar que o futuro retorne um resultado e exiba-o:

async def main():
    my_future = create()
    result = await my_future

    print(result)Linguagem de código:  Python  ( python )

Na prática, raramente você precisará criar Futureobjetos diretamente. No entanto, você usará os Futureobjetos retornados da API. Portanto, é importante entender como Futurefunciona.

Futuros, tarefas e corrotinas

A hierarquia de classes a seguir mostra os relacionamentos entre Coroutine , Future e Task :

Nesta hierarquia de classes, Courtine, Future e Task são subclasses da classe abstrata Awaitable.

A Awaitableclasse possui um método abstrato __await__(). Qualquer classe que possua a implementação do __await__()método pode ser usada com a palavra-chave await. E os objetos de classes que podem ser usados ​​com a awaitpalavra-chave são chamados de awaitables .

Resumo

• Um futuro é um objeto que retorna um valor no futuro, não agora.
• Future, Coroutine, e Tasksão aguardáveis ​​e seus objetos podem ser usados ​​com a awaitpalavra-chave.