Summary  
This chapter covers how to implement infinite generators using `yield` inside a `while True` loop to produce unbounded sequences of values on demand and control their retrieval with `next()` or iteration constructs.  

General domain of usage  
Data streaming

Onthoud dat `yield` een generator pauzeert en deze hervat bij de volgende `next()`-aanroep. Tot nu toe hadden de generators die je hebt gezien een duidelijk eindpunt. Maar generators worden bijzonder krachtig wanneer ze worden gecombineerd met een **oneindige lus** – waarbij waarden oneindig worden geproduceerd zonder ze ooit in het geheugen op te slaan.

## Oneindige generators met `while True`

Het gebruik van een `while True`-lus binnen een generator creëert een **oneindige reeks** – iets dat onmogelijk als lijst kan worden opgeslagen. De generator produceert alleen de volgende waarde wanneer `next()` wordt aangeroepen:


def counter():
    count = 1
    while True:       # Runs forever
        yield count   # Return current value and pause
        count += 1    # Resume from here on the next call

gen = counter()

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

Hoe vaak je `next()` ook aanroept, de generator heeft altijd een nieuwe waarde klaar – hij loopt nooit vooruit en slaat geen waarden op in het geheugen.

## Een oneindige generator beheersen

Omdat de generator oneindig doorgaat, moet je bepalen hoeveel waarden je wilt ophalen. De meest gebruikelijke manier is met een `for`-lus en `range()`:


def counter():
    count = 1
    while True:
        yield count
        count += 1

gen = counter()

for _ in range(5):
    print(next(gen))  # 1, 2, 3, 4, 5

Nooit itereren over een oneindige generator met een gewone `for`-lus zonder stopvoorwaarde – dit blijft oneindig doorgaan en zal je programma laten vastlopen.

Opmerking

import unittest
import types

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 TestIdGenerator(unittest.TestCase):

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

    def test_first_five_ids(self):
        import user_code
        try:
            gen = user_code.id_generator()
            result = [next(gen) for _ in range(5)]
            expected = ["ID_1", "ID_2", "ID_3", "ID_4", "ID_5"]
            condition = result == expected
            failure_message = f"Expected `{expected}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `id_generator` is not defined."
        _dynamic_test(self, condition, f"The `id_generator` correctly generates `['ID_1', 'ID_2', 'ID_3', 'ID_4', 'ID_5']`.", failure_message)

    def test_id_format(self):
        import user_code
        try:
            gen = user_code.id_generator()
            result = [next(gen) for _ in range(5)]
            condition = all(id.startswith("ID_") for id in result)
            failure_message = f"Expected all IDs to follow the format `ID_N`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `id_generator` is not defined."
        _dynamic_test(self, condition, "All generated IDs follow the format `ID_N`.", failure_message)

    def test_ids_are_sequential(self):
        import user_code
        try:
            gen = user_code.id_generator()
            result = [next(gen) for _ in range(5)]
            numbers = [int(id.split("_")[1]) for id in result]
            condition = numbers == list(range(1, 6))
            failure_message = f"Expected sequential IDs starting from 1, but got `{result}`."
        except (AttributeError, ValueError):
            condition = False
            failure_message = "Could not verify sequential IDs — make sure the format is `ID_N`."
        _dynamic_test(self, condition, "The generated IDs are sequential starting from `ID_1`.", 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.

Oneindige Generatoren

Oneindige generators met `while True`

Een oneindige generator beheersen

Oplossing

Oneindige Generatoren

Oneindige generators met while True

Een oneindige generator beheersen

Oplossing

Oneindige generators met `while True`