Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

asyncio.gather za obdelavo v serijah

Lekcija 5 od 12 Posodobljeno 30. julij 2026 Napredni
Na tej strani
  1. Orkestriranje vzporednih zahtevkov
  2. Osnovna sintaksa
  3. Celoten vzorec: Serija s semaforjem
  4. Obravnava napak v seriji
  5. Razdelitev na podserije (razčlenjevanje)
  6. Sledenje napredku
  7. Ključne ugotovitve

Orkestriranje vzporednih zahtevkov

asyncio.gather je osrednja funkcija za vzporedno izvajanje več korutin in zbiranje vseh rezultatov. V kombinaciji s semaforjem ti omogoča učinkovito obdelavo serij zahtevkov ob hkratnem spoštovanju omejitev API-ja.

Osnovna sintaksa

import asyncio

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

asyncio.gather sprejme poljubno število korutin (zato uporaba *tasks za razpakiranje seznama) in vrne seznam rezultatov v istem vrstnem redu, kot so bile opravila predložena. To je ključna točka: tudi če se vprašanje 3 konča pred vprašanjem 1, bo responses[0] vedno vseboval rezultat za vprašanje 1.

Celoten vzorec: Serija s semaforjem

To je vzorec, ki ga boš v proizvodnem okolju uporabljal najpogosteje:

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)

Ta vzorec encapsulira semafor znotraj funkcije za obdelavo serije. Poklicati moraš le process_batch(prompts) in pridobiti seznam odgovorov.

Obravnava napak v seriji

Privzeto asyncio.gather ob napaki katere koli korotine prekliče vse ostale in posreduje napako dalje. Parameter return_exceptions=True to vedenje spremeni:

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

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

Z return_exceptions=True so napake zajete kot vrednosti v seznamu rezultatov. Tako lahko identificiraš in ponovno poskusiš neuspele zahtevke.

Razdelitev na podserije (razčlenjevanje)

Pri zelo velikih količinah je bolje razdeliti delo na podserije, namesto da bi hkrati zagnal na tisoče opravil:

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

Razčlenjevanje ponuja več prednosti: lahko prikazuješ napredek, shranjuješ vmesne rezultate in omejiš porabo pomnilnika. Če ena podserija odpove, ne izgubiš rezultatov iz prejšnjih podserij.

Sledenje napredku

Pri velikih serijah je koristen indikator napredka:

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()  # nova vrstica po napredku
    return results

Ključne ugotovitve

  • asyncio.gather(*tasks) izvaja korotine vzporedno in vrača rezultate v izvirnem vrstnem redu
  • return_exceptions=True prepreči, da bi ena sama napaka spodletela celotni seriji
  • Razčlenjevanje ti omogoča obdelavo zelo velikih količin brez zapolnitve pomnilnika
  • gather vedno kombiniraj s semaforjem za spoštovanje omejitev hitrosti
  • Dodaj sledenje napredku za dolgotrajne procese