Python asyncio samles

Asynkron inngang/utgang eller Asyncio er en programmeringsmetodikk som bruker en hendelsessløyfe eller en enkelt tråd for å oppnå høy samtidighet. Python er ikke det eneste språket eller rammeverket som bruker tilnærmingen; JavaScripts Nodejs er kanskje den mest kjente. Vi bruker Asyncio i Python snarere enn multithreading fordi det er ganske utfordrende å skrive en trådsikker programmering. Det er betydelig vanskeligere å møte løpsproblemer når du bruker asynkron programmering, siden du kan finne spesifikt hvor koden vil endre seg fra en oppgave til den neste.På grunn av kravet om at hver tråd har sin bunke, bruker tråder en stor mengde data. Async -programmering holder stabelen liten ved å slappe av den kontinuerlig mellom operasjonene, slik at alle programmene kan dele den samme stabelen. Plattformen trenger mer minne for å støtte trådene fordi de er OS -konstruksjoner. Asynkrone oppgaver har ikke dette problemet.

Her vil vi diskutere Asyncio -funksjonen - samles. To avgjørende funksjoner bør forstås når du lærer Python Asyncio -modulen. Det første alternativet er kjørt, som er en enkel metode for å kjøre en koroutine, og det andre alternativet er samlet. Den nåværende konteksten starter på nytt når alle korutinene er fullført, slik at du kan starte en rekke av dem samtidig ved å bruke Gathering.

Hver koroutines svar er oppført i returverdien. Som navnet tilsier, asyncio.Samle () konsentrerer seg stort sett om å samle resultatene. Det venter på mange fremtider og returnerer deretter resultatene i en spesifikk sekvens. Asyncio.Samle () Avbestander alle ufullstendige jobber den samler seg hvis det blir kansellert av seg selv.

Syntaks av Asyncio.Samle i Python

Asyncio.Samle () aksepterer en enkelt eller flere ventabler som *Args, innkapsler dem i oppgaver hvis det er aktu. Resultatene fra hver ventable blir deretter returnert i den rekkefølgen du passerte dem:

# F_Output, G_Output = Await Asyncio.Samle (f (), g ())

Du kan også gi unntak for retur = sant, der tilfellene er levert sammen med de vanlige resultatene, og du må selv bestemme om de var vellykkede.

Eksempel 1:
Asyncio.Samle () -funksjonen kan brukes til å kjøre mange korutiner samtidig. Koroutiner kjøres samtidig av denne funksjonen som parametere.

Importer asyncio
Importer tid
async def wishes ():
trykk ("Hei")
AwaitaSyncio.søvn (1)
trykk ("Ha en fin dag")
async def main ():
Begynn = tid.tid()
AwaitaSyncio.Samle (ønsker (), ønsker ())
Gåret = tid.Tid () - Begynn
print (f "__name__ utført i Elapsed: 0.2f sekunder.")
asyncio.løp (main ()))

Her importerte vi to moduler: Asyncio og Python -tiden. Deretter definerte vi en funksjon med navnet "Wishes". Vi etablerte ASYNC -funksjonsdefinisjonen. Async -definisjon inneholder bare asynkron kode; All annen kode er synkron. Inne. Asyncio.Søvnfunksjonen ble kalt og verdien for suspensjonen av den valgte tråden ble satt ved hjelp av det avvente nøkkelordet. Venter returnerer kontrollen til hendelsessløyfen under en funksjonsanrop.

Etter det konstruerte vi en annen async def -funksjon som hoved (). Inne i denne funksjonen setter vi variabelen der tidsfunksjonen fra Python Time -modulen kalles. Med det avvente nøkkelordet definerte vi asyncio.Samle funksjon for å samle et resultat av funksjonsønskene. Vi registrerte også tiden for utførelsen av hovedkoden.

I utgangen har vi korutinene generert to ganger samtidig fra ønsker () -funksjonen. Utgangen fra koden som tidligere er nevnt vises vellykket i følgende bilde:

