Python Asyncio se reúne

Entrada/saída assíncrona ou Asyncio é uma metodologia de programação que usa um loop de eventos ou um único encadeamento para realizar alta simultaneidade. O Python não é o único idioma ou estrutura que usa a abordagem; Os nodejs de JavaScript são talvez os mais conhecidos. Usamos asyncio em python em vez de multithreading porque escrever uma programação segura para tópicos é bastante desafiadora. É significativamente mais difícil encontrar problemas de raça ao usar programação assíncrona, pois você pode identificar especificamente onde o código mudará de uma tarefa para a seguinte.Devido ao requisito de que cada encadeamento tenha sua pilha, os threads usam uma grande quantidade de dados. A programação assíncrona mantém a pilha pequena, desenrolando -a continuamente entre as operações, permitindo que todos os programas compartilhem a mesma pilha. A plataforma precisa de mais memória para suportar os threads porque eles são construções de sistema operacional. Tarefas assíncronas não têm esse problema.

Aqui, discutiremos a função Asyncio - reunir. Duas funções cruciais devem ser entendidas ao aprender o módulo Python Asyncio. A primeira opção é executada, que é um método direto de executar uma coroutina, e a segunda opção é reunir. O contexto atual reinicia assim que todas as coroutinas forem concluídas, permitindo que você inicie uma série delas simultaneamente usando o coletivo.

As respostas de cada coroutina estão listadas no valor de retorno. Como o próprio nome indica, Asyncio.reunir -se () concentra -se principalmente em reunir os resultados. Espera em vários futuros e depois retorna os resultados em uma sequência específica. O Asyncio.Reúna () cancela todos os trabalhos incompletos que ele reúne se for cancelado por si só.

Sintaxe de Asyncio.Reúna -se em Python

ASYNCIO.reunir () aceita um único ou múltiplo aguardável como *args, encapsula -os em tarefas, se apropriado, então aguarda que cada um deles conclua. Os resultados de cada um aguardável são devolvidos na ordem em que você passou por eles:

# f_output, g_output = aguarda asyncio.reunir (f (), g ())

Você também pode fornecer as exceções de retorno = true, em que as exceções do caso são entregues junto com os resultados regulares, e você deve determinar por si mesmo se eles foram bem -sucedidos.

Exemplo 1:
O Asyncio.Reunir () A função pode ser usada para executar inúmeras coroutinas simultaneamente. Coroutines são executados simultaneamente por esta função como parâmetros.

importar asyncio
tempo de importação
assíncrof def wishes ():
print ("Hello")
aguarda.sono (1)
print ("Tenha um bom dia")
Async def main ():
BEGIN = Time.tempo()
aguarda.reunir (desejos (), desejos ())
decorrido = tempo.time () - Comece
print (f "__name__ executado em decorrido: 0.2f segundos.")
ASYNCIO.executar (main ())

Aqui, importamos dois módulos: Asyncio e a hora do Python. Em seguida, definimos uma função com o nome "desejos". Estabelecemos a definição de função assíncrona. A definição assíncrona contém apenas código assíncrono; Todo o outro código é síncrono. Dentro da função Async Def Wishes, imprimimos os valores da string. O Asyncio.A função do sono foi chamada e o valor para a suspensão do fio selecionado foi definido usando a palavra -chave aguarda. Aguarda retorna o controle ao loop do evento durante uma chamada de função.

Depois disso, construímos outra função assíncrona como main (). Dentro dessa função, definimos a variável em que a função de tempo do módulo de tempo python é chamada. Com a palavra -chave aguardar, definimos o Asyncio.Reúna função para reunir o resultado da função deseja. Também registramos o tempo de tempo para a execução do código principal.

Na saída, temos as coroutinas geradas duas vezes simultaneamente a partir da função Wishes (). A saída do código mencionada anteriormente é exibida com sucesso na imagem a seguir:

Exemplo 2:
A execução de várias co-rotinas pode ser agendada dinamicamente usando o método Asyncio Gather, como demonstrado neste exemplo. Seguindo a coleção bem-sucedida de todos os resultados de co-rotina, a chamada aguarda fornece os valores como resultados e os imprime.

importar asyncio
ASYNC def add (a: int, b: int):
Retornar A + B
Async def get_result ():
entradas = [(4, 5), (6, 6), (7, 8), (9, 4)]
tarefas = [Asyncio.create_task (add (a, b)) para a, b em entradas]
Result = Asyncio.reunir (*tarefas)
print ("Resultado:")
Imprimir (Aguarda resultado)
ASYNCIO.Run (get_result ())

Neste exemplo em particular, incluímos o módulo Asyncio para utilizar o Asyncio.reunir função. Em seguida, definimos uma função assíncrona para adição. Geramos a função ADD ASYNC e definimos as duas variáveis ​​A e B com o tipo de dados int para a função Adicionar. Com o comando de retorno, adicionamos essas variáveis ​​com o operador Plus.

Depois de definir a coroutina, criamos outra função para agendar o loop de evento na coroutina. A função é chamada "get_result", onde inicializamos a lista com as entradas variáveis. Depois disso, criamos a lista de tarefas na variável de tarefas. Com o Asyncio.Reúna função, reunimos o resultado da lista de tarefas passando a tarefa de ponteiro para essa função. Finalmente imprimimos o resultado. A seguinte lista de tarefas é obtida no programa anterior:

Exemplo 3:
Reunimos o resultado da tarefa futura, passando a tarefa futura no Asyncio.reunir função. Future designa um cálculo que está em execução atualmente ou que será planejado no futuro. Um resultado eventual de um procedimento assíncrono é representado por um objeto exclusivo de baixo nível aguardável.

importar asyncio
Do futuro de importação de Asyncio
ASYNC def function1 (futuro):
print ("function1 vai dormir por 3 segundos")
Aguarda Asyncio.sono (3)
print ("function1 resolvendo o futuro")
futuro.feito()
futuro.set_result ("futuro está resolvido")
ASYNC def function2 (futuro):
print ("function2 aguardará o futuro")
aguarde o futuro
print ("function2 encontra o futuro resolvido")
Async def main ():
futuro = futuro ()
Resultados = aguarda.reunir (function2 (futuro), function1 (futuro))
Se __name __ == "__ main___":
ASYNCIO.executar (main ())
Print ("Principal terminado")

Aqui, incluímos primeiro o módulo Asyncio e o futuro módulo do Asyncio. Em seguida, definimos a coroutina como "função1" e passamos o futuro. Então, dentro daquela coroutina, chamamos a função de sono para a suspensão da coroutina. Chamamos as chamadas de chamada do sistema feita e Set_Result System no futuro. Lá, temos outra coroutina chamada "function2" e também leva o futuro como um argumento. Ligamos para o comando aguardar no futuro para ser resolvido.

Depois disso, temos a definição principal assíncrona que chamamos de função futura e obtemos o resultado do futuro pelo Asyncio.reunir método. No final, imprimimos a declaração quando a função principal foi encerrada. A saída do código mencionada anteriormente é exibida com sucesso na imagem a seguir:

Conclusão

Reunir é forte, como você pode ver. Podemos solicitar sucintamente vários recursos de uma só vez, o que é uma ocorrência típica nos programas da Web. Com a ajuda do Python Asyncio.Reunir módulo embutido, a programação assíncrona foi apresentada neste tutorial. Reunimos os resultados de coroutinas, tarefas e futuros. Um código simultâneo pode ser sua melhor escolha quando você precisa otimizar o desempenho para atividades específicas, pois discutimos anteriormente como executar as inúmeras coroutinas simultaneamente usando o Asyncio.reunir métodos.