Python's yield meesteren: Generator vs Return – Een praktische gids

Wat is Python Yield?

Het yield keyword gedraagt zich als return, maar in plaats van direct een waarde terug te geven, retourneert het een generator-object dat geïtereerd kan worden. Wanneer een functie met yield wordt aangeroepen, pauzeert de uitvoering bij de eerste yield statement en geeft controle terug aan de caller met een generator. Opvolgende aanroepen naar next() of een for lus hervatten de uitvoering vanaf dat punt, yielding de volgende waarde.

Belangrijkste takeaways

• Yield creëert een generator, wat lazy evaluation mogelijk maakt.
• Generators zijn geheugenefficiënt voor grote of oneindige sequences.
• Uitlezen uit een generator kan met for-in, list(), of next().
• Eenmaal uitgeput, kan een generator niet hergebruikt worden; roep de functie opnieuw aan.

Syntax

yield expression

Praktisch voorbeeld: Een simpele yield

def test_yield():
    yield "Welkom bij Guru99 Python Tutorials"
output = test_yield()
print(output)

Output:

<generator object test_yield at 0x00000028265EB9A8>

Het generator-object bevat de geyieldede waarde. Om er toegang te krijgen, itereer:

for value in output:
    print(value)

Output:

Welkom bij Guru99 Python Tutorials

Generators uitgelegd

Een generator-functie is een speciale functie die een itereerbaar generator-object retourneert. In tegenstelling tot reguliere functies die een enkele waarde retourneren, yieldt een generator een reeks waarden lazy, wat elk alleen produceert wanneer gevraagd.

Een generator-functie maken

def generator_example():
    yield "H"
    yield "E"
    yield "L"
    yield "L"
    yield "O"
for letter in generator_example():
    print(letter)

Output:

H
E
L
L
O

Normale functie vs Generator functie

Overweeg het volgende paar functies:

# Normale functie
def normal_test():
    return "Hello World"
# Generator functie
def generator_test():
    yield "Hello World"
print(normal_test())  # → Hello World
print(generator_test())  # → <generator object generator_test>

Normale functies termineren bij return; generators pauzeren bij yield, retourneer controle aan de caller met een generator-object.

Een generator consumeren

Je kunt waarden uit een generator halen met:

• for-in loops
• list() om alle waarden te materialiseren
• next() voor handmatige stappen

Voorbeeld: Even getallen

def even_numbers(n):
    for x in range(n):
        if x % 2 == 0:
            yield x
print(list(even_numbers(10)))  # → [0, 2, 4, 6, 8]

for-in gebruiken

for num in even_numbers(10):
    print(num)

Output:

0
2
4
6
8

next() gebruiken

gen = even_numbers(10)
for _ in range(6):
    try:
        print(next(gen))
    except StopIteration:
        print("Einde van generator")

Output:

0
2
4
6
8
Einde van generator

Generators zijn éénmalig gebruik

Eenmaal een generator volledig geïtereerd is, is hij uitgeput. Opnieuw itereren levert niets op tenzij de generator-functie opnieuw wordt aangeroepen.

gen = even_numbers(10)
for num in gen:
    print(num)
print(list(gen))  # → []

Yield in actie: Fibonacci-reeks

def fibonacci_series(limit):
    a, b = 0, 1
    count = 0
    while count < limit:
        yield a
        a, b = b, a + b
        count += 1
fib = fibonacci_series(7)
for num in fib:
    print(num)

Output:

0
1
1
2
3
5
8

Een functie aanroepen die yieldt

Hieronder kwadrateren we getallen met een helper en een generator die elk resultaat yieldt.

def square(n):
    return n * n
def square_range(n):
    for i in range(n):
        yield square(i)
for value in square_range(10):
    print(value)

Output:

0
1
4
9
16
25
36
49
64
81

Wanneer yield te gebruiken boven return

• Verwerken van grote of streaming data waar het laden van alle items ineens onpraktisch is.
• Genereren van potentiële oneindige sequences (bijv. lazy file readers).
• Geheugenvoetafdruk en opstarttijd verbeteren voor grote datasets.
• Wanneer je berekening wilt pauzeren en hervatten, niet alleen een finale waarde retourneren.

Yield vs. Return – Snelle referentie

Belangrijkste takeaways

• Yield produceert een generator-object, geen waarde.
• Generators leveren waarden lazy, wat geheugengebruik minimaal houdt.
• Waarden uitlezen via for-in, list(), of next().
• Eenmaal uitgeput, moeten generators opnieuw aangeroepen worden voor hergebruik.
• Yield presteert beter dan return voor grote of streaming data.