Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

asyncio.gather don Phróiseáil Bhaisce

Ceacht 5 as 12 Nuashonraithe 30 Iúil 2026 Ardleibhéal
Ar an leathanach seo
  1. Orchestru Iarratais Chomhthreomhara
  2. Bunshintacs
  3. Patrún Iomlán: Baisc le Seafamar
  4. Earráidí a Láimhseáil i mBaisc
  5. Roinnt i bhFo-bhaisceanna (Chunking)
  6. Rianú Dul Chun Cinn
  7. Príomhphointí

Orchestru Iarratais Chomhthreomhara

Is é asyncio.gather an fheidhm lárnach chun ilchóras (coroutines) a rith go comhthreomhar agus na torthaí go léir a bhailiú. Nuair a chomhcheanglaítear le seafamar é, ligeann sé duit baisceanna iarratas a phróiseáil go héifeachtach agus teorainneacha API a urramú ag an am céanna.

Bunshintacs

import asyncio

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

Glacann asyncio.gather le líon athraitheach córas (sin fáth a bhfuil *tasks ann chun an liosta a dhíphacáistiú) agus filleann sé liosta torthaí san ord céanna leis na tascanna a cuireadh isteach. Is pointe tábhachtach é seo: fiú má chríochnaíonn ceist 3 roimh cheist 1, beidh toradh do cheist 1 i responses[0] i gcónaí.

Patrún Iomlán: Baisc le Seafamar

Seo an patrún a úsáidfidh tú is minice sa táirgeadh:

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)

Cuimsíonn an patrún seo an seafamar laistigh den fheidhm bhaisce. Ní gá duit ach process_batch(prompts) a ghlaow agus an liosta freagraí a fháil ar ais.

Earráidí a Láimhseáil i mBaisc

De réir réamhshocraithe, má ardaíonn córas amháin eisceacht, cealaíonn asyncio.gather gach rud agus scaipeann sé an earráid. Athraíonn an paraiméadar return_exceptions=True an t-iompar seo:

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

Le return_exceptions=True, gabhtar earráidí mar luachanna sa liosta torthaí. Is féidir leat iarratais theipthe a aithint agus iad a athriacht ansin.

Roinnt i bhFo-bhaisceanna (Chunking)

Do thoirt an-mhór, is fearr roinnt i bhfo-bhaisceanna seachas na mílte tasc a sheoladh ag an am céanna:

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

Tairgeann chunking roinnt buntáistí: is féidir leat dul chun cinn a thaispeáint, torthaí idirmheánacha a shábháil, agus úsáid cuimhne a theorannú. Má theipeann ar fho-bhaisc amháin, ní chailleann tú na torthaí ó fho-bhaisceanna roimhe sin.

Rianú Dul Chun Cinn

Do bhaisceanna móra, tá táscaire dul chun cinn úsáideach:

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

Príomhphointí

  • Rithíonn asyncio.gather(*tasks) córais go comhthreomhar agus filleann sé torthaí san ord bunaidh
  • Coscaíonn return_exceptions=True ar earráid amháin an bhaisc iomlán a theip
  • Ligeann chunking duit toirt an-mhór a láimhseáil gan an chuimhne a líonadh
  • Comhcheangail gather le seafamar i gcónaí chun teorainneacha ráta a urramú
  • Cuir rianú dul chun cinn leis do phróisis a mhaireann fada