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

Eine **Generatorfunktion** ist eine spezielle Art von Funktion, die das Schlüsselwort `yield` anstelle von `return` verwendet, um eine Sequenz von Werten zu erzeugen. Beim Aufruf einer Generatorfunktion wird ein Iterator-Objekt zurückgegeben, das durchlaufen werden kann, um die Werte nacheinander abzurufen.   
Der Hauptvorteil von Generatorfunktionen liegt in ihrer **Speichereffizienz**. Generatorfunktionen erzeugen Werte bei Bedarf, anstatt die gesamte Sequenz im Voraus zu generieren. Dadurch sind sie besonders speichersparend, insbesondere bei großen Datensätzen oder unendlichen Sequenzen.   

Betrachten Sie ein einfaches Generator-Beispiel. Diese Funktion liefert Logins einzeln aus der angegebenen Liste:

def unique_logins_from_list(login_list):
    # Iterate over each login in the list
    for login in login_list: 
        yield login  # `yield` the current login

# A predefined list of available logins
login_list = ["user1", "user2", "user3", "user4", "user5"]

# Creating a generator instance from the login list
login_generator = unique_logins_from_list(login_list)

# Generate and print 5 logins, one at a time
for _ in range(5):
    # Each call to `next()` gives the next login
    print(next(login_generator)) 


Das Prinzip eines **Generators** besteht darin, dass Werte einzeln mit dem Schlüsselwort `yield` zurückgegeben werden, __ohne sie alle gleichzeitig im Speicher zu halten__. Im Beispiel iteriert der Generator `unique_logins_from_list` durch die __Liste der Logins und gibt jeden einzelnen__ mit `yield` zurück und pausiert an dieser Stelle. Bei jedem Aufruf von `next()` setzt der Generator die Ausführung an der letzten Stelle fort und liefert effizient Werte __ohne die gesamte__ Liste gleichzeitig im Speicher halten zu müssen. Generatoren sind daher besonders nützlich für die Verarbeitung großer Datenmengen oder Datenströme.

import unittest
import user_code  # ÐÐ¼Ð¿Ð¾ÑÑÐ¸ÑÑÐµÐ¼ ÑÐ°Ð¹Ð» Ñ ÑÑÐ½ÐºÑÐ¸ÐµÐ¹ id_generator

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_first_five_ids(self):
        """Checks that the first five generated IDs are correct"""
        id_gen = user_code.id_generator()
        expected_output = ["ID_1", "ID_2", "ID_3", "ID_4", "ID_5"]
        result = [next(id_gen) for _ in range(5)]
        condition = result == expected_output
        failure_message = f"For input (first 5 IDs), expected {expected_output}, but got {result}."
        _dynamic_test(self, condition, "The function correctly generates the first five IDs.", failure_message)
    
    def test_continuous_generation(self):
        """Checks that the generator continues producing IDs sequentially"""
        id_gen = user_code.id_generator()
        for _ in range(10):
            next(id_gen)
        result = next(id_gen)
        expected_output = "ID_11"
        condition = result == expected_output
        failure_message = f"For input (after 10 iterations), expected {expected_output}, but got {result}."
        _dynamic_test(self, condition, "The function correctly continues generating sequential IDs.", failure_message)
    
    def test_generator_type(self):
        """Checks that the function returns a generator object"""
        result = isinstance(user_code.id_generator(), type((lambda: (yield))()))
        expected_output = True
        condition = result == expected_output
        failure_message = "Expected `id_generator` to return a generator object, but it did not."
        _dynamic_test(self, condition, "The function correctly returns a generator object.", failure_message)
    
    def test_id_gen_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'id_gen'),
            "The `id_gen` variable is declared.",
            "Expected `id_gen` to be declared."
        )
      
if __name__ == "__main__":
    unittest.main()

test_main.py

Erwerben Sie ein fundiertes Verständnis dafür, wie Funktionen die Python-Programmierung prägen. Beherrschen Sie das Definieren und Aufrufen von Funktionen, das Arbeiten mit Argumenten, das Verwalten von Rückgabewerten sowie das Erstellen flexibler und effizienter Codes mithilfe von Rekursion und Lambda-Ausdrücken.

Erkunden Sie, was Funktionen sind und warum sie in Python unverzichtbar sind. Lernen Sie, wie man Funktionen erstellt, Argumente definiert, Rückgabewerte verarbeitet und eingebaute Funktionen effektiv nutzt.

Erfahren Sie, wie Positions- und optionale Argumente in Python funktionieren. Entwicklung anpassungsfähiger Funktionen, die verschiedene Eingaben verarbeiten und die Flexibilität Ihres Codes verbessern.

Verstehen, wie mit beliebigen und Schlüsselwortargumenten gearbeitet wird, um variable Eingabegrößen zu verarbeiten. Erfahren, wie diese Techniken Ihre Funktionen dynamischer und organisierter machen.

Erfahren Sie, wie Rückgabewerte die Ausgabe einer Funktion darstellen. Lernen Sie, einzelne oder mehrere Werte zurückzugeben, None zu verwenden und Generatoren für eine fortgeschrittene Steuerung des Datenflusses zu nutzen.

Erschließen Sie fortgeschrittene Funktionskonzepte mit Rekursion und Lambda-Funktionen. Lernen Sie, wie Rekursion wiederkehrende Probleme löst und wie Lambda-Ausdrücke prägnante, einzeilige Funktionen erstellen.

Generatorfunktionen

Lösung