Python Academy · Lekcja

Korutyny i pętla zdarzeń

Proszę definiować korutyny za pomocą async def i uruchamiać je przez asyncio.run().

Korutyny i pętla zdarzeń to bezpłatna lekcja Python Academy na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Python Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Python Academy zawiera 4 lekcji w sumie.

Czym jest współbieżność?

Asyncio zapewnia współbieżność kooperatywną: jeden wątek obsługuje wiele zadań, przełączając się między nimi za każdym razem, gdy któreś oczekuje na operację wejścia-wyjścia.

# Traditional: blocking I/O holds the whole thread
# Asyncio: while waiting for I/O, run other coroutines

import asyncio

async def main():
    print("Hello")
    await asyncio.sleep(1)   # yield control
    print("World")

asyncio.run(main())

async def — funkcje korutynowe

Funkcje zdefiniowane za pomocą async def są funkcjami korutynowymi. Ich wywołanie zwraca obiekt korutyny; wykonanie rozpoczyna się dopiero po użyciu await lub zaplanowaniu.

import asyncio

async def greet(name):
    return f"Hello, {name}"

result = asyncio.run(greet("Alice"))
print(result)   # Hello, Alice

Pętla zdarzeń

Pętla zdarzeń steruje wykonywaniem korutyn. asyncio.run(coro) tworzy nową pętlę zdarzeń, wykonuje korutynę do końca, a następnie zamyka pętlę.

import asyncio

async def compute():
    await asyncio.sleep(0)
    return 42

value = asyncio.run(compute())
print(value)   # 42

# For advanced use:
loop = asyncio.new_event_loop()
result = loop.run_until_complete(compute())
loop.close()

await wstrzymuje wykonywanie

await expr wstrzymuje bieżącą korutynę do czasu zakończenia działania expr (innej korutyny lub obiektu future). W tym czasie pętla zdarzeń wykonuje inne zadania.

import asyncio

async def task(name, delay):
    print(f"{name} starting")
    await asyncio.sleep(delay)
    print(f"{name} done")

async def main():
    await task("A", 2)
    await task("B", 1)   # sequential here

asyncio.run(main())

asyncio.sleep()

asyncio.sleep(seconds) wstrzymuje bieżącą korutynę na określony czas, nie blokując pętli zdarzeń.

import asyncio

async def heartbeat():
    while True:
        print("ping")
        await asyncio.sleep(1)

# asyncio.run(heartbeat())  # runs forever

asyncio.run() — punkt wejścia

asyncio.run(coro) to standardowy punkt wejścia na najwyższym poziomie. Nie należy wywoływać go wewnątrz działającej pętli zdarzeń.

import asyncio

async def main():
    print("running")

if __name__ == "__main__":
    asyncio.run(main())

Sprawdzanie, czy pętla zdarzeń działa

Należy użyć asyncio.get_running_loop(), aby sprawdzić, czy pętla już działa. Jeśli nie, funkcja zgłasza RuntimeError.

import asyncio

async def inner():
    loop = asyncio.get_running_loop()
    print(f"Loop: {loop}")

asyncio.run(inner())

Wykonywanie kodu blokującego

Kod obciążający procesor lub wykonujący blokujące operacje wejścia-wyjścia można uruchomić bez blokowania pętli zdarzeń za pomocą loop.run_in_executor(None, func, *args).

import asyncio, time

def blocking():
    time.sleep(2)
    return "done"

async def main():
    loop = asyncio.get_event_loop()
    result = await loop.run_in_executor(None, blocking)
    print(result)

asyncio.run(main())

Łączenie korutyn

Korutyny mogą używać await wobec innych korutyn, tworząc łańcuch. Sterowanie przechodzi w dół łańcucha, a następnie wraca w górę po zakończeniu każdego poziomu.

import asyncio

async def fetch_data():
    await asyncio.sleep(1)
    return {"value": 42}

async def process():
    data = await fetch_data()
    return data["value"] * 2

async def main():
    result = await process()
    print(result)   # 84

asyncio.run(main())

Identyfikowanie korutyn

Za pomocą asyncio.iscoroutine(obj) lub asyncio.iscoroutinefunction(func) można sprawdzać funkcje asynchroniczne w czasie działania programu.

import asyncio

async def my_coro():
    pass

print(asyncio.iscoroutinefunction(my_coro))   # True
coro = my_coro()
print(asyncio.iscoroutine(coro))              # True
coro.close()   # clean up the un-awaited coroutine

Tryb debugowania asyncio

Tryb debugowania pozwala wykrywać nieoczekiwane korutyny, powolne funkcje zwrotne i inne problemy: należy ustawić PYTHONASYNCIODEBUG=1 lub przekazać debug=True do asyncio.run.

import asyncio

async def main():
    pass

asyncio.run(main(), debug=True)

# Or:
# PYTHONASYNCIODEBUG=1 python script.py

Szybkie sprawdzenie

Co robi asyncio.run(coro)?

Podsumowanie

Korutyny należy definiować za pomocą async def, uruchamiać za pomocą asyncio.run() i wstrzymywać za pomocą await. Pętla zdarzeń kooperatywnie planuje wykonywanie korutyn, uruchamiając inne, gdy jedna oczekuje na operację wejścia-wyjścia.

Często zadawane pytania

Czy lekcja „Korutyny i pętla zdarzeń” jest bezpłatna?

Tak — pełny tekst „Korutyny i pętla zdarzeń” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Python Academy, przejdź na CoddyKit PRO. Kurs Python Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Korutyny i pętla zdarzeń”?

Proszę definiować korutyny za pomocą async def i uruchamiać je przez asyncio.run(). Ćwiczysz Python Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Python Academy?

Nie wymagamy żadnego doświadczenia. Python Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Korutyny i pętla zdarzeń”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Python Academy?

Tak. Każda lekcja Python Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

Korutyny i pętla zdarzeń
await, zadania i grupowanie
Asynchroniczne menedżery kontekstu i iteratory
Wzorce asynchronicznego wejścia-wyjścia w środowisku produkcyjnym

← Powrót do Python Academy