Μετάβαση στο κύριο περιεχόμενο
Ελληνικά— Επιλέξτε γλώσσα
Μενού

Το asyncio.gather για επεξεργασία παρτίδων

Μάθημα 5 / 12 Ενημερώθηκε 30 Ιουλίου 2026 Προχωρημένος
Σε αυτήν τη σελίδα
  1. Ορχήστρωση παράλληλων αιτημάτων
  2. Βασική Σύνταξη
  3. Πλήρες Πρότυπο: Παρτίδα με Semaphore
  4. Διαχείριση Σφαλμάτων σε μια Παρτίδα
  5. Διαχωρισμός σε Υπο-παρτίδες (Chunking)
  6. Παρακολούθηση Προόδου
  7. Βασικά σημεία

Ορχήστρωση παράλληλων αιτημάτων

Το asyncio.gather είναι η κεντρική συνάρτηση για την εκτέλεση πολλαπλών coroutines παράλληλα και τη συλλογή όλων των αποτελεσμάτων. Σε συνδυασμό με ένα semaphore, σας επιτρέπει να επεξεργάζεστε παρτίδες αιτημάτων αποτελεσματικά, σεβόμενοι ταυτόχρονα τα όρια του 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 δέχεται έναν μεταβλητό αριθμό coroutines (εξ ου και το *tasks για την αποσυσκευασία της λίστας) και επιστρέφει μια λίστα με αποτελέσματα στην ίδια σειρά με τα υποβληθέντα tasks. Αυτό είναι ένα σημαντικό σημείο: ακόμα κι αν το ερώτημα 3 ολοκληρωθεί πριν από το ερώτημα 1, το responses[0] θα περιέχει πάντα το αποτέλεσμα για το ερώτημα 1.

Πλήρες Πρότυπο: Παρτίδα με Semaphore

Αυτό είναι το πρότυπο που θα χρησιμοποιείτε συχνότερα σε περιβάλλον παραγωγής:

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)

Αυτό το πρότυπο ενσωματώνει το semaphore μέσα στη συνάρτηση της παρτίδας. Απλώς καλείτε το process_batch(prompts) και ανακτάτε τη λίστα με τις απαντήσεις.

Διαχείριση Σφαλμάτων σε μια Παρτίδα

Εξ ορισμού, αν μια μοναδική coroutine προκαλέσει εξαίρεση, το 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

# Χρήση
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)

Για πολύ μεγάλους όγκους δεδομένων, είναι προτιμότερο να χωρίζετε τα δεδομένα σε υπο-παρτίδες αντί να εκκινείτε χιλιάδες tasks ταυτόχρονα:

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 προσφέρει πολλά πλεονεκτήματα: μπορείτε να εμφανίζετε την πρόοδο, να αποθηκεύετε ενδιάμεσα αποτελέσματα και να περιορίζετε τη χρήση μνήμης. Αν αποτύχει μια υπο-παρτίδα, δεν χάνετε τα αποτελέσματα από τις προηγούμενες υπο-παρτίδες.

Παρακολούθηση Προόδου

Για μεγάλες παρτίδες, ένας δείκτης προόδου είναι χρήσιμος:

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()  # νέα γραμμή μετά την πρόοδο
    return results

Βασικά σημεία

  • Το asyncio.gather(*tasks) εκτελεί coroutines παράλληλα και επιστρέφει τα αποτελέσματα στην αρχική σειρά
  • Το return_exceptions=True εμποδίζει ένα μοναδικό σφάλμα να αποτύχει ολόκληρη την παρτίδα
  • Το chunking σας επιτρέπει να διαχειρίζεστε πολύ μεγάλους όγκους χωρίς να κορεστεί η μνήμη
  • Συνδυάζετε πάντα το gather με ένα semaphore για να σέβεστε τα όρια ρυθμού (rate limits)
  • Προσθέστε παρακολούθηση προόδου για διαδικασίες μεγάλης διάρκειας