Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

asyncio.gather apjomapstrādei

Nodarbība 5 no 12 Atjaunota 2026. gada 30. jūlijs Augstākais
Šajā lapā
  1. Paralēlo pieprasījumu orķestrēšana
  2. Pamata sintakse
  3. Pilns paraugs: Partija ar semaforu
  4. Kļūdu apstrāde partijā
  5. Sadalīšana apakšpartijās (Chunking)
  6. Progresa izsekošana
  7. Galvenās atziņas

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=True novē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ē gather ar semaforu, lai ievērotu ātruma ierobežojumus
  • Ilgstošiem procesiem pievieno progresa izsekošanu