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

Kom ihåg att `yield` pausar en generator och återupptar den vid nästa anrop av `next()`. Hittills har de generatorer du har sett haft en tydlig slutpunkt. Men generatorer blir särskilt kraftfulla när de kombineras med en **oändlig loop** – de genererar värden utan slut utan att någonsin lagra dem i minnet.

## Oändliga generatorer med `while True`

Att använda en `while True`-loop inuti en generator skapar en **oändlig sekvens** – något som vore omöjligt att lagra som en lista. Generatorn producerar endast nästa värde när `next()` anropas:


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

Oavsett hur många gånger du anropar `next()`, kommer generatorn alltid att ha ett nytt värde redo – den ligger aldrig före eller lagrar värden i minnet.

## Kontroll av en oändlig generator

Eftersom generatorn körs för alltid behöver du styra hur många värden du hämtar. Det vanligaste sättet är att använda en `for`-loop 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

Iterera aldrig över en oändlig generator med en vanlig `for`-loop utan ett stoppvillkor – den kommer att köra för alltid och krascha ditt program.

Observera

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 gedigen förståelse för hur funktioner formar Python-programmering. Bemästra att definiera och anropa funktioner, arbeta med argument, hantera returvärden och skapa flexibel, effektiv kod med rekursion och lambda-uttryck.

Utforska vad funktioner är och varför de är viktiga i Python. Lär dig hur man skapar funktioner, definierar argument, hanterar returvärden och använder inbyggda funktioner effektivt.

Lär dig hur positionella och valfria argument fungerar i Python. Skapa anpassningsbara funktioner som hanterar olika indata och förbättrar flexibiliteten i din kod.

Förstå hur man arbetar med godtyckliga och nyckelordsargument för att hantera variabla inmatningsstorlekar. Lär dig hur dessa tekniker gör dina funktioner mer dynamiska och organiserade.

Upptäck hur returvärden representerar en funktions utdata. Lär dig att returnera enskilda eller flera värden, använda None och utforska generatorer för mer avancerad kontroll av dataflöde.

Lås upp avancerade funktionskoncept med rekursion och lambda-funktioner. Lär dig hur rekursion löser repetitiva problem och hur lambda-uttryck skapar koncisa, enradiga funktioner.

Oändliga Generatorer

Oändliga generatorer med `while True`

Kontroll av en oändlig generator

Lösning

Oändliga Generatorer

Oändliga generatorer med while True

Kontroll av en oändlig generator

Lösning

Oändliga generatorer med `while True`