Asyncio-biblioteket introduceres i python 3.4 til at udføre samtidige programmer med enkelt gevind. Dette bibliotek er populært end andre biblioteker og rammer for sin imponerende hastighed og forskellige anvendelser. Dette bibliotek bruges i python til at oprette, udføre og strukturere coroutines og håndtere flere opgaver samtidigt uden at udføre opgaverne parallelt. De vigtigste dele af dette bibliotek er defineret nedenfor:

Coroutine: Den del af koden, der kan pauses og genoptages i multitrådet script kaldes coroutine. coroutines arbejder sammen i multi-threaded program. Når en coroutine holder pause, kan anden coroutine udføre.

Begivenhedssløjfe: Det bruges til at starte udførelsen af ​​coroutines og håndtere input / output-operationer. Det tager flere opgaver og udfør dem.

Opgave: Udførelsen og resultatet af coroutines defineres af opgaverne. Du kan tildele flere antal opgaver ved hjælp af asyncio-biblioteket og køre opgaverne asynkront.

Fremtid: Det fungerer som en fremtidig opbevaring, hvor resultatet af coroutines opbevares efter afslutning. Dette er nyttigt, når enhver coroutine kræver at vente på resultatet af anden coroutine.

Hvordan du kan implementere ovenstående begreber i asyncio-biblioteket vises i denne vejledning ved hjælp af nogle enkle eksempler.

Eksempel 1: Opret enkelt coroutine med en enkelt opgave

Opret en fil med navnet async1.py og tilføj følgende kode. asyncio-biblioteket importeres for at bruge funktionerne i dette bibliotek. tilføje funktion erklæres for at beregne summen af ​​et bestemt rækkeområde. Nummerområdet fra 1 til 101 tildeles af opgaven med et sekund forsinkelse. Begivenhedssløjfen erklæres, at den vil køre, indtil alle hovedmetodens opgaver er afsluttet. Efter beregning af værdien venter funktionen i et sekund og udskriver resultatet.

importer asyncio
async def tilføj (start, slut, vent):
#Initialiser sumvariabel
sum = 0
#Beregn summen af ​​alle tal
for n inden for rækkevidde (start, slut):
sum + = n
# Vent i tildelte sekunder
afventer asyncio.sove (vent)
# Udskriv resultatet
print (f'Sum fra start til end er sum ')
async def hoved ():
#Tildel en enkelt opgave
opgave = løkke.create_task (tilføj (1.101,1))
# Kør opgaven asynkront
afventer asyncio.vent ([opgave])
hvis __name__ == '__main__':
#Deklarer hændelsesløkke
loop = asyncio.get_event_loop ()
# Kør koden, indtil du fuldfører al opgave
løkke.run_until_complete (main ())
# Luk sløjfen
løkke.tæt()

Produktion:

$ python3 async1.py

Outputtet viser summen af ​​1 til 101, som er 5050.

Eksempel 2: Opret flere coroutines

Brugen af ​​asyncio-biblioteket ryddes, når du kører flere coroutines samtidigt. Opret en ny fil med navnet async2.py og tilføj følgende kode. Tre opgaver genereres med tre forskellige intervaller og venteværdier i hoved () metode. Første opgave beregner summen fra 5 til 500000 ved at vente 3 sekunder, anden opgave beregner summen fra 2 til 300000 ved at vente 2 sekunder, og den tredje opgave beregner summen fra 10 til 1000 ved at vente 1 sekund. Opgaven med lave venteværdier afsluttes først, og opgaven med høj venteværdi afsluttes endelig.

importer asyncio
async def tilføj (start, slut, vent):
#Initialiser sumvariabel
sum = 0
#Beregn summen af ​​alle tal
for n inden for rækkevidde (start, slut):
sum + = n
# Vent i tildelte sekunder
afventer asyncio.sove (vent)
# Udskriv resultatet
print (f'Sum fra start til end er sum ')
async def hoved ():
#Tildel første opgave
task1 = loop.create_task (tilføj (5.500.000,3))
#Tildel anden opgave
task2 = loop.create_task (tilføj (2.300.000,2))
#Tildel tredje opgave
task3 = loop.create_task (tilføj (10.1000,1))
#Kør opgaverne asynkront
afventer asyncio.vent ([opgave1, opgave2, opgave3])
hvis __name__ == '__main__':
#Deklarer hændelsessløjfe
loop = asyncio.get_event_loop ()
# Kør koden, indtil du fuldfører al opgave
løkke.run_until_complete (main ())
#Luk løkken
løkke.tæt()

Produktion:

$ python3 async1.py

Outputtet viser, at opgave3 er afsluttet først, fordi ventetiden for denne opgave kun var 1 sekund, og opgave1 er afsluttet sidst, fordi ventetiden for denne opgave var 3 sekunder.

Eksempel 3: coroutines med fremtiden

Dette eksempel viser brugen af ​​fremtidigt objekt i asyncio-biblioteket. Opret en ny fil med navnet async3.py og tilføj følgende kode. To opgaver tildeles til fremtiden i dette eksempel. vis besked funktion erklæres her for at udskrive beskeden, før den udføres coroutine og efter afslutningen af ​​udførelsen. Første opgave venter i 2 sekunder og afsluttes sidste. Anden opgave venter i 1 sekund og gennemføres først.

importer asyncio
async def show_message (nummer, vent):
# Udskriv meddelelsen
print (f'Task number kører ')
# Vent i tildelte sekunder
afventer asyncio.sove (vent)
udskriv (f'Task nummer er udført ')
async def stop_after (når):
afventer asyncio.søvn (når)
løkke.hold op()
async def hoved ():
#Tildel første opgave
task1 = asyncio.sikre_futur (show_message (1,2))
print ('Tidsplan 1')
#Tildel anden opgave
task2 = asyncio.sikre_future (show_message (2,1))
print ('Tidsplan 2')
#Kør opgaverne asynkront
afventer asyncio.vent ([opgave1, opgave2])
hvis __name__ == '__main__':
#Deklarer hændelsessløjfe
loop = asyncio.get_event_loop ()
# Kør koden for hovedmetoden, indtil du fuldfører al opgave
løkke.run_until_complete (main ())

Produktion:

$ python3 async3.py

Det vises i output, at opgave1 startes først og afsluttes sidst, og opgave2 startes senere, men afsluttes først i kort ventetid.

Konklusion

Det grundlæggende koncept for asynkron programmering ved hjælp af asyncio-biblioteket med python forklares her. Håber, du vil være i stand til at skrive kode med flere tråde i python efter at have øvet eksemplerne på denne vejledning.