Przejdź do głównej treści
Polski— Wybierz język
Menu

asyncio.gather do przetwarzania wsadowego

Lekcja 5 z 12 Zaktualizowano 30 lipca 2026 Zaawansowany
Na tej stronie
  1. Orkiestracja żądań równoległych
  2. Podstawowa składnia
  3. Kompletny wzorzec: Partia z semaforem
  4. Obsługa błędów w partii
  5. Podział na pod-partie (Chunking)
  6. Śledzenie postępu
  7. Kluczowe wnioski

Orkiestracja żądań równoległych

asyncio.gather to podstawowa funkcja służąca do uruchamiania wielu korutyn równolegle i zbierania wszystkich wyników. W połączeniu z semaforem pozwala efektywnie przetwarzać partie żądań, jednocześnie respektując limity API.

Podstawowa składnia

import asyncio

requests = ["Question 1", "Question 2", "Question 3"]
tasks = [process_request(r) for r in requests]
responses = await asyncio.gather(*tasks)

asyncio.gather przyjmuje zmienną liczbę korutyn (stąd *tasks do rozwinięcia listy) i zwraca listę wyników w tej samej kolejności, w jakiej przesłano zadania. To ważny punkt: nawet jeśli pytanie 3 zakończy się przed pytaniem 1, responses[0] zawsze będzie zawierać wynik dla pytania 1.

Kompletny wzorzec: Partia z semaforem

Oto wzorzec, którego będziesz używać najczęściej w środowisku produkcyjnym:

import os
from asyncio import Semaphore
from openai import AsyncOpenAI
import httpx

client = AsyncOpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1",
    timeout=httpx.Timeout(3600.0)
)

async def process_batch(prompts: list[str], max_concurrent: int = 5) -> list[str]:
    sem = Semaphore(max_concurrent)

    async def single_request(prompt: str) -> str:
        async with sem:
            response = await client.chat.completions.create(
                model="grok-4.5",
                messages=[{"role": "user", "content": prompt}]
            )
            return response.choices[0].message.content

    tasks = [single_request(p) for p in prompts]
    return await asyncio.gather(*tasks)

Wzorzec ten inkapsuluje semafor wewnątrz funkcji obsługującej partię. Wystarczy wywołać process_batch(prompts) i pobrać listę odpowiedzi.

Obsługa błędów w partii

Domyślnie, jeśli pojedyncza korutyna zgłosi wyjątek, asyncio.gather anuluje wszystko i propaguje błąd. Parametr return_exceptions=True zmienia to zachowanie:

async def safe_batch(prompts: list[str]) -> list[str | Exception]:
    sem = Semaphore(5)

    async def single_request(prompt: str) -> str:
        async with sem:
            response = await client.chat.completions.create(
                model="grok-4.5",
                messages=[{"role": "user", "content": prompt}]
            )
            return response.choices[0].message.content

    tasks = [single_request(p) for p in prompts]
    results = await asyncio.gather(*tasks, return_exceptions=True)
    return results

# Użycie
results = await safe_batch(mes_prompts)
for i, result in enumerate(results):
    if isinstance(result, Exception):
        print(f"Error on prompt {i}: {result}")
    else:
        print(f"Result {i}: {result[:100]}...")

Dzięki return_exceptions=True błędy są przechwytywane jako wartości na liście wyników. Możesz następnie zidentyfikować i ponowić nieudane żądania.

Podział na pod-partie (Chunking)

Przy bardzo dużych wolumenach lepiej jest podzielić dane na pod-partie, niż uruchamiać tysiące zadań jednocześnie:

async def chunked_batch(
    prompts: list[str],
    chunk_size: int = 50,
    max_concurrent: int = 5
) -> list[str]:
    all_results = []

    for i in range(0, len(prompts), chunk_size):
        chunk = prompts[i:i + chunk_size]
        print(f"Processing batch {i//chunk_size + 1} ({len(chunk)} prompts)")
        results = await process_batch(chunk, max_concurrent)
        all_results.extend(results)

    return all_results

Podział na fragmenty (chunking) oferuje kilka zalet: możesz wyświetlać postęp, zapisywać wyniki pośrednie i ograniczać zużycie pamięci. Jeśli jedna pod-partia nie powiedzie się, nie tracisz wyników z poprzednich pod-partii.

Śledzenie postępu

W przypadku dużych partii przydatny jest wskaźnik postępu:

import asyncio
from asyncio import Semaphore

async def batch_with_progress(prompts: list[str], max_concurrent: int = 5) -> list[str]:
    sem = Semaphore(max_concurrent)
    completed = 0
    total = len(prompts)

    async def single_request(prompt: str) -> str:
        nonlocal completed
        async with sem:
            response = await client.chat.completions.create(
                model="grok-4.5",
                messages=[{"role": "user", "content": prompt}]
            )
            completed += 1
            print(f"\r{completed}/{total} completed", end="", flush=True)
            return response.choices[0].message.content

    tasks = [single_request(p) for p in prompts]
    results = await asyncio.gather(*tasks)
    print()  # nowa linia po postępie
    return results

Kluczowe wnioski

  • asyncio.gather(*tasks) uruchamia korutyny równolegle i zwraca wyniki w oryginalnej kolejności
  • return_exceptions=True zapobiega sytuacji, w której pojedynczy błąd powoduje niepowodzenie całej partii
  • Podział na fragmenty pozwala obsługiwać bardzo duże wolumeny bez zapychania pamięci
  • Zawsze łącz gather z semaforem, aby respektować limity częstotliwości
  • Dodaj śledzenie postępu dla procesów długotrwałych