0Pricing
Python Academy · Lekcja

await, zadania i grupowanie

Proszę używać await, asyncio.create_task i asyncio.gather do współbieżności.

await, zadania i grupowanie to bezpłatna lekcja Python Academy na CoddyKit. To lekcja 2 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.

await a wykonywanie sekwencyjne

Użycie samego await powoduje sekwencyjne wykonywanie korutyn. Aby uruchamiać je współbieżnie, należy opakować je w zadania.

import asyncio

async def main():
    # Sequential — total ~3 s
    await asyncio.sleep(2)
    await asyncio.sleep(1)

    # Concurrent using gather — total ~2 s
    await asyncio.gather(asyncio.sleep(2), asyncio.sleep(1))

asyncio.create_task()

asyncio.create_task(coro) planuje wykonywanie korutyny jako niezależnego zadania współbieżnie z bieżącą korutyną.

import asyncio

async def work(n):
    await asyncio.sleep(n)
    return n

async def main():
    t1 = asyncio.create_task(work(2))
    t2 = asyncio.create_task(work(1))
    r1 = await t1
    r2 = await t2
    print(r1, r2)   # 2 1 (total ~2 s)

asyncio.run(main())

asyncio.gather()

asyncio.gather(*coros) uruchamia korutyny współbieżnie i zwraca wszystkie wyniki w odpowiedniej kolejności po zakończeniu ich wszystkich.

import asyncio

async def fetch(i):
    await asyncio.sleep(1)
    return f"data-{i}"

async def main():
    results = await asyncio.gather(fetch(1), fetch(2), fetch(3))
    print(results)  # ["data-1", "data-2", "data-3"] in ~1 s

asyncio.run(main())

gather z return_exceptions

Należy ustawić return_exceptions=True, aby nieudana korutyna zwróciła wyjątek jako wynik zamiast anulować całe wywołanie gather.

import asyncio

async def risky(n):
    if n == 2: raise ValueError("bad")
    return n

async def main():
    results = await asyncio.gather(
        risky(1), risky(2), risky(3),
        return_exceptions=True
    )
    print(results)   # [1, ValueError("bad"), 3]

asyncio.wait()

asyncio.wait(tasks, return_when=...) zwraca dwa zbiory: done i pending. Proszę użyć FIRST_COMPLETED, aby zareagować na pierwszy wynik.

import asyncio

async def slow(): await asyncio.sleep(3); return "slow"
async def fast(): await asyncio.sleep(1); return "fast"

async def main():
    tasks = {asyncio.create_task(slow()), asyncio.create_task(fast())}
    done, pending = await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)
    for t in pending: t.cancel()

Anulowanie zadań

Proszę wywołać task.cancel(), aby zażądać anulowania. Zadanie otrzyma asyncio.CancelledError przy najbliższym punkcie await.

import asyncio

async def long_job():
    try:
        await asyncio.sleep(100)
    except asyncio.CancelledError:
        print("Cancelled!")
        raise   # re-raise is required

async def main():
    t = asyncio.create_task(long_job())
    await asyncio.sleep(1)
    t.cancel()
    await t

asyncio.timeout() — Python 3.11+

Proszę opakować operację oczekiwania w asyncio.timeout(seconds), aby anulować ją, jeśli trwa zbyt długo.

import asyncio

async def main():
    try:
        async with asyncio.timeout(2):
            await asyncio.sleep(10)   # too slow
    except TimeoutError:
        print("Timed out!")

asyncio.wait_for()

W Pythonie < 3.11 proszę użyć asyncio.wait_for(coro, timeout=N), aby dodać limit czasu; w przypadku jego przekroczenia zostanie zgłoszony asyncio.TimeoutError.

import asyncio

async def slow(): await asyncio.sleep(5)

async def main():
    try:
        await asyncio.wait_for(slow(), timeout=2)
    except asyncio.TimeoutError:
        print("Timed out")

Nazwy zadań i inspekcja

Proszę nadawać zadaniom nazwy, aby ułatwić debugowanie, używając asyncio.create_task(coro, name="..."), a następnie sprawdzać je za pomocą task.get_name().

import asyncio

async def worker(): await asyncio.sleep(1)

async def main():
    t = asyncio.create_task(worker(), name="worker-1")
    print(t.get_name())   # worker-1
    await t

TaskGroup — Python 3.11+

asyncio.TaskGroup tworzy uporządkowaną grupę zadań. Jeśli dowolne zadanie zgłosi wyjątek, wszystkie zadania zostaną anulowane.

import asyncio

async def main():
    async with asyncio.TaskGroup() as tg:
        t1 = tg.create_task(asyncio.sleep(1))
        t2 = tg.create_task(asyncio.sleep(2))
    # all tasks done here

Semafor do ograniczania liczby żądań

Proszę użyć asyncio.Semaphore(n), aby ograniczyć liczbę operacji wykonywanych współbieżnie, na przykład wywołań API.

import asyncio

sem = asyncio.Semaphore(5)  # max 5 concurrent

async def limited_fetch(url):
    async with sem:
        await fetch(url)   # at most 5 at a time

Szybki test

Jaka jest różnica między await coro() a asyncio.create_task(coro())?

Podsumowanie

Proszę używać create_task lub gather do wykonywania operacji współbieżnie. gather zbiera wszystkie wyniki, natomiast wait zapewnia szczegółową kontrolę. Zadania można anulować za pomocą .cancel(), a limity czasu ustawiać za pomocą wait_for lub asyncio.timeout.

Często zadawane pytania

Czy lekcja „await, zadania i grupowanie” jest bezpłatna?

Tak — pełny tekst „await, zadania i grupowanie” 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 „await, zadania i grupowanie”?

Proszę używać await, asyncio.create_task i asyncio.gather do współbieżności. Ć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 2 z 4.

Ile czasu zajmuje lekcja „await, zadania i grupowanie”?

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

  1. Korutyny i pętla zdarzeń
  2. await, zadania i grupowanie
  3. Asynchroniczne menedżery kontekstu i iteratory
  4. Wzorce asynchronicznego wejścia-wyjścia w środowisku produkcyjnym
← Powrót do Python Academy