Asyncio-biblioteket introduceras i python 3.4 för att utföra samtidiga program med en tråd. Detta bibliotek är populärt än andra bibliotek och ramar för sin imponerande hastighet och olika användning. Detta bibliotek används i python för att skapa, köra och strukturera coroutines och hantera flera uppgifter samtidigt utan att göra uppgifterna parallellt. De viktigaste delarna av detta bibliotek definieras nedan:

Coroutine: Den del av koden som kan pausas och återupptas i skript med flera trådar kallas coroutine. coroutines arbetar tillsammans i flera trådade program. När en coroutine pausar kan andra coroutine köra.

Eventslinga: Den används för att starta körningen av coroutines och hantera input / output-operationer. Det tar flera uppgifter och slutför dem.

Uppgift: Körningen och resultatet av coroutines definieras av uppgifterna. Du kan tilldela flera antal uppgifter med hjälp av asyncio-biblioteket och köra uppgifterna asynkront.

Framtida: Det fungerar som en framtida lagring där resultatet av coroutines kommer att lagras efter slutförandet. Detta är användbart när någon coroutine behöver vänta på resultatet av annan coroutine.

Hur du kan implementera ovanstående begrepp för asyncio-biblioteket visas i denna handledning med hjälp av några enkla exempel.

Exempel 1: Skapa en enda coroutine med en enda uppgift

Skapa en fil med namnet async1.py och lägg till följande kod. asyncio-biblioteket importeras för att använda funktionerna i detta bibliotek. Lägg till funktionen deklareras för att beräkna summan av ett visst antal intervall. Nummerområdet från 1 till 101 tilldelas av uppgiften med en sekund fördröjning. Eventslingan förklaras att den kommer att köras tills alla uppgifter för huvudmetoden är slutförda. Efter beräkning av värdet väntar funktionen en sekund och skriver ut resultatet.

importera asyncio
async def add (start, end, wait):
#Initialize sum variable
summa = 0
#Beräkna summan av alla siffror
för n inom räckvidd (start, slut):
summa + = n
#Vänta i tilldelade sekunder
väntar på asyncio.sova (vänta)
# Skriv ut resultatet
skriva ut (f'Sum från start till end är sum ')
async def huvud ():
#Tilldela en enda uppgift
uppgift = loop.create_task (lägg till (1,101,1))
#Kör uppgiften asynkront
väntar på asyncio.vänta ([uppgift])
om __name__ == '__main__':
#Declare event loop
loop = asyncio.get_event_loop ()
#Kör koden tills du har slutfört alla uppgifter
slinga.run_until_complete (main ())
#Stäng slingan
slinga.stänga()

Produktion:

$ python3 async1.py

Utgången visar summan av 1 till 101 som är 5050.

Exempel 2: Skapa flera koroutiner

Användningen av asyncio-biblioteket rensas när du kör flera coroutines samtidigt. Skapa en ny fil med namnet async2.py och lägg till följande kod. Tre uppgifter genereras med tre olika intervall och väntvärden i huvud () metod. Första uppgiften beräknar summan från 5 till 500000 genom att vänta 3 sekunder, den andra uppgiften beräknar summan från 2 till 300000 genom att vänta 2 sekunder och den tredje uppgiften beräknar summan från 10 till 1000 genom att vänta 1 sekunder. Uppgiften med lågt väntande värde kommer att slutföras först och uppgiften med högt väntande värde kommer slutligen att slutföras.

importera asyncio
async def add (start, end, wait):
#Initialize sum variable
summa = 0
#Beräkna summan av alla siffror
för n inom räckvidd (start, slut):
summa + = n
#Vänta i tilldelade sekunder
väntar på asyncio.sova (vänta)
#Skriv ut resultatet
skriva ut (f'Sum från start till end är sum ')
async def huvud ():
#Assign first task
uppgift1 = slinga.create_task (lägg till (5.500.000,3))
#Tilldela andra uppgiften
uppgift2 = slinga.create_task (lägg till (2.300.000,2))
#Tilldela tredje uppgift
task3 = loop.create_task (lägg till (10,1000,1))
#Kör uppgifterna asynkront
väntar på asyncio.vänta ([uppgift1, uppgift2, uppgift3])
om __name__ == '__main__':
#Declare event loop
loop = asyncio.get_event_loop ()
#Kör koden tills du har slutfört alla uppgifter
slinga.run_until_complete (main ())
#Stäng slingan
slinga.stänga()

Produktion:

$ python3 async1.py

Utgången visar att uppgift 3 slutförts först eftersom väntetiden för den här uppgiften var bara 1 sekund och uppgift 1 slutfördes senast eftersom väntetiden för denna uppgift var 3 sekunder.

Exempel 3: coroutines med framtiden

Det här exemplet visar användningen av framtida objekt i asyncio-biblioteket. Skapa en ny fil med namnet async3.py och lägg till följande kod. Två uppgifter tilldelas för framtiden i detta exempel. visa_meddelande funktionen deklareras här för att skriva ut meddelandet innan coroutine körs och efter genomförandet. Första uppgiften väntar i 2 sekunder och slutför sist. Den andra uppgiften väntar i 1 sekund och slutför först.

importera asyncio
async def show_message (nummer, vänta):
# Skriv ut meddelandet
skriva ut (f'Task number körs ')
#Vänta i tilldelade sekunder
väntar på asyncio.sova (vänta)
skriva ut (f'Task number är klar ')
async def stopp_efter (när):
väntar på asyncio.sova (när)
slinga.sluta()
async def huvud ():
#Assign first task
uppgift1 = asyncio.försäkra_futur (visa_meddelande (1,2))
skriva ut ('Schema 1')
#Tilldela andra uppgiften
task2 = asyncio.försäkra_futur (visa_meddelande (2,1))
skriva ut ('Schema 2')
#Kör uppgifterna asynkront
väntar på asyncio.vänta ([uppgift1, uppgift2])
om __name__ == '__main__':
#Declare event loop
loop = asyncio.get_event_loop ()
#Kör koden för huvudmetoden tills du har slutfört alla uppgifter
slinga.run_until_complete (main ())

Produktion:

$ python3 async3.py

Det visas i utgången att uppgift 1 startas först och slutförs senast, och uppgift 2 startas senare men slutfördes först för kort väntetid.

Slutsats

Det grundläggande begreppet asynkron programmering med asyncio-biblioteket för python förklaras här. Hoppas, du kommer att kunna skriva flertrådig kod i python efter att ha övat på exemplen i denna handledning.