Meerdere resultaten verzamelen met gather

Een dagrapport vraagt drie onafhankelijke aantallen op. De snelste bron hoort niet automatisch in de eerste kolom van het rapport: die kolom heeft al een betekenis. Je wilt het werk laten overlappen en toch kunnen vertrouwen op de koppeling tussen elke bron en haar resultaat.

Eén await voor meerdere bewerkingen

Met asyncio.gather wacht je op meerdere awaitables tegelijk. Je geeft de coroutineobjecten als afzonderlijke argumenten mee. Gather plant coroutines als taken en geeft bij een succesvolle uitvoering een lijst met hun resultaten terug.

Die lijst volgt de volgorde van de argumenten. De eerste bron kan als laatste klaar zijn en toch het eerste resultaat leveren. De volgorde van klaar zijn is dus iets anders dan de volgorde waarin je de resultaten later gebruikt.

import asyncio

async def tickets():
    await asyncio.sleep(0)
    return 6

async def visitors():
    await asyncio.sleep(0)
    return 18

async def main():
    counts = await asyncio.gather(tickets(), visitors())
    print(counts)
    print("tickets:", counts[0])
    print("bezoekers:", counts[1])

asyncio.run(main())

[6, 18]
tickets: 6
bezoekers: 18

Het voorbeeld vraagt informatie voor twee vaste kolommen op. De getallen hoeven niet op dezelfde manier berekend te worden om ze samen te kunnen afwachten. Je kunt aan de twee posities zien bij welke aanroep elk getal hoort.

Heb je een lijst coroutineobjecten, dan gebruik je asyncio.gather(*pending). De ster pakt de lijst uit tot losse argumenten. In deze oefeningen krijg je juist een lijst async functies: maak daar eerst de coroutineobjecten van met job() voor iedere functie.

Eén uitvoering, meerdere gebruiksmogelijkheden

Na het verzamelen heb je gewone waarden. Je kunt ze optellen, aan een naam koppelen of later nogmaals bekijken zonder de bronnen opnieuw uit te voeren. Voor een lege lijst bronnen is de verzamelde lijst leeg en de som van die waarden nul.

Roep de functies precies eenmaal aan. job() een keer voor de som en daarna nog eens voor de weergave maakt twee uitvoeringen. Dat kan meer werk veroorzaken of zelfs een ander antwoord opleveren wanneer een bron intussen verandert.

Gewone fouten laten doorgaan

Standaard geeft gather de eerste gewone uitzondering door aan de coroutine die erop wacht. Dat is nuttig wanneer het complete rapport zonder één van de bronnen geen betekenis heeft. Een fout vervangen door nul kan dan een overtuigend maar onjuist totaal opleveren.

Een andere belangrijke eigenschap: het doorgaan van die fout annuleert de andere bewerkingen niet automatisch. Zij kunnen nog lopen wanneer de aanroeper de fout ontvangt. De code die het werk beheert blijft verantwoordelijk voor wat er daarna met dat werk gebeurt.

In deze les laat de oefenomgeving die andere bron gecontroleerd afronden. In de volgende les onderzoek je TaskGroup, waarmee de levensduur van verwant werk anders wordt geregeld. Gather en TaskGroup zijn daarom geen uitwisselbare spellingen van hetzelfde foutbeleid.

Fouten als deelresultaat

Met return_exceptions=True wacht gather ook bij gewone fouten op de andere bewerkingen. Op de plaats van een mislukte bewerking staat dan het exceptionobject. Dat object is geen geslaagd antwoord: de aanroeper moet het bewust herkennen en verwerken.

import asyncio

async def stock():
    await asyncio.sleep(0)
    return 7

async def price():
    await asyncio.sleep(0)
    raise ValueError("prijs ontbreekt")

async def main():
    results = await asyncio.gather(stock(), price(), return_exceptions=True)
    for result in results:
        if isinstance(result, Exception):
            print(type(result).__name__ + ": " + str(result))
        else:
            print("waarde:", result)

asyncio.run(main())

waarde: 7
ValueError: prijs ontbreekt

Het voorbeeld maakt zichtbaar welke bron bruikbaar is en welke fout ging. Deze oefening gebruikt gewone exceptions, zoals ValueError. Annulering heeft een eigen betekenis en volgt in een latere les.

Veelgemaakte fout: een foutobject als waarde gebruiken

Wie alle antwoorden zonder controle optelt, kan proberen een getal bij een exceptionobject op te tellen. Het gevolg is een nieuwe fout die het oorspronkelijke probleem onduidelijk maakt. Controleer daarom eerst of een uitkomst een Exception is wanneer je voor foutresultaten hebt gekozen.

De opdrachten houden beide beleidskeuzes apart. Een strikte functie geeft de oorspronkelijke fout door; de functie voor deelresultaten maakt juist expliciete tuples met "ok" of "error". Bewaar daarbij de foutklasse en melding, zodat de lezer begrijpt waarom een onderdeel ontbreekt.

Samenvatting

• Gather verzamelt succesvolle resultaten in argumentvolgorde, onafhankelijk van de eindvolgorde.
• Met * pak je een lijst awaitables uit; voer iedere bron eenmaal uit.
• Kies bewust tussen een fout laten doorgaan en foutobjecten als deelresultaten behandelen.

Hierna onderzoek je hoe TaskGroup verwante taken bij een fout gezamenlijk afrondt.