Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

asyncio.gather pre dávkové spracovanie

Lekcia 5 z 12 Aktualizované 30. júla 2026 Pokročilý
Na tejto strane
  1. Orchestrovanie paralelných požiadaviek
  2. Základná syntax
  3. Kompletný vzor: Dávka so semaforom
  4. Spracovanie chýb v dávke
  5. Rozdelenie na poddávky (Chunking)
  6. Sledovanie priebehu
  7. Kľúčové poznatky

Orchestrovanie paralelných požiadaviek

asyncio.gather je kľúčová funkcia na spúšťanie viacerých korutín paralelne a zhromažďovanie všetkých výsledkov. V kombinácii so semaforom ti umožňuje efektívne spracovávať dávky požiadaviek pri dodržaní limitov API.

Základná syntax

import asyncio

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

asyncio.gather prijíma ľubovoľný počet korutín (preto sa používa *tasks na rozbalenie zoznamu) a vracia zoznam výsledkov v rovnakom poradí, v akom boli úlohy odoslané. Toto je dôležitý bod: aj keď sa otázka 3 dokončí skôr ako otázka 1, responses[0] bude vždy obsahovať výsledok pre otázku 1.

Kompletný vzor: Dávka so semaforom

Toto je vzor, ktorý budeš v produkcii používať najčastejšie:

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)

Tento vzor zapuzdruje semafor priamo vo funkcii pre dávku. Stačí, ak zavoláš process_batch(prompts) a získaš zoznam odpovedí.

Spracovanie chýb v dávke

Štandardne, ak jediná korutína vyhodí výnimku, asyncio.gather všetko zruší a chybu propaguje ďalej. Parameter return_exceptions=True toto správanie mení:

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

# Použitie
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]}...")

S return_exceptions=True sa chyby zachytia ako hodnoty v zozname výsledkov. Následne môžeš identifikovať a opakovať neúspešné požiadavky.

Rozdelenie na poddávky (Chunking)

Pri veľmi veľkých objemoch je lepšie rozdeliť prácu na poddávky, namiesto spustenia tisícok úloh naraz:

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

Rozdeľovanie na časti (chunking) prináša niekoľko výhod: môžeš zobrazovať priebeh, ukladať priebežné výsledky a obmedziť využitie pamäte. Ak zlyhá jedna poddávka, nestratíš výsledky z predchádzajúcich poddávok.

Sledovanie priebehu

Pri veľkých dávkach je užitočný indikátor priebehu:

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()  # nový riadok po indikátore priebehu
    return results

Kľúčové poznatky

  • asyncio.gather(*tasks) spúšťa korutíny paralelne a vracia výsledky v pôvodnom poradí
  • return_exceptions=True zabraňuje tomu, aby jedna chyba zlyhala celú dávku
  • Rozdeľovanie na časti (chunking) ti umožňuje spracovávať veľmi veľké objemy bez zaplnenia pamäte
  • Vždy kombinuj gather so semaforom, aby si dodržal limity rýchlosti
  • Pridaj sledovanie priebehu pre dlho bežiace procesy