Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

asyncio.gather kötegelt feldolgozáshoz

5. lecke 12 közül Frissítve 2026. július 30. Haladó
Ezen az oldalon
  1. Párhuzamos kérések orchestrálása
  2. Alapvető szintaxis
  3. Teljes minta: Köteg szemafórral
  4. Hibakezelés kötegben
  5. Felosztás al-kötegekre (Chunking)
  6. Folyamatkövetés
  7. Főbb megállapítások

Párhuzamos kérések orchestrálása

Az asyncio.gather a több korutin párhuzamos futtatására és az összes eredmény összegyűjtésére szolgáló alapfüggvény. Szemafórral kombinálva lehetővé teszi, hogy hatékonyan dolgozz fel kéréskötegeket, miközben tiszteletben tartod az API-korlátokat.

Alapvető szintaxis

import asyncio

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

Az asyncio.gather korutinok változó számú argumentumát fogadja (ezért szükséges a *tasks a lista kibontásához), és az eredmények listáját adja vissza ugyanabban a sorrendben, ahogy a feladatokat elküldted. Ez fontos pont: még ha a 3. kérdés hamarabb le is fut, mint az 1., a responses[0] akkor is az 1. kérdés eredményét fogja tartalmazni.

Teljes minta: Köteg szemafórral

Íme a minta, amelyet a leggyakrabban használni fogsz éles környezetben:

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)

Ez a minta a szemafórt a kötegfüggvényen belül kapszulázza. Csak meg kell hívnod a process_batch(prompts) függvényt, és lekérned a válaszok listáját.

Hibakezelés kötegben

Alapértelmezés szerint, ha egyetlen korutin kivételt dob, az asyncio.gather mindent megszakít és továbbítja a hibát. A return_exceptions=True paraméter megváltoztatja ezt a viselkedést:

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

# Használat
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]}...")

A return_exceptions=True paraméterrel a hibák értékként kerülnek rögzítésre az eredménylistában. Így azonosíthatod és újrapróbálhatod a sikertelen kéréseket.

Felosztás al-kötegekre (Chunking)

Nagyon nagy mennyiség esetén jobb al-kötegekre bontani a feladatot, mintsem ezerével indítani a feladatokat egyszerre:

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

A darabolásnak (chunking) számos előnye van: megjelenítheted a folyamatot, elmentheted a közbenső eredményeket, és korlátozhatod a memóriahasználatot. Ha egy al-köteg meghibásodik, nem veszíted el a korábbi al-kötegek eredményeit.

Folyamatkövetés

Nagy kötegeknél hasznos egy folyamatjelző:

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()  # új sor a folyamatjelző után
    return results

Főbb megállapítások

  • Az asyncio.gather(*tasks) párhuzamosan futtatja a korutinokat, és az eredeti sorrendben adja vissza az eredményeket
  • A return_exceptions=True megakadályozza, hogy egyetlen hiba miatt az egész köteg meghiúsuljon
  • A darabolás (chunking) lehetővé teszi nagyon nagy mennyiségek kezelését a memória túlterhelése nélkül
  • Mindig kombináld a gather függvényt egy szemafórral az aránykorlátok betartása érdekében
  • Adj hozzá folyamatkövetést a hosszú ideig futó folyamatokhoz