asyncio.gather för batchbearbetning
På denna sida
Orkestrera parallella förfrågningar
asyncio.gather är kärnfunktionen för att köra flera korutiner parallellt och samla in alla resultat. Kombinerat med en semafor låter det dig bearbeta batchar av förfrågningar effektivt samtidigt som du respekterar API-gränser.
Grundläggande 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 tar ett variabelt antal korutiner (därav *tasks för att packa upp listan) och returnerar en lista med resultat i samma ordning som de skickade uppgifterna. Detta är en viktig punkt: även om fråga 3 blir klar före fråga 1, kommer responses[0] alltid att innehålla resultatet för fråga 1.
Komplett mönster: Batch med semafor
Här är mönstret du kommer använda oftast i produktion:
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)
Detta mönster kapslar in semaforn i batch-funktionen. Du behöver bara anropa process_batch(prompts) och hämta listan med svar.
Hantera fel i en batch
Som standard, om en enda korutin kastar ett undantag, avbryter asyncio.gather allt och propagerar felet. Parametern return_exceptions=True ändrar detta beteende:
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
# Användning
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]}...")
Med return_exceptions=True fångas fel som värden i resultatlistan. Du kan sedan identifiera och försöka igen med misslyckade förfrågningar.
Dela upp i underbatchar (Chunking)
För mycket stora volymer är det bättre att dela upp i underbatchar istället för att starta tusentals uppgifter samtidigt:
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
Chunking erbjuder flera fördelar: du kan visa framsteg, spara mellanresultat och begränsa minnesanvändningen. Om en underbatch misslyckas förlorar du inte resultaten från tidigare underbatchar.
Spåra framsteg
För stora batchar är en framstegsindikator användbar:
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() # ny rad efter framsteg
return results
Viktiga punkter
asyncio.gather(*tasks)kör korutiner parallellt och returnerar resultat i den ursprungliga ordningenreturn_exceptions=Trueförhindrar att ett enskilt fel misslyckas med hela batchen- Chunking låter dig hantera mycket stora volymer utan att mätta minnet
- Kombinera alltid
gathermed en semafor för att respektera hastighetsbegränsningar - Lägg till framstegsspårning för långvariga processer