Summary  
This chapter covers generator functions and how the `yield` keyword pauses and resumes execution to produce values lazily and maintain state across iterations without storing the entire sequence in memory.

General domain of usage  
Data streaming and large-sequence processing

Een **generatorfunctie** is een speciaal type functie die het sleutelwoord `yield` gebruikt in plaats van `return` om een reeks waarden te genereren. Wanneer een generatorfunctie wordt aangeroepen, retourneert deze een iteratorobject, dat kan worden geïtereerd om waarden één voor één op te halen.

Definitie

Een **iteratorobject** is een object dat het iteratorprotocol implementeert door de methoden `__iter__()` en `__next__()` te definiëren. Hierdoor kun je elementen één voor één ophalen met `next()`, waardoor het mogelijk is om over items in reeksen of generatorfuncties te itereren.

Het belangrijkste voordeel van generatorfuncties is hun **geheugenefficiëntie**. In plaats van de volledige reeks vooraf te genereren en in het geheugen op te slaan, produceren generators waarden **on-the-fly** wanneer ze nodig zijn.

## Hoe `yield` werkt

In tegenstelling tot `return`, dat de functie volledig beëindigt, **pauzeert** `yield` de functie en slaat het de huidige status op. De volgende keer dat `next()` wordt aangeroepen, gaat de generator precies verder waar hij was gebleven:


def count_up(start, stop):
    while start <= stop:
        yield start  # Pause and return the current value
        start += 1   # Resume from here on the next call

counter = count_up(1, 3)

print(next(counter))  # 1
print(next(counter))  # 2
print(next(counter))  # 3

Je kunt ook over een generator itereren met een `for`-lus – deze roept automatisch `next()` aan totdat de generator is uitgeput:

def count_up(start, stop):
    while start <= stop:
        yield start
        start += 1

for value in count_up(1, 5):
    print(value)  # 1, 2, 3, 4, 5

Wanneer een generator is uitgeput (geen waarden meer om te genereren), zal het aanroepen van `next()` erop een `StopIteration`-fout veroorzaken. Een `for`-lus handelt dit automatisch af.

Opmerking

import unittest
import re

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

class TestEvenNumbers(unittest.TestCase):

    def test_even_numbers_is_generator(self):
        import user_code
        import types
        try:
            result = user_code.even_numbers(1, 10)
            condition = isinstance(result, types.GeneratorType)
            failure_message = "Expected `even_numbers` to return a generator object."
        except AttributeError:
            condition = False
            failure_message = "The function `even_numbers` is not defined."
        _dynamic_test(self, condition, "The `even_numbers` function returns a generator object.", failure_message)

    def test_even_numbers_correct_values(self):
        import user_code
        try:
            result = list(user_code.even_numbers(1, 10))
            expected = [2, 4, 6, 8, 10]
            condition = result == expected
            failure_message = f"Expected `{expected}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `even_numbers` is not defined."
        _dynamic_test(self, condition, f"The `even_numbers` generator yields `[2, 4, 6, 8, 10]` for range 1 to 10.", failure_message)

    def test_even_numbers_no_odd_values(self):
        import user_code
        try:
            result = list(user_code.even_numbers(1, 10))
            condition = all(n % 2 == 0 for n in result)
            failure_message = f"Expected only even numbers, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `even_numbers` is not defined."
        _dynamic_test(self, condition, "The `even_numbers` generator yields only even numbers.", failure_message)

    def test_even_numbers_different_range(self):
        import user_code
        try:
            result = list(user_code.even_numbers(5, 20))
            expected = [6, 8, 10, 12, 14, 16, 18, 20]
            condition = result == expected
            failure_message = f"Expected `{expected}` for range 5 to 20, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `even_numbers` is not defined."
        _dynamic_test(self, condition, f"The `even_numbers` generator correctly handles the range 5 to 20.", failure_message)

if __name__ == '__main__':
    unittest.main()

test_main.py

Krijg een grondig begrip van hoe functies de Python-programmering vormgeven. Beheers het definiëren en aanroepen van functies, het werken met argumenten, het afhandelen van returnwaarden en het creëren van flexibele, efficiënte code met behulp van recursie en lambda-expressies.

Ontdek wat functies zijn en waarom ze essentieel zijn in Python. Leer hoe functies worden aangemaakt, argumenten worden gedefinieerd, returnwaarden worden afgehandeld en ingebouwde functies effectief worden gebruikt.

Leer hoe positionele en optionele argumenten werken in Python. Ontwikkel flexibele functies die verschillende invoer aankunnen en de flexibiliteit van uw code verbeteren.

Inzicht in het werken met willekeurige en keyword-argumenten om variabele invoergroottes te verwerken.
Begrip van hoe deze technieken functies dynamischer en georganiseerder maken.

Ontdek hoe returnwaarden de output van een functie vertegenwoordigen.
Leer hoe u één of meerdere waarden retourneert, None gebruikt en generatoren toepast voor geavanceerdere gegevensstroomcontrole.

Ontgrendel geavanceerde functiethema's met recursie en lambda-functies. Leer hoe recursie herhalende problemen oplost en hoe lambda-expressies beknopte, éénregelige functies creëren.

Generatorfuncties

Hoe `yield` werkt

Oplossing

Generatorfuncties

Hoe yield werkt

Oplossing

Hoe `yield` werkt