Stel je voor dat je een logbestand van 10 GB in een lijst laadt, alleen maar om de fouten te vinden. Het is mogelijk dat uw programma onvoldoende geheugen heeft voordat het er een vindt. Python-generatoren lossen dit op door waarden op aanvraag één voor één te produceren, zodat je met vrijwel geen geheugen door enorme of zelfs eindeloze gegevens kunt werken.

Deze gids laat stap voor stap zien wat er werkelijk gebeurt als een generator draait. We hebben elk voorbeeld uitgevoerd op Python 3.13 en de uitvoer komt uit die run. Het helpt als je al vertrouwd bent met de functies en loops, die in onze Python-tutorial voor beginners worden besproken.

Wat is een generator?

Een generator is een speciaal soort iterator die u maakt door een functie te schrijven met behulp van yield. Elke functie met yield erin wordt automatisch een generatorfunctie, en als je deze aanroept, krijg je een generatorobject in plaats van dat je de code uitvoert.

def count_up(limit):
    print("starting")
    n = 1
    while n <= limit:
        yield n
        n += 1
    print("finished")

gen = count_up(2)
print(gen)

# <generator object count_up at 0x...>

Merk op dat “starten” niet werd afgedrukt. Door de functie aan te roepen, werd alleen de generator gemaakt. Er is nog niets binnengelopen.

Hoe rendement werkt, stap voor stap

Elke aanroep naar next() voert de functie uit totdat deze een yield bereikt, geeft die waarde terug en blijft op zijn plaats hangen. De volgende oproep wordt direct na die regel hervat, waarbij elke lokale variabele intact is.

print(next(gen))
# starting
# 1

print(next(gen))
# 2

next(gen)
# finished
# StopIteration

Volg de uitvoer zorgvuldig. “starten” verschijnt alleen op de eerste next(). Op de tweede keer gaat de uitvoering verder vanaf het punt waar deze stopte, dus n is nog steeds beschikbaar en wordt 2. Op de derde keer eindigt de lus, wordt ‘voltooid’ afgedrukt, valt de functie van het einde en verhoogt Python StopIteration om aan te geven dat er niets meer over is.

Je belt zelf zelden next(). Een for lus doet het voor je en handelt StopIteration rustig af, en dat geldt ook voor list(), sum() en soortgelijke functies:

print(list(count_up(3)))

# starting
# finished
# [1, 2, 3]

rendement versus rendement

Deze vertraging staat bekend als luie evaluatie: waarden worden alleen uitgewerkt als dat nodig is. Een vlakte return in een generator maakt er eenvoudigweg een einde aan, wat StopIteration activeert.

Het geheugenverschil, gemeten

We hebben een lijst van één miljoen vierkanten vergeleken met een gelijkwaardige generator, met behulp van sys.getsizeof:

import sys

squares_list = [n * n for n in range(1_000_000)]
squares_gen = (n * n for n in range(1_000_000))

print(sys.getsizeof(squares_list), sys.getsizeof(squares_gen))

# 8448728 200

De eigen structuur van de lijst nam ongeveer 8,4 MB in beslag, terwijl de generator op ons systeem slechts 200 bytes in beslag nam. De werkelijke kloof is zelfs nog groter, omdat getsizeof de gehele objecten in de lijst niet meetelt. De grootte van de generator blijft ook voor een miljard items hetzelfde, omdat deze alleen de huidige status opslaat en niet de resultaten.

Er is echter een wisselwerking. Met len() kan een lijst hergebruikt, geïndexeerd en gemeten worden. Een generator biedt dit allemaal niet. Als u willekeurige toegang nodig heeft, of als u meerdere keren een kleine hoeveelheid gegevens moet herhalen, is een lijst eenvoudiger. Zie onze gids voor Python-lijst versus tupel versus set voor meer informatie over deze typen.

Generator-expressies

Voor eenvoudige gevallen heb je geen functie nodig. Een generatorexpressie ziet eruit als een lijstbegrip met ronde haakjes in plaats van vierkante:

squares = [n * n for n in range(5)]   # builds a list now
squares = (n * n for n in range(5))   # produces values on demand

print(sum(n * n for n in range(5)))

# 30

Wanneer een generatorexpressie het enige argument voor een functie is, zoals in sum(), kunt u de extra haakjes weglaten. Dit is een nette gewoonte voor totalen over grote gegevens, omdat er geen tijdelijke lijst wordt gemaakt.

Bouw een datapijplijn

Dit is waar generatoren echt uitblinken. Kleine generatoren kunnen aan elkaar worden gekoppeld, zodat elk item één voor één elke stap doorloopt:

def read_lines(lines):
    for line in lines:
        yield line.strip()

def only_errors(lines):
    for line in lines:
        if line.startswith("ERROR"):
            yield line

def messages(lines):
    for line in lines:
        yield line.split(" ", 1)[1]

log = ["INFO started\n", "ERROR db down\n",
       "ERROR disk full\n", "INFO stopped\n"]

print(list(messages(only_errors(read_lines(log)))))

# ['db down', 'disk full']

Elke stap doet één klein klusje en kan op zichzelf worden getest. Bij echt gebruik kunt u de voorbeeldlijst vervangen door een geopend bestand, omdat bestandsobjecten regel voor regel kunnen worden gelezen, zoals onze gids voor Python-bestandsverwerking laat zien. Zelfs een log van meerdere gigabytes zou dan met heel weinig geheugen passeren.

