Премини към основното съдържание
Български— Изберете език
Меню

asyncio.gather за пакетна обработка

Урок 5 от 12 Обновен 30 юли 2026 г. Напреднало
На тази страница
  1. Оркестриране на паралелни заявки
  2. Основен синтаксис
  3. Пълен шаблон: Пакет със семафор
  4. Обработка на грешки в пакет
  5. Разделяне на под-пакети (Chunking)
  6. Проследяване на напредъка
  7. Ключови изводи

Оркестриране на паралелни заявки

asyncio.gather е основната функция за изпълнение на множество корутини паралелно и събиране на всички резултати. В комбинация със семафор, тя Ви позволява да обработвате пакети от заявки ефективно, като същевременно спазвате лимитите на API.

Основен синтаксис

import asyncio

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

asyncio.gather приема променлив брой корутини (оттук и *tasks за разпакетиране на списъка) и връща списък с резултати в същия ред, в който са подадени задачите. Това е важен момент: дори въпрос 3 да приключи преди въпрос 1, responses[0] винаги ще съдържа резултата за въпрос 1.

Пълен шаблон: Пакет със семафор

Ето шаблона, който ще използвате най-често в продукционна среда:

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)

Този шаблон капсулира семафора във функцията за пакетна обработка. Трябва само да извикате process_batch(prompts) и да получите списъка с отговори.

Обработка на грешки в пакет

По подразбиране, ако една корутина предизвика изключение, asyncio.gather отменя всичко и разпространява грешката. Параметърът return_exceptions=True променя това поведение:

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

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

С return_exceptions=True, грешките се улавят като стойности в списъка с резултати. След това можете да идентифицирате и повторите неуспешните заявки.

Разделяне на под-пакети (Chunking)

За много големи обеми е по-добре да разделите задачите на под-пакети, вместо да стартирате хиляди задачи едновременно:

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

Разделянето на части предлага няколко предимства: можете да показвате напредъка, да запазвате междинни резултати и да ограничавате използването на паметта. Ако един под-пакет се провали, не губите резултатите от предишните под-пакети.

Проследяване на напредъка

За големи пакети индикаторът за напредък е полезен:

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()  # new line after progress
    return results

Ключови изводи

  • asyncio.gather(*tasks) изпълнява корутини паралелно и връща резултатите в оригиналния ред
  • return_exceptions=True предотвратява провала на целия пакет при една единствена грешка
  • Разделянето на части Ви позволява да обработвате много големи обеми, без да претоварвате паметта
  • Винаги комбинирайте gather със семафор, за да спазвате лимитите на честота
  • Добавете проследяване на напредъка за процеси с продължително изпълнение