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

Opnå en solid forståelse af, hvordan funktioner former Python-programmering. Behersk definition og kald af funktioner, arbejde med argumenter, håndtering af returværdier samt oprettelse af fleksibel og effektiv kode ved brug af rekursion og lambda-udtryk.

Undersøg hvad funktioner er, og hvorfor de er essentielle i Python. Lær at oprette funktioner, definere argumenter, håndtere returværdier og anvende indbyggede funktioner effektivt.

Lær, hvordan positionelle og valgfrie argumenter fungerer i Python. Udarbejd fleksible funktioner, der håndterer forskellige input og øger fleksibiliteten i din kode.

Forstå hvordan man arbejder med vilkårlige og nøgleordsargumenter for at håndtere variable inputstørrelser. Lær hvordan disse teknikker gør dine funktioner mere dynamiske og organiserede.

Opdag, hvordan returværdier repræsenterer en funktions output. Lær at returnere enkelt- eller flere værdier, anvende None samt udforske generatorer for mere avanceret styring af dataflow.

Lås op for avancerede funktionskoncepter med rekursion og lambda-funktioner. Forstå hvordan rekursion løser gentagne problemer, og hvordan lambda-udtryk skaber korte, énliniers funktioner.

Infinite Generators

Infinite Generators with while True

Controlling an Infinite Generator

Løsning

Infinite Generators with `while True`