Oneindige reeksen

Een lijst kan niet oneindig zijn, maar een generator wel, omdat deze alleen de volgende waarde berekent. Gebruik itertools.islice om er zoveel te nemen als je nodig hebt:

import itertools

def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

print(list(itertools.islice(fibonacci(), 8)))

# [0, 1, 1, 2, 3, 5, 8, 13]

Wees echter voorzichtig: het aanroepen van list(fibonacci()) zonder limiet zou duren totdat je geheugen verdwenen is. Hetzelfde patroon is geschikt voor ID-generatoren, pollinglussen en gepagineerde API-resultaten, waarbij u de volgende pagina pas ophaalt als de huidige leeg is.

opbrengst uit en batches

yield from ga verder met een andere iterabele, waardoor je een geneste lus bespaart:

def chain_all(*groups):
    for group in groups:
        yield from group

print(list(chain_all([1, 2], (3, 4))))

# [1, 2, 3, 4]

Een heel praktisch patroon is het opsplitsen van gegevens in batches van vaste grootte, bijvoorbeeld om duizend rijen tegelijk in een database in te voegen:

def batches(items, size):
    batch = []
    for item in items:
        batch.append(item)
        if len(batch) == size:
            yield batch
            batch = []
    if batch:
        yield batch

print(list(batches(range(7), 3)))

# [[0, 1, 2], [3, 4, 5], [6]]

De laatste if batch zorgt ervoor dat er geen kleinere overgebleven groep verloren gaat. Python 3.12 en hoger bevatten ook itertools.batched, dat een soortgelijke taak vervult.

verzenden, sluiten en opruimen

Generatoren kunnen ook waarden ontvangen. send() hervat de generator en de waarde wordt het resultaat van de expressie yield. U moet eerst één keer next() bellen om de eerste yield te bereiken:

def running_total():
    total = 0
    while True:
        value = yield total
        total += value

t = running_total()
next(t)
print(t.send(10), t.send(5))

# 10 15

De meeste mensen hebben dit zelden nodig. Een meer algemeen probleem is opruimen. Als je eerder stopt, loopt er nog steeds een finally blok als de generator gesloten is:

def tracked():
    try:
        yield 1
        yield 2
    finally:
        print("cleanup ran")

tr = tracked()
next(tr)
tr.close()

# cleanup ran

Pytest gebruikt precies dit idee: een armatuur met yield voert de opschoning achteraf uit, zoals onze pytest-tutorial laat zien. Op dezelfde manier verandert de contextmanager decorateur van de standaardbibliotheek een generator in een with blok.

Generatoren in klassen

Het schrijven van een __iter__ methode als generator is de gemakkelijkste manier om je eigen klasse itereerbaar te maken. Een bonus is dat elke lus een nieuwe generator krijgt, zodat het object steeds opnieuw kan worden herhaald:

class Countdown:
    def __init__(self, start):
        self.start = start

    def __iter__(self):
        n = self.start
        while n > 0:
            yield n
            n -= 1

c = Countdown(3)
print(list(c), list(c))

# [3, 2, 1] [3, 2, 1]

Wanneer moet u een generator gebruiken?

Een generator is over het algemeen niet altijd sneller. Als je uiteindelijk elke waarde gebruikt, is het totale werk vergelijkbaar en kan het begrijpen van een lijst zelfs sneller gaan voor kleine gegevens, omdat er minder overhead per item is. De belangrijkste voordelen zijn het geheugengebruik en het sneller verkrijgen van de eerste resultaten.

Veel voorkomende fouten

Een uitgeputte generator hergebruiken

Dit overkomt bijna iedereen op een gegeven moment. Een generator onthoudt dat het klaar is:

g = count_up(2)
print(list(g), list(g))

# [1, 2] []

De tweede oproep krijgt een lege lijst zonder enige fout. Roep de functie opnieuw aan om een ​​nieuwe generator te krijgen, of gebruik de hierboven getoonde klassenbenadering.

Er wordt verwacht dat de code onmiddellijk wordt uitgevoerd

def noisy():
    print("body runs")
    yield 1

n = noisy()        # nothing is printed
print(next(n))     # body runs, then 1

Argumentcontroles bovenaan een generator worden pas uitgevoerd bij de eerste next(), dus fouten kunnen ver verwijderd zijn van de oproep die ze heeft veroorzaakt.

Andere vallen

• Calen len() of indexeren. Generatoren ondersteunen geen van beide en verhogen een TypeError.
• Een bestand te vroeg sluiten. Het retourneren van een generator vanuit een with blok kan betekenen dat het bestand wordt gesloten voordat er een regel is gelezen. Plaats de yield in het with blok.
• Alles inpakken list(). Dat gooit het geheugenvoordeel weg.
• Gebruik er één voor kleine gegevens. Een eenvoudige lijst is vaak duidelijker.

Tot slot

Een generator is een functie die kan pauzeren. Dat ene idee zorgt voor een laag geheugengebruik, eindeloze reeksen en schone pijplijnen. Om het in de praktijk te brengen, zoek je een plek in je code waar een grote lijst wordt opgebouwd die je maar één keer kunt doorlopen, en verander je die in een generator. Probeer dan twee kleine generatoren aan elkaar te koppelen in een echt logbestand.

Veelgestelde vragen

Blijf leren