Python assíncrono/espera

Resumo : neste tutorial, você aprenderá sobre corrotinas Python e como usar Python asynce awaitpalavras-chave para criar e pausar corrotinas.

Introdução às corrotinas Python

Uma corrotina é uma função regular com a capacidade de pausar sua execução ao encontrar uma operação que pode demorar um pouco para ser concluída.

Quando a operação de longa duração for concluída, você poderá retomar a corrotina pausada e executar o código restante nessa corrotina.

Enquanto a corrotina aguarda a operação de longa execução, você pode executar outro código. Ao fazer isso, você pode executar o programa de forma assíncrona para melhorar seu desempenho.

Para criar e pausar uma corrotina, você usa Python asynce awaitpalavras-chave:

• A asyncpalavra-chave cria uma corrotina.
• A awaitpalavra-chave pausa uma corrotina.

Definindo uma corrotina com palavra-chave Python assíncrona

O seguinte define uma função simples que retorna o número quadrado de um inteiro:

def square(number: int) -> int:
    return number*numberLinguagem de código:  Python  ( python )

E você pode passar um número inteiro para a square()função para obter seu número quadrado:

def square(number: int) -> int:
    return number*number


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

Saída:

100Linguagem de código:  Python  ( python )

Quando você adiciona a asyncpalavra-chave à função, a função se torna uma corrotina:

async def square(number: int) -> int:
    return number*numberLinguagem de código:  Python  ( python )

Uma corrotina de chamada retorna um objeto de corrotina que será executado posteriormente. Por exemplo:

async def square(number: int) -> int:
    return number*number


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

Saída:

<coroutine object square at 0x00000185C31E7D80>
sys:1: RuntimeWarning: coroutine 'square' was never awaitedLinguagem de código:  Python  ( python )

Neste exemplo, chamamos a square()corrotina, atribuímos o valor retornado à resultvariável e o imprimimos.

Quando você chama uma corrotina, o Python não executa o código dentro da corrotina imediatamente. Em vez disso, ele retorna um objeto de co-rotina.

A segunda linha da saída também mostra uma mensagem de erro indicando que a corrotina nunca foi aguardada. Mais sobre isso na awaitseção a seguir:

sys:1: RuntimeWarning: coroutine 'square' was never awaitedLinguagem de código:  JavaScript  ( javascript )

Para executar uma corrotina, você precisa executá-la em um loop de eventos . Antes do Python 3.7, você precisava criar manualmente um loop de eventos para executar corrotinas e fechar o loop de eventos.

Porém, desde a versão 3.7, a asynciobiblioteca adicionou algumas funções que simplificam o gerenciamento do loop de eventos.

Por exemplo, você pode usar a asyncio.run()função para criar automaticamente um loop de eventos, executar uma corrotina e fechá-la.

O seguinte usa a asyncio.run()função para executar a square()corrotina e obter o resultado:

import asyncio


async def square(number: int) -> int:
    return number*number

result = asyncio.run(square(10))
print(result)Linguagem de código:  Python  ( python )

Saída:

100Linguagem de código:  Python  ( python )

É importante observar que o asyncio.run()foi projetado para ser o principal ponto de entrada de um asyncioprograma.

Além disso, a asyncio.run()função executa apenas uma corrotina que pode chamar outras corrotinas e funções no programa.

Pausando uma corrotina com a palavra-chave Python wait

A awaitpalavra-chave pausa a execução de uma corrotina. A awaitpalavra-chave é seguida por uma chamada para uma corrotina como esta:

result = await my_coroutine()Linguagem de código:  Python  ( python )

A awaitpalavra-chave faz com que my_coroutine()o código seja executado, aguarda a conclusão do código e retorna um resultado.

É importante observar que awaita palavra-chave só é válida dentro de uma corrotina. Em outras palavras, você deve usar a awaitpalavra-chave dentro de uma corrotina.

Este é o motivo pelo qual você viu uma mensagem de erro no exemplo acima que usa a awaitpalavra-chave fora de uma corrotina.

O exemplo a seguir mostra como usar a awaitpalavra-chave para pausar uma corrotina:

import asyncio


async def square(number: int) -> int:
    return number*number


async def main() -> None:
    x = await square(10)
    print(f'x={x}')

    y = await square(5)
    print(f'y={y}')

    print(f'total={x+y}')

if __name__ == '__main__':
    asyncio.run(main())Linguagem de código:  Python  ( python )

Saída:

x=100
y=25
total=125Linguagem de código:  Python  ( python )

Como funciona. (vamos nos concentrar na main()função):

Primeiro, chame a square()corrotina usando a awaitpalavra-chave. A awaitpalavra-chave irá pausar a execução da main()corrotina, aguardar a square()conclusão da corrotina e retornar o resultado:

x = await square(10)
print(f'x={x}')Linguagem de código:  Python  ( python )

Segundo, chame a square()corrotina uma segunda vez usando a awaitpalavra-chave:

y = await square(5)
print(f'y={y}')Linguagem de código:  Python  ( python )

Terceiro, exiba o total:

print(f'total={x+y}')Linguagem de código:  Python  ( python )

A instrução a seguir usa a run()função para executar a main()corrotina e gerenciar o loop de eventos:

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

Até agora, nosso programa é executado como um programa síncrono. Não revela o poder do modelo de programação assíncrona.

Resumo

• Uma corrotina é uma função regular com o poder de pausar uma operação de longa duração, aguardar o resultado e retomar a partir do ponto pausado.
• Use asyncpalavra-chave para definir uma corrotina.
• Use awaitpalavra-chave para pausar uma corrotina.
• Use asyncio.run()a função para executar automaticamente uma corrotina em um loop de eventos e gerenciar um loop de eventos.