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

Husk, at `yield` sætter en generator på pause og genoptager den ved næste `next()`-kald. Indtil nu har de generatorer, du har set, haft et tydeligt stoppunkt. Men generatorer bliver særligt kraftfulde, når de kombineres med et **uendeligt loop** – hvilket muliggør produktion af værdier uendeligt uden nogensinde at gemme dem i hukommelsen.

## Uendelige generatorer med `while True`

Brug af et `while True`-loop inde i en generator skaber en **uendelig sekvens** – noget, der ville være umuligt at gemme som en liste. Generatoren producerer kun den næste værdi, når `next()` kaldes:


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

Uanset hvor mange gange du kalder `next()`, vil generatoren altid have en ny værdi klar – den kører aldrig forud eller gemmer værdier i hukommelsen.

## Styring af en uendelig generator

Da generatoren kører uendeligt, skal du styre, hvor mange værdier du henter. Den mest almindelige metode er at bruge en `for`-løkke med `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

Undlad at iterere over en uendelig generator med en almindelig `for`-løkke uden en stopbetingelse – den vil køre uendeligt og få dit program til at gå ned.

Bemærk

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

Få en solid forståelse af, hvordan funktioner former Python-programmering. Opnå færdigheder i at definere og kalde funktioner, arbejde med argumenter, håndtere returværdier samt skabe fleksibel og effektiv kode ved hjælp af rekursion og lambda-udtryk.

Udforsk, hvad funktioner er, og hvorfor de er essentielle i Python. Lær, hvordan man opretter funktioner, definerer argumenter, håndterer returværdier og bruger indbyggede funktioner effektivt.

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

Forstå hvordan man arbejder med vilkårlige og navngivne argumenter 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, bruge None og udforsk generatorer for mere avanceret styring af dataflow.

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

Uendelige Generatorer

Uendelige generatorer med `while True`

Styring af en uendelig generator

Løsning

Uendelige Generatorer

Uendelige generatorer med while True

Styring af en uendelig generator

Løsning

Uendelige generatorer med `while True`