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 **generatorfunksjon** er en spesiell type funksjon som bruker nøkkelordet `yield` i stedet for `return` for å generere en sekvens av verdier. Når en generatorfunksjon kalles, returnerer den et iteratorobjekt, som kan itereres over for å hente ut verdier én om gangen.

Definisjon

Hovedfordelen med generatorfunksjoner er deres **minneeffektivitet**. I stedet for å generere hele sekvensen på forhånd og lagre den i minnet, produserer generatorer verdier **løpende** etter hvert som de trengs.

## Hvordan `yield` fungerer

I motsetning til `return`, som avslutter funksjonen helt, **pauser** `yield` funksjonen og lagrer dens tilstand. Neste gang `next()` kalles, fortsetter generatoren nøyaktig der den slapp:


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 med en `for`-løkke – den kaller automatisk `next()` til generatoren er tom:

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 tom (ingen flere verdier å gi med yield), vil et kall til `next()` på den utløse en `StopIteration`-feil. En `for`-løkke håndterer dette automatisk.

Merk

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 av hvordan funksjoner former Python-programmering. Bli ekspert på å definere og kalle funksjoner, arbeide med argumenter, håndtere returverdier og lage fleksibel, effektiv kode ved bruk av rekursjon og lambda-uttrykk.

Utforsk hva funksjoner er og hvorfor de er essensielle i Python. Lær hvordan du oppretter funksjoner, definerer argumenter, håndterer returverdier og bruker innebygde funksjoner effektivt.

Lær hvordan posisjonelle og valgfrie argumenter fungerer i Python. Bygg tilpasningsdyktige funksjoner som håndterer ulike input og gir økt fleksibilitet i koden din.

Forstå hvordan du arbeider med vilkårlige og navngitte argumenter for å håndtere variable mengder input. Lær hvordan disse teknikkene gjør funksjonene dine mer dynamiske og organiserte.

Oppdag hvordan returverdier representerer en funksjons output. Lær å returnere én eller flere verdier, bruke None, og utforsk generatorer for mer avansert kontroll over datastrøm.

Lås opp avanserte funksjonskonsepter med rekursjon og lambda-funksjoner. Lær hvordan rekursjon løser repeterende problemer og hvordan lambda-uttrykk skaper konsise, énlinjers funksjoner.

Generator-Funksjoner

Hvordan `yield` fungerer

Løsning

Generator-Funksjoner

Hvordan yield fungerer

Løsning

Hvordan `yield` fungerer