asyncio.gather za obdelavo v serijah
Na tej strani
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 redureturn_exceptions=Trueprepreči, da bi ena sama napaka spodletela celotni seriji- Razčlenjevanje ti omogoča obdelavo zelo velikih količin brez zapolnitve pomnilnika
gathervedno kombiniraj s semaforjem za spoštovanje omejitev hitrosti- Dodaj sledenje napredku za dolgotrajne procese