Generators

Generatoren zijn een speciaal type iterator in Python waarmee je lui over gegevens kunt itereren. In plaats van alle gegevens in één keer terug te geven, leveren ze telkens één element op, waardoor ze efficiënt met geheugen omgaan.

In deze les leer je hoe je generatoren in Python maakt en gebruikt.

Een generator is een functie die het sleutelwoord yield gebruikt om telkens één waarde terug te geven. Elke aanroep van de methode next() van de generator hervat de uitvoering vanaf de plek waar de generator voor het laatst een waarde opleverde.

# Basic generator example
def my_generator():
    yield 1
    yield 2
    yield 3

# Using the generator
gen = my_generator()
print(next(gen))  # Outputs: 1
print(next(gen))  # Outputs: 2
print(next(gen))  # Outputs: 3

Generatoren bewaren de toestand van de functie, zodat ze de uitvoering precies kunnen hervatten op het punt waar ze waren gestopt. Daardoor gaan ze efficiënt met geheugen om en zijn ze ideaal voor grote gegevensverzamelingen.

# Example: Generating a range of numbers
def range_generator(start, end):
    while start < end:
        yield start
        start += 1

for number in range_generator(1, 5):
    print(number)  # Outputs: 1, 2, 3, 4

Generator-expressies lijken op lijstcomprehensies, maar gebruiken ronde haakjes in plaats van vierkante haakjes. Ze maken generatoren in plaats van lijsten.

# Generator expression
gen_exp = (x * x for x in range(5))

for value in gen_exp:
    print(value)  # Outputs: 0, 1, 4, 9, 16

Generatoren gaan efficiënter met geheugen om dan lijsten, omdat ze niet alle gegevens in het geheugen opslaan. In plaats daarvan genereren ze de gegevens tijdens het uitvoeren.

# Comparing lists and generators
# List comprehension
list_comp = [x * x for x in range(1000000)]

# Generator expression
gen_exp = (x * x for x in range(1000000))

# List comprehension uses more memory
print(type(list_comp))  # Outputs: <class 'list'>
print(type(gen_exp))    # Outputs: <class 'generator'>

Generatoren zijn ideaal voor:

• Het verwerken van grote gegevensverzamelingen die niet in het geheugen passen.
• Het genereren van oneindige reeksen.
• Luie evaluatie van gegevens.

Generatoren kunnen oneindige reeksen produceren, zoals een eindeloze reeks getallen. Zorg ervoor dat je de lus stopt om oneindige uitvoering te voorkomen.

# Infinite generator example
def infinite_sequence():
    num = 0
    while True:
        yield num
        num += 1

# Using the infinite generator
for i in infinite_sequence():
    if i > 5:
        break
    print(i)  # Outputs: 0, 1, 2, 3, 4, 5

Generatorfuncties kunnen meerdere yield-instructies bevatten, waarmee je complexe reeksen kunt maken:

# Multiple yields in a generator
def multi_yield():
    yield "First"
    yield "Second"
    yield "Third"

for value in multi_yield():
    print(value)  # Outputs: First, Second, Third

Dit zijn enkele fouten die je moet vermijden:

• return gebruiken in plaats van yield in een generatorfunctie.
• De generator niet uitlezen met een lus of next().
• Generatoren gebruiken voor kleine gegevensverzamelingen waarvoor lijsten geschikter zijn.

In deze les heb je geleerd:

• Wat generatoren zijn en hoe ze in Python werken.
• Hoe je yield gebruikt om generatorfuncties te maken.
• Wat de verschillen zijn tussen generatoren en lijsten.
• Welke toepassingen generatoren hebben, zoals oneindige reeksen en grote gegevensverzamelingen.

Goed gedaan! Laten we doorgaan naar het volgende onderwerp.