asyncio.gather apjomapstrādei
Šajā lapā
Paralēlo pieprasījumu orķestrēšana
asyncio.gather ir galvenā funkcija vairāku korutīņu paralēlai izpildei un visu rezultātu apkopošanai. Apvienojot to ar semaforu, tu vari efektīvi apstrādāt pieprasījumu partijas, vienlaikus ievērojot API ierobežojumus.
Pamata sintakse
import asyncio
requests = ["Question 1", "Question 2", "Question 3"]
tasks = [process_request(r) for r in requests]
responses = await asyncio.gather(*tasks)
asyncio.gather pieņem mainīgu skaitu korutīņu (tāpēc tiek izmantots *tasks, lai „atpakotu” sarakstu) un atgriež rezultātu sarakstu tādā pašā secībā, kādā tika iesniegti uzdevumi. Tas ir svarīgi: pat ja 3. jautājums tiek pabeigts ātrāk nekā 1., responses[0] vienmēr saturēs rezultātu tieši 1. jautājumam.
Pilns paraugs: Partija ar semaforu
Lūk, paraugs, ko visbiežāk izmantosi ražošanas vidē:
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 paraugs iekapsulē semaforu partijas funkcijā. Tev tikai jāizsauc process_batch(prompts) un jāsaņem atbilžu saraksts.
Kļūdu apstrāde partijā
Pēc noklusējuma, ja viena korutīne izraisa izņēmumu, asyncio.gather atceļ visu un izplata kļūdu tālāk. Parametrs return_exceptions=True maina šo uzvedību:
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
# Lietošana
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]}...")
Izmantojot return_exceptions=True, kļūdas tiek saglabātas kā vērtības rezultātu sarakstā. Pēc tam tu vari identificēt un atkārtoti izpildīt neizdevušos pieprasījumus.
Sadalīšana apakšpartijās (Chunking)
Ļoti lieliem datu apjomiem ir lietderīgāk sadalīt uzdevumus apakšpartijās, nevis vienlaikus palaist tūkstošiem uzdevumu:
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
Sadalīšana mazākās daļās piedāvā vairākas priekšrocības: tu vari attēlot progresu, saglabāt starprezultātus un ierobežot atmiņas patēriņu. Ja viena apakšpartija neizdodas, tu nezaudē iepriekšējo apakšpartiju rezultātus.
Progresa izsekošana
Lieliem apjomiem noder progresa indikators:
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() # jauna rinda pēc progresa
return results
Galvenās atziņas
asyncio.gather(*tasks)izpilda korutīnes paralēli un atgriež rezultātus sākotnējā secībāreturn_exceptions=Truenovērš situāciju, kur viena kļūda izgāž visu partiju- Sadalīšana daļās ļauj apstrādāt ļoti lielus apjomus, nepārslogojot atmiņu
- Vienmēr kombinē
gatherar semaforu, lai ievērotu ātruma ierobežojumus - Ilgstošiem procesiem pievieno progresa izsekošanu