Summary  
This chapter covers generator functions that use `yield` to pause and resume execution for memory-efficient, on-the-fly value production and support iteration via `next()` or `for` loops.

General domain of usage  
data stream 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 doorlopen om waarden één voor één op te halen.

Definitie

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 afsluit, **pauzeert** `yield` de functie en slaat de status ervan 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 yielden), zal het aanroepen van `next()` 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

Verkrijg een grondig begrip van hoe functies de Python-programmering vormgeven. Beheers het definiëren en aanroepen van functies, werken met argumenten, omgaan met 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 je functies maakt, argumenten definieert, returnwaarden afhandelt en ingebouwde functies effectief gebruikt.

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

Begrijpen hoe te werken met willekeurige en keyword-argumenten om variabele invoergroottes te verwerken. Leren hoe deze technieken uw functies dynamischer en georganiseerder maken.

Ontdek hoe returnwaarden de output van een functie vertegenwoordigen. Leer hoe je één of meerdere waarden retourneert, gebruikmaakt van None, en verken generators voor geavanceerdere controle over gegevensstromen.

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