Summary  
This chapter covers generator functions that use `yield` to pause and resume execution for memory-efficient, on-the-fly value production and support iteration via `next()` or `for` loops.

General domain of usage  
data stream processing

En **generatorfunktion** er en særlig type funktion, der bruger nøgleordet `yield` i stedet for `return` til at generere en sekvens af værdier. Når en generatorfunktion kaldes, returnerer den et iteratorobjekt, som kan itereres over for at hente værdier én ad gangen.

Definition

Den primære fordel ved generatorfunktioner er deres **hukommelseseffektivitet**. I stedet for at generere hele sekvensen på forhånd og gemme den i hukommelsen, producerer generatorer værdier **løbende** efter behov.

## Sådan fungerer `yield`

I modsætning til `return`, som afslutter funktionen helt, **pauser** `yield` funktionen og gemmer dens tilstand. Næste gang `next()` kaldes, genoptager generatoren præcis der, hvor den slap:


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 også iterere over en generator ved hjælp af en `for`-løkke – den kalder automatisk `next()` indtil generatoren er udtømt:

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 er udtømt (ingen flere værdier at yield'e), vil et kald til `next()` på den udløse en `StopIteration`-fejl. En `for`-løkke håndterer dette automatisk.

Bemærk

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 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.

Generatorfunktioner

Sådan fungerer `yield`

Løsning

Generatorfunktioner

Sådan fungerer yield

Løsning

Sådan fungerer `yield`