Python Asyncio si raduna
Input/output asincroni o asincio è una metodologia di programmazione che utilizza un ciclo di eventi o un singolo thread per realizzare ad alta concorrenza. Python non è l'unica lingua o framework che utilizza l'approccio; Nodejs di JavaScript è forse il più noto. Usiamo Asyncio in Python piuttosto che multithreading perché scrivere una programmazione di thread-safe è piuttosto impegnativa. È significativamente più difficile incontrare problemi di razza quando si utilizzano una programmazione asincrona poiché è possibile individuare in particolare dove il codice cambierà da un'attività all'altra.A causa del requisito che ogni thread ha il suo stack, i thread usano una grande quantità di dati. La programmazione asincrima mantiene lo stack piccolo rilassandolo continuamente tra le operazioni, consentendo a tutti i programmi di condividere lo stesso stack. La piattaforma necessita di più memoria per supportare i thread perché sono costrutti del sistema operativo. I compiti asincroni non hanno questo problema.
Qui discuteremo della funzione Asyncio - Gather. Due funzioni cruciali dovrebbero essere comprese quando si impara il modulo Python Asyncio. La prima opzione è eseguita, che è un metodo semplice per l'esecuzione di una coroutine e la seconda opzione è raccolta. Il contesto attuale si riavvia una volta completate tutte le coroutine, consentendo di lanciarle contemporaneamente usando Gather.
Le risposte di ogni coroutine sono elencate nel valore di ritorno. Come suggerisce il nome, Asyncio.Gather () si concentra principalmente sulla raccolta dei risultati. Aspetta numerosi futuri e poi restituisce i risultati in una sequenza specifica. L'asincio.Gather () annulla tutti i lavori incompleti che raccoglie se viene annullato da solo.
Sintassi di Asyncio.Raccogli a Python
Asyncio.Gather () accetta un singolo o multiplo in attesa come *Args, li incapsula in attività, se del caso, quindi attende che ciascuno di essi sia completato. I risultati di ciascuno in attesa vengono quindi restituiti nell'ordine in cui li hai superati:
# f_output, g_output = aspetta asyncio.Gather (f (), g ())Puoi anche fornire le eccezioni di ritorno = true, in cui le eccezioni del caso vengono consegnate insieme ai risultati regolari e devi determinare tu stesso se hanno avuto successo.
Esempio 1:
L'asincio.La funzione Gather () può essere utilizzata per eseguire numerose coroutine contemporaneamente. Le coroutine vengono eseguite contemporaneamente da questa funzione come parametri.
tempo di importazione
Async Def Wishes ():
stampa ("ciao")
Attenzione.sonno (1)
Stampa ("Buona giornata")
Async def main ():
Inizia = tempo.tempo()
Attenzione.Gather (Wishes (), Wishes ())
trasmesso = tempo.Time () - Inizia
print (f "__name__ eseguito in eloped: 0.2f secondi.")
Asyncio.run (main ())
Qui, abbiamo importato due moduli: Asyncio e il tempo di Python. Quindi, abbiamo definito una funzione con il nome "Wishes". Abbiamo stabilito la definizione della funzione Async. La definizione asincrima contiene solo un codice asincrono; Tutto l'altro codice è sincrono. All'interno della funzione Async Def Wishes, abbiamo stampato i valori della stringa. L'asincio.La funzione di sonno è stata chiamata e il valore per la sospensione del thread selezionato è stato impostato utilizzando la parola chiave di attesa. Aspetta restituisce il controllo al ciclo dell'evento durante una chiamata di funzione.
Successivamente, abbiamo costruito un'altra funzionalità di asincroni DEF come principale (). All'interno di quella funzione, impostiamo la variabile in cui viene chiamata la funzione temporale dal modulo Time Python. Con la parola chiave di attesa, abbiamo definito l'asyncio.raccogliere la funzione per raccogliere un risultato dei desideri della funzione. Abbiamo anche registrato il tempo trascorso per l'esecuzione del codice principale.
Nell'output, abbiamo le coroutine generate due volte contemporaneamente dalla funzione Wishes (). L'output del codice precedentemente menzionato viene visualizzato correttamente nella seguente immagine:
Esempio 2:
L'esecuzione di diverse coutine può essere programmata dinamicamente utilizzando il metodo di raccolta Asyncio come dimostrato in questo esempio. Seguendo la raccolta riuscita di tutti i risultati di co-routine, la chiamata di attesa fornisce i valori come risultati e li stampa.
Async def aggiungi (a: int, b: int):
restituire a + b
async def get_result ():
Input = [(4, 5), (6, 6), (7, 8), (9, 4)]
compiti = [asyncio.create_task (aggiungi (a, b)) per a, b negli ingressi]
Risultato = asyncio.raccogli (*compiti)
print ("Risultato:")
Stampa (attesa risultato)
Asyncio.run (get_result ())
In questo particolare esempio, abbiamo incluso il modulo Asyncio per l'utilizzo dell'Asyncio.Raccogli la funzione. Quindi, abbiamo definito una funzione di asincroni per l'aggiunta. Abbiamo generato la funzione Aggiungi Async e impostato le due variabili A e B con il tipo di dati INT nella funzione Aggiungi. Con il comando di ritorno, abbiamo aggiunto queste variabili con l'operatore più.
Dopo aver impostato la coroutine, abbiamo creato un'altra funzione per programmare il ciclo dell'evento nella coroutine. La funzione è denominata "get_result" in cui abbiamo inizializzato l'elenco con gli input variabili. Successivamente, abbiamo creato l'elenco delle attività nella variabile dell'attività. Con l'asyncio.Raccogli la funzione, abbiamo raccolto il risultato dell'elenco delle attività passando l'attività del puntatore a quella funzione. Abbiamo finalmente stampato il risultato. Il seguente elenco di attività è ottenuto dal programma precedente:
Esempio 3:
Abbiamo raccolto il risultato del compito futuro passando il compito futuro nell'Asyncio.Raccogli la funzione. Il futuro designa un calcolo attualmente in esecuzione o che sarà pianificato in futuro. Un eventuale risultato di una procedura asincrona è rappresentato da un oggetto in attesa di basso livello.
da asyncio import future
Async Def Function1 (Future):
print ("function1 dormirà per 3 secondi")
Aspetta Asyncio.sonno (3)
print ("function1 risolvendo il futuro")
futuro.Fatto()
futuro.set_result ("Future è risolto")
Async Def Function2 (Future):
Print ("Function2 Aspetterà il futuro")
Aspetta il futuro
print ("function2 trova il futuro risolto")
Async def main ():
Future = Future ()
RISULTATI = AVVEASYNCIO.Gather (function2 (futuro), function1 (futuro))
Se __Name __ == "__ main___":
Asyncio.run (main ())
Stampa ("Main Terminated")
Qui, abbiamo incluso per la prima volta il modulo Asyncio e il modulo futuro dell'Asyncio. Quindi, abbiamo definito la coroutine come "funzione1" e abbiamo superato il futuro. Quindi, all'interno di quella coroutine, abbiamo chiamato la funzione del sonno per la sospensione della coroutine. Abbiamo chiamato le chiamate di sistema System Done e Set_Result in futuro. Lì, abbiamo un'altra coroutine che si chiama "funzione2" e prende anche il futuro come argomento. Abbiamo chiamato il comando di attesa in futuro per essere risolti.
Successivamente, abbiamo la definizione principale asincrima che abbiamo chiamato la funzione futura e otteniamo il risultato dal futuro dall'asincia.Metodo di raccolta. Alla fine, abbiamo stampato l'istruzione quando la funzione principale è stata terminata. L'output del codice precedentemente menzionato viene visualizzato correttamente nella seguente immagine:
Conclusione
Gather è forte, come puoi vedere. Possiamo richiedere succintamente diverse risorse contemporaneamente, il che è un evento tipico nei programmi Web. Con l'aiuto dell'asincia di Python.Raccogli il modulo integrato, la programmazione asincrona è stata presentata in questo tutorial. Abbiamo raccolto i risultati di coroutine, compiti e futuri. Un codice simultaneo potrebbe essere la scelta migliore quando è necessario ottimizzare le prestazioni per attività particolari, poiché in precedenza abbiamo discusso di come eseguire le numerose coroutine utilizzando contemporaneamente l'asyncio.Raccogli metodi.