Kurs Python · Moduł 6: Async i FastAPI

Asynchroniczność - równoległe obserwacje

7 min czytania ·
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 def i await - składnia
  • Event loop - silnik asynchroniczności
  • asyncio.gather() - równoległe wykonanie
  • asyncio.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. 1. Czym jest programowanie asynchroniczne?

  2. 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.

  1. PytanieCzym jest asynchroniczność?
  2. Pytanieasync def
  3. Pytanieawait
  4. Ułóż w kolejnościFunkcja asynchroniczna
  5. Kliknij w kolejnościasyncio.gather
  6. Zadanie z kodemPierwsza funkcja async

Przydatne artykuły