Genopfriskning af async/await i Python
Gennemgå de centrale begreber inden for asynkron programmering i Python, herunder event loops og coroutines.
Genopfriskning af async/await i Python er en gratis Bootcamp i FastAPI-backendudvikling-lektion på CoddyKit. Dette er lektion 1 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Bootcamp i FastAPI-backendudvikling, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Bootcamp i FastAPI-backendudvikling-kurset indeholder 4 lektioner i alt.
Introduktion til asynkron Python
Velkommen til den asynkrone programmeringsverden i Python! Det giver dine programmer mulighed for at gøre flere ting uden at vente på, at hver opgave bliver færdig, før den næste startes.
Det er særligt nyttigt til opgaver, der indebærer ventetid, som netværksforespørgsler eller læsning og skrivning af filer, hvor programmet ellers bare ville stå inaktivt.
Synkron kontra asynkron: Ventetidsspillet
Forestil dig, at du laver aftensmad:
- Synkron: Du hakker grøntsager, venter på, at de bliver tilberedt, og vasker derefter op. Der foregår kun én opgave ad gangen.
- Asynkron: Du hakker grøntsager, lægger dem på komfuret, og mens de bliver tilberedt (venter), begynder du at vaske op. Du gør flere ting "samtidigt" ved at skifte mellem opgaverne, når en af dem venter.
Asynkron programmering hjælper dit program med at holde sig aktivt i stedet for at vente!
Nøgleordet `async`: Korutiner
I Python bruger vi nøgleordet async til at definere en særlig type funktion, der kaldes en korutine. En korutine er en funktion, der kan sættes på pause og genoptages.
Den kører ikke med det samme, når den kaldes. I stedet returnerer den et "korutineobjekt", som skal planlægges af en hændelsesløkke for at køre.
import asyncio
async def hello_world():
print("Hello, async world!")
# Calling it directly doesn't run it!
# It returns a coroutine object.
coro_obj = hello_world()
print(f"Type of coro_obj: {type(coro_obj)}")
# To actually run it, you need an event loop.
# We'll see how in a moment!
`await`: Sæt udførelsen på pause
Nøgleordet await bruges inde i en async def-funktion (en korutine) til at sætte udførelsen på pause, indtil en anden ventbar værdi (som en anden korutine eller en Future) er færdig.
Når en korutine bruger await på noget, giver den midlertidigt kontrollen tilbage til hændelsesløkken, så andre opgaver kan køre. Det er afgørende for ikke-blokerende adfærd.
import asyncio
async def cook_rice():
print("Starting to cook rice...")
await asyncio.sleep(2) # Simulate 2 seconds of cooking
print("Rice is cooked!")
async def chop_veg():
print("Chopping vegetables...")
await asyncio.sleep(1) # Simulate 1 second of chopping
print("Vegetables chopped!")
async def main_meal():
await chop_veg() # Wait for chopping to finish
await cook_rice() # Then wait for rice to cook
print("Dinner is ready!")
# This will run sequentially for now.
# We'll make it concurrent soon!
asyncio.run(main_meal())
Hændelsesløkken: Orkestratoren
Tænk på hændelsesløkken som dirigenten i et orkester. Den har ansvaret for:
- At planlægge, hvornår korutiner kører.
- At håndtere I/O-hændelser (som når netværksdata ankommer).
- At skifte mellem opgaver, når en af dem venter (f.eks. på grund af
await).
Pythons asyncio-modul leverer infrastrukturen til hændelsesløkken.
Kør asynkron kode med `asyncio.run()`
Hvis du vil udføre et asynkront program, bruger du typisk asyncio.run(). Denne funktion:
- Henter en hændelsesløkke til den aktuelle tråd.
- Kører den angivne korutine, indtil den er færdig.
- Styrer hændelsesløkkens levetid.
Det er den enkleste måde at starte din asynkrone funktion på øverste niveau.
import asyncio
async def say_hello():
print("Hello from coroutine!")
await asyncio.sleep(0.5) # Wait for 0.5 seconds
print("Goodbye from coroutine!")
async def main():
print("Starting async program...")
await say_hello()
print("Async program finished.")
# This is the entry point for your async application
asyncio.run(main())
Simulering af ikke-blokerende handlinger
asyncio.sleep() er en "ventbar" værdi, der sætter den aktuelle korutine på pause i et angivet tidsrum. Det afgørende er, at den ikke blokerer hele programmet. Mens én korutine sover, kan hændelsesløkken skifte til andre korutiner og køre dem.
Det er sådan, asynkron programmering opnår samtidighed uden at have brug for flere tråde.
import asyncio
import time
async def task_one():
print(f"Task One started at {time.strftime('%X')}")
await asyncio.sleep(2)
print(f"Task One finished at {time.strftime('%X')}")
async def task_two():
print(f"Task Two started at {time.strftime('%X')}")
await asyncio.sleep(1)
print(f"Task Two finished at {time.strftime('%X')}")
async def main():
start_time = time.monotonic()
await task_one()
await task_two()
end_time = time.monotonic()
print(f"Total time: {end_time - start_time:.2f} seconds")
asyncio.run(main())
Samtidig udførelse med `asyncio.gather`
Hvis flere korutiner virkelig skal køre samtidigt (det vil sige, at deres udførelse kan flettes ind i hinanden, når en af dem venter), bruger vi asyncio.gather().
asyncio.gather() tager flere ventbare værdier og planlægger dem til at køre "parallelt" på hændelsesløkken, mens den venter på, at de alle bliver færdige.
import asyncio
import time
async def fetch_data(delay, name):
print(f"Fetching {name} data... (starts at {time.strftime('%X')})")
await asyncio.sleep(delay) # Simulate network request
print(f"Finished {name} data. (ends at {time.strftime('%X')})")
return f"Data from {name}"
async def main():
start_time = time.monotonic()
# Run fetch_data for 'users' and 'products' concurrently
user_data, product_data = await asyncio.gather(
fetch_data(2, "users"),
fetch_data(1, "products")
)
end_time = time.monotonic()
print(f"\nReceived: {user_data}, {product_data}")
print(f"Total time: {end_time - start_time:.2f} seconds")
asyncio.run(main())
Tjek af begreberne async/await
Hvilke af følgende udsagn om Pythons nøgleord async og await er SANDE?
Opsummering og næste trin
Fremragende! Du har genopfrisket din forståelse af Pythons grundlæggende asynkrone funktioner:
- Asynkron programmering hjælper med at håndtere I/O-bundne opgaver effektivt.
async defdefinerer korutiner, altså funktioner, der kan sættes på pause.awaitsætter en korutine på pause og giver kontrollen til hændelsesløkken.- Hændelsesløkken orkestrerer udførelsen af korutiner.
asyncio.run()starter din asynkrone applikation.asyncio.gather()gør det muligt at køre flere korutiner samtidigt.
Nu skal vi se, hvordan FastAPI udnytter disse effektive begreber til at bygge højtydende web-API'er!
Lær Bootcamp i FastAPI-backendudvikling med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 21
- Lektioner
- 84
Ofte stillede spørgsmål
Er lektionen “Genopfriskning af async/await i Python” gratis?
Ja — alle 3 lektioner i læringssporet Bootcamp i FastAPI-backendudvikling, inklusive “Genopfriskning af async/await i Python”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Bootcamp i FastAPI-backendudvikling-kurset indeholder 4 lektioner i alt.
Hvad lærer jeg i “Genopfriskning af async/await i Python”?
Gennemgå de centrale begreber inden for asynkron programmering i Python, herunder event loops og coroutines. Du øver dig i Bootcamp i FastAPI-backendudvikling med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på Bootcamp i FastAPI-backendudvikling?
Der kræves ingen tidligere erfaring. Bootcamp i FastAPI-backendudvikling på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 1 af 4.
Hvor lang tid tager lektionen “Genopfriskning af async/await i Python”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne Bootcamp i FastAPI-backendudvikling-lektion?
Ja. Alle Bootcamp i FastAPI-backendudvikling-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.
Alle lektioner i dette kursus
- Genopfriskning af async/await i Python
- FastAPI og asynkrone operationer
- Udførelse af baggrundsopgaver
- WebSockets til realtidskommunikation