Kurs Python · Moduł 6: Async i FastAPI
Asynchroniczność - równoległe obserwacje
W tej lekcji12
Witaj w Module 6! Darwin tutaj z ekscytującym tematem - asynchroniczne programowanie w Pythonie!
Do tej pory wszystkie Twoje programy były synchroniczne - wykonywały operacje jedna po drugiej. Teraz poznasz asynchroniczność - technikę pozwalającą na wykonywanie wielu zadań jednocześnie!
Analogia Safari: Synchroniczne programowanie to jak jeden przewodnik obserwujący zwierzęta po kolei - najpierw lwy (czeka 30 minut), potem słonie (czeka 20 minut), potem gepardy (czeka 15 minut). Asynchroniczne to jak wielu przewodników obserwujących jednocześnie - jeden przy lwach, drugi przy słoniach, trzeci przy gepardach - wszyscy równolegle! ⏱
Problem z synchronicznym kodem
Synchroniczny kod - czekanie po kolei
import time
def observe_lions():
"""Obserwacja lwów - trwa 3 sekundy"""
print("Rozpoczynam obserwację lwów...")
time.sleep(3) # Symulacja czekania
print("Obserwacja lwów zakończona!")
return {"species": "Lew", "count": 5}
def observe_elephants():
"""Obserwacja słoni - trwa 2 sekundy"""
print("Rozpoczynam obserwację słoni...")
time.sleep(2)
print("Obserwacja słoni zakończona!")
return {"species": "Słoń", "count": 3}
def observe_cheetahs():
"""Obserwacja gepardów - trwa 4 sekundy"""
print("Rozpoczynam obserwację gepardów...")
time.sleep(4)
print("Obserwacja gepardów zakończona!")
return {"species": "Gepard", "count": 2}
# Synchroniczne wykonanie - PO KOLEI
start = time.time()
result1 = observe_lions() # Czeka 3s
result2 = observe_elephants() # Potem czeka 2s
result3 = observe_cheetahs() # Potem czeka 4s
end = time.time()
print(f"\nCałkowity czas: {end - start:.1f}s")
# Output: Całkowity czas: 9.0s (3 + 2 + 4)Problem: Czas = 9 sekund! Musimy czekać na każdą obserwację po kolei, mimo że moglibyśmy obserwować równolegle! ⏰
Rozwiązanie - asynchroniczny kod
Asynchroniczny kod - równoległe czekanie
import asyncio
async def observe_lions():
"""Asynchroniczna obserwacja lwów"""
print("Rozpoczynam obserwację lwów...")
await asyncio.sleep(3) # await zamiast time.sleep!
print("Obserwacja lwów zakończona!")
return {"species": "Lew", "count": 5}
async def observe_elephants():
"""Asynchroniczna obserwacja słoni"""
print("Rozpoczynam obserwację słoni...")
await asyncio.sleep(2)
print("Obserwacja słoni zakończona!")
return {"species": "Słoń", "count": 3}
async def observe_cheetahs():
"""Asynchroniczna obserwacja gepardów"""
print("Rozpoczynam obserwację gepardów...")
await asyncio.sleep(4)
print("Obserwacja gepardów zakończona!")
return {"species": "Gepard", "count": 2}
async def main():
"""Główna funkcja async"""
start = time.time()
# Wykonaj równolegle!
results = await asyncio.gather(
observe_lions(),
observe_elephants(),
observe_cheetahs()
)
end = time.time()
print(f"\nCałkowity czas: {end - start:.1f}s")
# Output: Całkowity czas: 4.0s (max z 3, 2, 4)
print(f"Wyniki: {results}")
# Uruchom async main
asyncio.run(main())Wynik: Czas = 4 sekundy! Wszystkie obserwacje wykonują się równolegle!
Oszczędność: 9s → 4s = 5 sekund szybciej (55% redukcja)!
Async/await - składnia
async def - definicja funkcji asynchronicznej
# Synchroniczna funkcja
def sync_function():
return "Sync result"
# Asynchroniczna funkcja (coroutine)
async def async_function():
return "Async result"async def tworzy coroutine - specjalną funkcję, która może być "zawieszona" (await) i wznowiona później.
await - czekanie na wynik
async def fetch_species_data(species_id):
print(f"Pobieranie danych dla gatunku {species_id}...")
await asyncio.sleep(2) # Symulacja I/O operation
return {"id": species_id, "name": "Lew", "population": 120}
async def main():
# await zawiesza wykonanie dopóki nie otrzyma wyniku
data = await fetch_species_data(1)
print(f"Otrzymano dane: {data}")
asyncio.run(main())await mówi: "Czekaj na wynik, ale w międzyczasie pozwól innym zadaniom działać".
WAŻNE: await można używać tylko wewnątrz async def!
Event Loop - silnik async
Event loop to serce asynchroniczności - zarządza wszystkimi coroutines i przełącza między nimi.
Analogia: Event loop to jak dispatcher safari - przydziela przewodników do różnych zadań, przełącza między nimi, i zbiera wyniki!
import asyncio
async def task1():
print("Task 1 start")
await asyncio.sleep(1)
print("Task 1 end")
async def task2():
print("Task 2 start")
await asyncio.sleep(0.5)
print("Task 2 end")
async def main():
# Event loop zarządza tymi taskami
await asyncio.gather(task1(), task2())
# asyncio.run() tworzy event loop i wykonuje main()
asyncio.run(main())Output:
Task 1 start
Task 2 start
Task 2 end (po 0.5s)
Task 1 end (po 1s)Event loop przełączał się między task1 i task2!
asyncio.gather() - równoległe wykonanie
asyncio.gather() wykonuje wiele coroutines równolegle i zwraca listę wyników:
import asyncio
async def get_species(species_id):
await asyncio.sleep(1)
return {"id": species_id, "name": f"Species {species_id}"}
async def main():
# Pobierz 5 gatunków równolegle
results = await asyncio.gather(
get_species(1),
get_species(2),
get_species(3),
get_species(4),
get_species(5)
)
print(f"Pobrano {len(results)} gatunków:")
for species in results:
print(f" - {species['name']}")
asyncio.run(main())Czas: 1 sekunda (zamiast 5 sekund synchronicznie)!
gather() zwraca wyniki w tej samej kolejności, w jakiej podałeś coroutines!
asyncio.create_task() - uruchom w tle
create_task() uruchamia coroutine w tle (nie czeka na wynik):
async def background_observation(species):
print(f"Rozpoczynam obserwację {species}...")
await asyncio.sleep(3)
print(f"Obserwacja {species} zakończona!")
async def main():
# Uruchom w tle
task1 = asyncio.create_task(background_observation("Lew"))
task2 = asyncio.create_task(background_observation("Słoń"))
print("Robię inne rzeczy w międzyczasie...")
await asyncio.sleep(1)
print("Nadal robię inne rzeczy...")
# Czekaj na zakończenie tasków
await task1
await task2
asyncio.run(main())Output:
Rozpoczynam obserwację Lew...
Rozpoczynam obserwację Słoń...
Robię inne rzeczy w międzyczasie...
Nadal robię inne rzeczy...
Obserwacja Lew zakończona!
Obserwacja Słoń zakończona!Async comprehensions
Python pozwala na async list/dict comprehensions:
async def get_population(species_id):
await asyncio.sleep(0.1)
return species_id * 10
async def main():
# Async list comprehension
populations = [await get_population(i) for i in range(1, 6)]
print(f"Populacje: {populations}")
# Output: Populacje: [10, 20, 30, 40, 50]
# Ale to wykonuje się SEKWENCYJNIE!
# Lepiej użyć gather():
populations = await asyncio.gather(
*[get_population(i) for i in range(1, 6)]
)
print(f"Populacje (równolegle): {populations}")
asyncio.run(main())Praktyczny przykład - Safari API Client
Asynchroniczny klient do API Safari:
import asyncio
import aiohttp # pip install aiohttp
class SafariAPIClient:
def __init__(self, base_url: str):
self.base_url = base_url
async def get_species(self, species_id: int):
"""Pobierz dane gatunku"""
async with aiohttp.ClientSession() as session:
async with session.get(f"{self.base_url}/species/{species_id}") as response:
return await response.json()
async def get_multiple_species(self, species_ids: list[int]):
"""Pobierz wiele gatunków równolegle"""
async with aiohttp.ClientSession() as session:
tasks = []
for species_id in species_ids:
task = session.get(f"{self.base_url}/species/{species_id}")
tasks.append(task)
responses = await asyncio.gather(*tasks)
results = []
for response in responses:
data = await response.json()
results.append(data)
return results
async def main():
client = SafariAPIClient("https://api.safari-db.com")
# Pobierz 10 gatunków równolegle
species_ids = list(range(1, 11))
start = time.time()
results = await client.get_multiple_species(species_ids)
end = time.time()
print(f"Pobrano {len(results)} gatunków w {end - start:.2f}s")
asyncio.run(main())Synchronicznie: 10 requests × 0.5s = 5 sekund Asynchronicznie: max(0.5s) = 0.5 sekundy
Kiedy używać async?
Używaj async gdy:
- I/O operations - zapytania HTTP, bazy danych, pliki
- Wiele równoległych operacji - 100+ requests do API
- WebSockets - real-time komunikacja
- Oczekiwanie - sleep, timery, długie obliczenia
NIE używaj async gdy:
- CPU-bound - obliczenia matematyczne, przetwarzanie obrazów
- Prosty kod - mała aplikacja bez I/O
- Brak bibliotek async - biblioteka nie wspiera async
Dla CPU-bound użyj multiprocessing zamiast async!
Async context managers
class AsyncDatabaseConnection:
async def __aenter__(self):
print("Łączenie z bazą...")
await asyncio.sleep(1)
return self
async def __aexit__(self, exc_type, exc_val, exc_tb):
print("Zamykanie połączenia...")
await asyncio.sleep(0.5)
async def query(self, sql):
print(f"Wykonuję: {sql}")
await asyncio.sleep(0.2)
return [{"id": 1, "name": "Lew"}]
async def main():
async with AsyncDatabaseConnection() as db:
results = await db.query("SELECT * FROM species")
print(f"Wyniki: {results}")
asyncio.run(main())Obsługa błędów w async
async def risky_operation(species_id):
if species_id == 3:
raise ValueError(f"Gatunek {species_id} nie istnieje!")
await asyncio.sleep(1)
return {"id": species_id}
async def main():
try:
results = await asyncio.gather(
risky_operation(1),
risky_operation(2),
risky_operation(3), # Błąd!
return_exceptions=True # Zwróć wyjątki zamiast rzucać
)
for i, result in enumerate(results, 1):
if isinstance(result, Exception):
print(f"Gatunek {i}: BŁĄD - {result}")
else:
print(f"Gatunek {i}: OK - {result}")
except Exception as e:
print(f"Błąd: {e}")
asyncio.run(main())Output:
Gatunek 1: OK - {'id': 1}
Gatunek 2: OK - {'id': 2}
Gatunek 3: BŁĄD - Gatunek 3 nie istnieje!Podsumowanie
W tej lekcji nauczyłeś/aś się:
- Sync vs Async - różnice i korzyści
async defiawait- składnia- Event loop - silnik asynchroniczności
asyncio.gather()- równoległe wykonanieasyncio.create_task()- taski w tle- Async comprehensions
- Praktyczne przykłady Safari API
- Kiedy używać async (I/O) vs multiprocessing (CPU)
- Async context managers i error handling
Analogia Safari finalna: Async to jak wielu przewodników safari obserwujących różne gatunki jednocześnie - zamiast czekać 9 sekund obserwując po kolei (sync), obserwują równolegle i kończą w 4 sekundy (async)! Event loop to dispatcher koordynujący wszystkich przewodników! ⏱
Następna lekcja: Darwin pokaże Ci FastAPI - nowoczesny framework async do budowania błyskawicznych API!
Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?
Sprawdź się
Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.
1. Czym jest programowanie asynchroniczne?
2. Jak zdefiniować funkcję asynchroniczną w Pythonie?
To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Układanie w pionie
Ułóż prostą funkcję asynchroniczną w Pythonie:
- Klikanie w kolejności
Ułóż wywołanie asyncio.gather do uruchomienia wielu coroutines:
- Edytor kodu
Napisz async funkcję observe_animal, która czeka 1 sekundę (asyncio.sleep) i zwraca nazwę zwierzęcia.