Revisão de Async/Await em Python
Revise os conceitos fundamentais da programação assíncrona em Python, incluindo ciclos de eventos e corrotinas.
Revisão de Async/Await em Python é uma aula grátis de FastAPI Backend Development Bootcamp no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de FastAPI Backend Development Bootcamp, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de FastAPI Backend Development Bootcamp inclui 4 aulas no total.
Partes desta aula ainda não foram traduzidas e aparecem em inglês.
Intro to Asynchronous Python
Welcome to the world of asynchronous programming in Python! This allows your programs to do multiple things without waiting for each task to finish before starting the next.
It's super useful for tasks that involve waiting, like network requests or reading/writing files, where your program would otherwise just sit idle.
Sync vs. Async: The Wait Game
Imagine cooking dinner:
- Synchronous: You chop vegetables, then wait for them to cook, then wash dishes. Only one task happens at a time.
- Asynchronous: You chop vegetables, put them on the stove, and while they're cooking (waiting), you start washing dishes. You're doing multiple things 'concurrently' by switching tasks when one is waiting.
Asynchronous programming helps your program stay busy instead of waiting!
The `async` Keyword: Coroutines
In Python, we use the async keyword to define a special type of function called a coroutine. A coroutine is a function that can be paused and resumed.
It doesn't run immediately when called; instead, it returns a 'coroutine object' that needs to be scheduled by an event loop to run.
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`: Pausing Execution
The await keyword is used inside an async def function (a coroutine) to pause its execution until another awaitable (like another coroutine or a Future) completes.
When a coroutine awaits something, it temporarily gives control back to the event loop, allowing other tasks to run. This is key to non-blocking behavior.
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())
The Event Loop: The Orchestrator
Think of the event loop as the conductor of an orchestra. It's responsible for:
- Scheduling when coroutines run.
- Handling I/O events (like network data arriving).
- Switching between tasks when one is waiting (e.g., due to
await).
Python's asyncio module provides the infrastructure for the event loop.
Running Async Code with `asyncio.run()`
To execute an asynchronous program, you typically use asyncio.run(). This function:
- Gets an event loop for the current thread.
- Runs the provided coroutine until it completes.
- Manages the event loop's lifecycle.
It's the simplest way to start your top-level async function.
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())
Simulating Non-Blocking Operations
asyncio.sleep() is an 'awaitable' that pauses the current coroutine for a given time. Crucially, it does NOT block the entire program. While one coroutine is sleeping, the event loop can switch to and run other coroutines.
This is how asynchronous programming achieves concurrency without needing multiple threads.
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())
Concurrent Execution with `asyncio.gather`
To truly run multiple coroutines concurrently (meaning they can interleave their execution when one awaits), we use asyncio.gather().
asyncio.gather() takes multiple awaitables and schedules them to run 'in parallel' on the event loop, waiting for all of them to complete.
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())
Async/Await Concepts Check
Which of the following statements about Python's async and await keywords are TRUE?
Refresher Recap & Next Steps
Fantastic! You've refreshed your understanding of Python's asynchronous fundamentals:
- Asynchronous programming helps manage I/O-bound tasks efficiently.
async defdefines coroutines, functions that can be paused.awaitpauses a coroutine, yielding control to the event loop.- The event loop orchestrates coroutine execution.
asyncio.run()starts your async application.asyncio.gather()allows running multiple coroutines concurrently.
Next, we'll see how FastAPI leverages these powerful concepts to build high-performance web APIs!
Perguntas Frequentes
A aula “Revisão de Async/Await em Python” é grátis?
Sim — o texto completo de “Revisão de Async/Await em Python” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de FastAPI Backend Development Bootcamp, atualize para CoddyKit PRO. O curso de FastAPI Backend Development Bootcamp inclui 4 aulas no total.
O que vou aprender em “Revisão de Async/Await em Python”?
Revise os conceitos fundamentais da programação assíncrona em Python, incluindo ciclos de eventos e corrotinas. Você pratica FastAPI Backend Development Bootcamp com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar FastAPI Backend Development Bootcamp?
Nenhuma experiência prévia é necessária. FastAPI Backend Development Bootcamp no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.
Quanto tempo leva a aula “Revisão de Async/Await em Python”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de FastAPI Backend Development Bootcamp?
Sim. Cada aula de FastAPI Backend Development Bootcamp inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Revisão de Async/Await em Python
- FastAPI e operações assíncronas
- Executando tarefas em segundo plano
- WebSockets para comunicação em tempo real