Eksempel 2:
Utførelsen av flere medruter kan planlegges dynamisk ved hjelp av Asyncio-samlingen-metoden som demonstrert i dette eksemplet. Etter den vellykkede samlingen av alle medrutine-resultater, gir Awent Call verdiene som utfall og skriver dem ut.

Importer asyncio
async def add (a: int, b: int):
Returner A + B
async def get_result ():
innganger = [(4, 5), (6, 6), (7, 8), (9, 4)]
oppgaver = [asyncio.create_task (legg til (a, b)) for a, b i innganger]
Resultat = asyncio.Samle (*oppgaver)
trykk ("Resultat:")
trykk (venter resultat)
asyncio.løp (get_result ())

I dette eksemplet inkluderte vi Asyncio -modulen for å bruke Asyncio.Samle funksjon. Deretter definerte vi en async -funksjon for tillegg. Vi genererte ADD -async -funksjonen og satte de to variablene A og B med Int -datatypen til ADD -funksjonen. Med returkommandoen la vi til disse variablene med Plus -operatøren.

Etter å ha satt coroutine, opprettet vi en annen funksjon for å planlegge hendelsessløyfen i Coroutine. Funksjonen heter “get_result” der vi initialiserte listen med de variable inngangene. Etter det opprettet vi oppgavelisten i oppgavevariabelen. Med asyncio.Samle funksjon, vi har samlet resultatet av oppgavelisten ved å sende pekeroppgaven til den funksjonen. Vi skrev endelig ut resultatet. Følgende oppgaveliste er innhentet fra forrige program:

Eksempel 3:
Vi samlet resultatet av den fremtidige oppgaven ved å overføre den fremtidige oppgaven i Asyncio.Samle funksjon. Fremtiden betegner en beregning som for tiden kjører eller som vil bli planlagt i fremtiden. Et eventuelt resultat av en asynkron prosedyre er representert av et unikt lavt nivå og venter på lavt nivå.

Importer asyncio
Fra Asyncio importerer fremtid
async def funksjon1 (fremtid):
Print ("Function1 vil sove i 3 sekunder")
Venter Asyncio.søvn (3)
Print ("Function1 Løsing av fremtiden")
framtid.gjort ()
framtid.set_result ("fremtiden er løst")
async def funksjon2 (fremtid):
Print ("Function2 vil vente på fremtiden")
Venter fremtid
Print ("Function2 finner fremtiden løst")
async def main ():
fremtid = fremtid ()
Resultater = AwaitAsyncio.Samle (Function2 (Future), Function1 (Future))
Hvis __navn __ == "__ main___":
asyncio.løp (main ()))
Print ("Hoved avsluttet")

Her inkluderte vi først Asyncio -modulen og den fremtidige modulen fra Asyncio. Deretter definerte vi coroutine som "funksjon1" og passerte fremtiden. Så, inni den koroutinen, kalte vi søvnfunksjon for suspensjon av koroutine. Vi ringte System Call og Set_Result System -anrop i fremtiden. Der har vi en annen koroutine som heter “Function2”, og det tar også fremtiden som et argument. Vi kalte den avvente kommandoen i fremtiden for å bli løst.

Etter det har vi den async hoveddefinisjonen som vi kalte fremtidens funksjon, og får resultatet fra fremtiden av Asyncio.Samle metode. Til slutt trykket vi uttalelsen da hovedfunksjonen ble avsluttet. Utgangen fra koden som tidligere er nevnt vises vellykket i følgende bilde:

Konklusjon

Samle er sterk, som du kan se. Vi kan kortfattet be om flere ressurser samtidig, noe som er en typisk forekomst i webprogrammene. Ved hjelp av Python Asyncio.Samle innebygd modul, asynkron programmering ble presentert i denne opplæringen. Vi samlet resultatene av koroutiner, oppgaver og futures. En samtidig kode kan være det beste valget ditt når du trenger å optimalisere ytelsen for spesielle aktiviteter, ettersom vi tidligere diskuterte hvordan vi kan utføre de mange korutiner samtidig ved å bruke Asyncio.Samle metoder.