Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

asyncio.gather apdoroti grupes

Paskaita 5 iš 12 Atnaujinta 2026 m. liepos 30 d. Pažengusiems
Šiame puslapyje
  1. Lygiagrečių užklausų orchestravimas
  2. Pagrindinė sintaksė
  3. Pilnas šablonas: grupė su semaforu
  4. Klaidų valdymas grupėje
  5. Skaidymas į pogrupius (Chunking)
  6. Eigos stebėjimas
  7. Svarbiausi punktai

Lygiagrečių užklausų orchestravimas

asyncio.gather yra pagrindinė funkcija, leidžianti vienu metu vykdyti kelias korutinas ir surinkti visus rezultatus. Derinama su semaforu, ji leidžia efektyviai apdoroti užklausų grupes, laikantis API ribojimų.

Pagrindinė sintaksė

import asyncio

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

asyncio.gather priima kintamą skaičių korutinų (todėl naudojamas *tasks sąrašui išpakuoti) ir grąžina rezultatų sąrašą ta pačia tvarka, kuria buvo pateiktos užduotys. Tai svarbus momentas: net jei trečias klausimas baigiamas anksčiau nei pirmas, responses[0] visada turės atsakymą į pirmąjį klausimą.

Pilnas šablonas: grupė su semaforu

Štai šablonas, kurį dažniausiai naudosite gamyboje:

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)

Šis šablonas inkapsuliuoja semaforą grupės funkcijos viduje. Tau tereikia iškviesti process_batch(prompts) ir gauti atsakymų sąrašą.

Klaidų valdymas grupėje

Pagal nutylėjimą, jei viena korutina išmeta išimtį, asyncio.gather atšaukia viską ir perduoda klaidą toliau. Parametras return_exceptions=True pakeičia šį elgesį:

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

# Naudojimas
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]}...")

Naudojant return_exceptions=True, klaidos įtraukiamos kaip reikšmės į rezultatų sąrašą. Tuomet gali identifikuoti ir pakartoti nepavykusias užklausas.

Skaidymas į pogrupius (Chunking)

Dirbant su labai dideliais kiekiais, geriau suskaidyti užduotis į pogrupius, nei paleisti tūkstančius užduočių vienu metu:

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

Skaidymas į dalis turi keletą privalumų: gali rodyti eigą, saugoti tarpinius rezultatus ir riboti atminties naudojimą. Jei vienas pogrupis nepavyksta, neprarandi ankstesnių pogrupių rezultatų.

Eigos stebėjimas

Didelėms grupėms pravartu turėti eigos indikatorių:

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()  # nauja eilutė po eigos rodymo
    return results

Svarbiausi punktai

  • asyncio.gather(*tasks) vykdo korutinas lygiagrečiai ir grąžina rezultatus originalia tvarka
  • return_exceptions=True neleidžia vienai klaidai sugriauti visos grupės
  • Skaidymas į dalis leidžia apdoroti labai didelius kiekius neperkraunant atminties
  • Visada derink gather su semaforu, kad laikytumeisi užklausų ribojimų
  • Ilgai trunkantiems procesams pridėk eigos stebėjimą