Summary  
This chapter covers generator functions and how the `yield` keyword pauses and resumes execution to produce values lazily and maintain state across iterations without storing the entire sequence in memory.

General domain of usage  
Data streaming and large-sequence processing

En **generatorfunktion** är en speciell typ av funktion som använder nyckelordet `yield` istället för `return` för att generera en sekvens av värden. När en generatorfunktion anropas returnerar den ett iteratorobjekt, vilket kan itereras över för att hämta värden ett i taget.

Definition

Ett **iteratorobjekt** är ett objekt som implementerar iteratorprotokollet genom att definiera metoderna `__iter__()` och `__next__()`. Detta gör det möjligt att hämta element ett i taget med `next()`, vilket möjliggör iteration över objekt i sekvenser eller generatorfunktioner.

Den främsta fördelen med generatorfunktioner är deras **minnes­effektivitet**. Istället för att generera hela sekvensen på förhand och lagra den i minnet, producerar generatorer värden **i realtid** när de behövs.

## Hur `yield` fungerar

Till skillnad från `return`, som avslutar funktionen helt, **pausar** `yield` funktionen och sparar dess tillstånd. Nästa gång `next()` anropas återupptas generatorn exakt där den pausades:


def count_up(start, stop):
    while start <= stop:
        yield start  # Pause and return the current value
        start += 1   # Resume from here on the next call

counter = count_up(1, 3)

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

Du kan också iterera över en generator med en `for`-loop – den anropar automatiskt `next()` tills generatorn är slut:

def count_up(start, stop):
    while start <= stop:
        yield start
        start += 1

for value in count_up(1, 5):
    print(value)  # 1, 2, 3, 4, 5

När en generator är uttömd (inga fler värden att yielda), kommer ett anrop till `next()` att utlösa ett `StopIteration`-undantag. En `for`-loop hanterar detta automatiskt.

Notering

import unittest
import re

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

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

    def test_even_numbers_correct_values(self):
        import user_code
        try:
            result = list(user_code.even_numbers(1, 10))
            expected = [2, 4, 6, 8, 10]
            condition = result == expected
            failure_message = f"Expected `{expected}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `even_numbers` is not defined."
        _dynamic_test(self, condition, f"The `even_numbers` generator yields `[2, 4, 6, 8, 10]` for range 1 to 10.", failure_message)

    def test_even_numbers_no_odd_values(self):
        import user_code
        try:
            result = list(user_code.even_numbers(1, 10))
            condition = all(n % 2 == 0 for n in result)
            failure_message = f"Expected only even numbers, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `even_numbers` is not defined."
        _dynamic_test(self, condition, "The `even_numbers` generator yields only even numbers.", failure_message)

    def test_even_numbers_different_range(self):
        import user_code
        try:
            result = list(user_code.even_numbers(5, 20))
            expected = [6, 8, 10, 12, 14, 16, 18, 20]
            condition = result == expected
            failure_message = f"Expected `{expected}` for range 5 to 20, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `even_numbers` is not defined."
        _dynamic_test(self, condition, f"The `even_numbers` generator correctly handles the range 5 to 20.", 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 samt skapa flexibel och 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 enstaka eller flera värden, använda None samt utforska generatorer för mer avancerad styrning 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.

Generatorfunktioner

Hur `yield` fungerar

Lösning

Generatorfunktioner

Hur yield fungerar

Lösning

Hur `yield` fungerar