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

Recall that `yield` pauses a generator and resumes it on the next `next()` call. So far, the generators you have seen had a clear stopping point. But generators become especially powerful when combined with an **infinite loop** – producing values indefinitely without ever storing them in memory.

## Infinite Generators with `while True`

Using a `while True` loop inside a generator creates an **infinite sequence** – something that would be impossible to store as a list. The generator only produces the next value when `next()` is called:


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

No matter how many times you call `next()`, the generator will always have a new value ready – it never runs ahead or stores values in memory.

## Controlling an Infinite Generator

Since the generator runs forever, you need to control how many values you retrieve. The most common way is using a `for` loop with `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

Never iterate over an infinite generator with a plain `for` loop without a stopping condition – it will run forever and crash your program.

Note

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

Erwerben Sie ein fundiertes Verständnis dafür, wie Funktionen die Python-Programmierung prägen. Beherrschen Sie das Definieren und Aufrufen von Funktionen, das Arbeiten mit Argumenten, das Verwalten von Rückgabewerten sowie das Erstellen flexibler und effizienter Codes mithilfe von Rekursion und Lambda-Ausdrücken.

Erkunden Sie, was Funktionen sind und warum sie in Python unverzichtbar sind. Lernen Sie, wie man Funktionen erstellt, Argumente definiert, Rückgabewerte verarbeitet und eingebaute Funktionen effektiv nutzt.

Erfahren Sie, wie Positions- und optionale Argumente in Python funktionieren. Entwicklung anpassungsfähiger Funktionen, die verschiedene Eingaben verarbeiten und die Flexibilität Ihres Codes verbessern.

Verstehen, wie mit beliebigen und Schlüsselwortargumenten gearbeitet wird, um variable Eingabegrößen zu verarbeiten. Erfahren, wie diese Techniken Ihre Funktionen dynamischer und organisierter machen.

Erfahren Sie, wie Rückgabewerte die Ausgabe einer Funktion darstellen. Lernen Sie, einzelne oder mehrere Werte zurückzugeben, None zu verwenden und Generatoren für eine fortgeschrittene Steuerung des Datenflusses zu nutzen.

Erschließen Sie fortgeschrittene Funktionskonzepte mit Rekursion und Lambda-Funktionen. Lernen Sie, wie Rekursion wiederkehrende Probleme löst und wie Lambda-Ausdrücke prägnante, einzeilige Funktionen erstellen.

Infinite Generators

Infinite Generators with while True

Controlling an Infinite Generator

Lösung

Infinite Generators with `while True`