Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

asyncio.gather för batchbearbetning

Lektion 5 av 12 Uppdaterad 30 juli 2026 Avancerad
På denna sida
  1. Orkestrera parallella förfrågningar
  2. Grundläggande syntax
  3. Komplett mönster: Batch med semafor
  4. Hantera fel i en batch
  5. Dela upp i underbatchar (Chunking)
  6. Spåra framsteg
  7. Viktiga punkter

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 ordningen
  • return_exceptions=True förhindrar att ett enskilt fel misslyckas med hela batchen
  • Chunking låter dig hantera mycket stora volymer utan att mätta minnet
  • Kombinera alltid gather med en semafor för att respektera hastighetsbegränsningar
  • Lägg till framstegsspårning för långvariga processer