Asyncio Library blir introdusert i Python 3.4 For å utføre entrådede samtidige programmer. Dette biblioteket er populært enn andre biblioteker og rammer for sin imponerende hastighet og forskjellige bruk. Dette biblioteket brukes i Python for å lage, utføre og strukturere korutiner og håndtere flere oppgaver samtidig uten å gjøre oppgavene parallelt. De viktigste delene av dette biblioteket er definert nedenfor:

Coroutine: Den delen av koden som kan pause og gjenopptas i flertrådet skript, kalles coroutine. Coroutines fungerer samarbeidsvillig i multitreftet program. Når en coroutine tar en pause, kan annen koroutine utføre.

Event Loop: Det brukes til å starte utførelsen av korutiner og håndtere inngangs-/utgangsoperasjoner. Det tar flere oppgaver og fullfører dem.

Oppgave: Utførelsen og resultatet av korutiner er definert av oppgavene. Du kan tilordne flere antall oppgaver ved hjelp av Asyncio -biblioteket og kjøre oppgavene asynkront.

Framtid: Det fungerer som en fremtidig lagring der resultatet av korutiner vil lagre etter fullføring. Dette er nyttig når noen koroutine krever å vente på resultatet av annen koroutine.

Hvordan du kan implementere de ovennevnte konseptene til Asyncio -biblioteket vises i denne opplæringen ved å bruke noen enkle eksempler.

Eksempel 1: Lag enkelt koroutine med en enkelt oppgave

Lag en fil som heter async1.py og legg til følgende kode. Asyncio Library importeres for å bruke funksjonene til dette biblioteket. Legg til Funksjon er erklært å beregne summen av et bestemt tallområde. Tallet fra 1 til 101 tildeles av oppgaven med ett sekund forsinkelse. Arrangementssløyfen er erklært at den vil kjøre til alle oppgavene til hovedmetoden er fullført. Etter å ha beregnet verdien, vil funksjonen vente i ett sekund og skrive ut resultatet.

Importer asyncio
async def add (start, slutt, vent):
#Initialiser sumvariabel
Sum = 0
#Kalkulere summen av alle tall
for n i rekkevidde (start, slutt):
sum += n
#Wait for tildelte sekunder
Venter Asyncio.Sov (vent)
#Trykk resultatet
print (f'sum fra start til end er sum ')
async def main ():
#Assign en enkelt oppgave
Oppgave = loop.create_task (legg til (1,101,1))
#Run oppgaven asynkront
Venter Asyncio.Vent ([oppgave])
if __name__ == '__main__':
#Declare Event Loop
loop = asyncio.get_event_loop ()
#Run koden til den er fullført all oppgave
Løkke.run_until_complete (main ())
#Løk sløyfen
Løkke.Lukk()

Produksjon:

$ python3 async1.py

Utgangen viser summen 1 til 101 som er 5050.

Eksempel-2: Lag flere korutiner

Bruken av Asyncio -biblioteket vil bli ryddet når du kjører flere korutiner samtidig. Lag en ny fil som heter async2.py og legg til følgende kode. Tre oppgaver genereres med tre forskjellige områder og venteverdier i hoved() metode. Første oppgave vil beregne summen fra 5 til 500000 ved å vente 3 sekunder, andre oppgave vil beregne summen fra 2 til 300000 ved å vente 2 sekunder og tredje oppgave vil beregne summen fra 10 til 1000 ved å vente 1 sekunder. Oppgaven med lave ventetidsverdier vil fullføre med det første, og oppgaven med høy venteverdi vil til slutt fullføre.

Importer asyncio
async def add (start, slutt, vent):
#Initialiser sumvariabel
Sum = 0
#Kalkulere summen av alle tall
for n i rekkevidde (start, slutt):
sum += n
#Wait for tildelte sekunder
Venter Asyncio.Sov (vent)
#Trykk resultatet
print (f'sum fra start til end er sum ')
async def main ():
#AKSIGN FØRSTE oppgave
Oppgave1 = loop.create_task (legg til (5,500000,3))
#Assign Second Task
Oppgave2 = loop.create_task (legg til (2,300000,2))
#Assign Tredje oppgave
Oppgave3 = loop.create_task (legg til (10,1000,1))
#Run oppgavene asynkront
Venter Asyncio.Vent ([Task1, Task2, Task3])
if __name__ == '__main__':
#Declare Event Loop
loop = asyncio.get_event_loop ()
#Run koden til den er fullført all oppgave
Løkke.run_until_complete (main ())
#Løk sløyfen
Løkke.Lukk()

Produksjon:

$ python3 async1.py

Utgangen viser at Task3 er fullført først fordi ventetiden for denne oppgaven bare var 1 sekund og Task1 er fullført sist fordi ventetiden for denne oppgaven var 3 sekunder.

Eksempel-3: Coroutines med fremtiden

Dette eksemplet viser bruken av fremtidig objekt av Asyncio -biblioteket. Lag en ny fil som heter async3.py og legg til følgende kode. To oppgaver er tildelt for fremtiden i dette eksemplet. Vis melding Funksjon er her erklært for å skrive ut meldingen før du utfører koroutinen og etter å ha fullført utførelsen. Første oppgave vil vente i 2 sekunder og fullføre sist. Andre oppgave vil vente i 1 sekunder og fullføre først.

Importer asyncio
async def show_message (nummer, vent):
#Trykk meldingen
print (f'task nummer kjører ')
#Wait for tildelte sekunder
Venter Asyncio.Sov (vent)
print (f'task nummer er fullført ')
async def stop_after (når):
Venter Asyncio.Sov (når)
Løkke.Stoppe()
async def main ():
#AKSIGN FØRSTE oppgave
Oppgave1 = asyncio.Sikre_futur (Show_Message (1,2))
Print ('Plan 1')
#Assign Second Task
Oppgave2 = asyncio.Sikre_futur (Show_Message (2,1))
Print ('Plan 2')
#Run oppgavene asynkront
Venter Asyncio.Vent ([Task1, Task2])
if __name__ == '__main__':
#Declare Event Loop
loop = asyncio.get_event_loop ()
#Run koden for hovedmetode til du fullfører all oppgave
Løkke.run_until_complete (main ())

Produksjon:

$ python3 async3.py

Det vises i utgangen at oppgaven1 startes først og fullføres sist, og Task2 startes senere, men fullføres først for kort ventetid.

Konklusjon

Det grunnleggende konseptet med asynkron programmering ved bruk av Asyncio Library of Python er forklart her. Håper, du vil kunne skrive flertrådet kode i Python etter å ha praktisert eksemplene på denne opplæringen.