Summary  
This chapter explains how to use `**kwargs` to let a function accept any number of named arguments as a dictionary, and shows how to iterate over those key–value pairs for tasks such as printing or conditional filtering.  

General domain of usage  
Data processing

In der Programmierung gibt es eine spezielle Syntax, um einer Funktion eine beliebige Anzahl benannter Parameter zu übergeben, bekannt als `**kwargs`.

Mit `**kwargs` kann eine Funktion beliebig viele benannte Argumente akzeptieren und diese als Dictionary behandeln.

def example_function(**kwargs):
    for key, value in kwargs.items():
        print(f'{key}: {value}')

# Example function call
example_function(name='John', age=25, city='New York')

In diesem Beispiel empfängt `**kwargs` benannte Argumente und gibt deren Schlüssel und Werte aus.



Die Methode `.items()` wird verwendet, um ein View-Objekt mit Schlüssel-Wert-Paaren aus einem Dictionary in Python zu erhalten. Jedes Element in dieser Ansicht wird als Tupel (key, value) dargestellt.

Hinweis

Mit `**kwargs` können Daten auch anhand einer Bedingung gefiltert werden. Zum Beispiel können nur die Einträge beibehalten werden, deren Wert einen bestimmten Schwellenwert erreicht:

def filter_by_value(threshold, **kwargs):
    result = {}
    for key, value in kwargs.items():
        if value >= threshold:
            result[key] = value
    return result

print(filter_by_value(50, apple=30, banana=60, cherry=80))

Hier wird `result` erstellt, indem jedes Schlüssel-Wert-Paar überprüft und nur diejenigen hinzugefügt werden, die die Bedingung erfüllen.

import unittest

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 TestFilterProductsByBudget(unittest.TestCase):
    def test_products_within_budget(self):
        import user_code
        """Checks that only affordable products are returned."""
        try:
            result = user_code.filter_products_by_budget(100, laptop=1200, smartphone=800, mouse=50, keyboard=90, headphones=150)
            expected_output = "Available products within budget: {'mouse': 50, 'keyboard': 90}"
            condition = result == expected_output
            failure_message = f"For input `(100, laptop=1200, smartphone=800, mouse=50, keyboard=90, headphones=150)`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `filter_products_by_budget` is not defined."
        
        _dynamic_test(self, condition, "The function correctly filters products within budget.", failure_message)
    
    def test_no_affordable_products(self):
        import user_code
        """Checks that the function returns a message when no products are within budget."""
        try:
            result = user_code.filter_products_by_budget(10, laptop=1200, smartphone=800, mouse=50, keyboard=90, headphones=150)
            expected_output = "No products available within the budget."
            condition = result == expected_output
            failure_message = f"For input `(10, laptop=1200, smartphone=800, mouse=50, keyboard=90, headphones=150)`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `filter_products_by_budget` is not defined."
        
        _dynamic_test(self, condition, "The function correctly returns a message when no products are affordable.", failure_message)
    
    def test_all_products_affordable(self):
        import user_code
        """Checks that all products are returned if all are within budget."""
        try:
            result = user_code.filter_products_by_budget(500, mouse=50, keyboard=90, headphones=150)
            expected_output = "Available products within budget: {'mouse': 50, 'keyboard': 90, 'headphones': 150}"
            condition = result == expected_output
            failure_message = f"For input `(500, mouse=50, keyboard=90, headphones=150)`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `filter_products_by_budget` is not defined."
        
        _dynamic_test(self, condition, "The function correctly returns all products when all are affordable.", failure_message)

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, den Umgang mit Argumenten, das Verarbeiten von Rückgabewerten sowie das Erstellen flexibler und effizienter Codestrukturen mithilfe von Rekursion und Lambda-Ausdrücken.

Erkunden Sie, was Funktionen sind und warum sie in Python unverzichtbar sind. Erfahren Sie, wie Funktionen erstellt werden, wie Argumente definiert werden, wie Rückgabewerte behandelt werden und wie eingebaute Funktionen effektiv genutzt werden.

Erfahren Sie, wie Positions- und optionale Argumente in Python funktionieren. Entwickeln Sie anpassungsfähige Funktionen, die verschiedene Eingaben verarbeiten und die Flexibilität Ihres Codes erhöhen.

Verstehen, wie mit beliebigen und Schlüsselwortargumenten gearbeitet wird, um variable Eingabegrößen zu verarbeiten.
Erlernen, wie diese Techniken Funktionen dynamischer und strukturierter gestalten.

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. Erfahren Sie, wie Rekursion wiederkehrende Probleme löst und wie Lambda-Ausdrücke prägnante, einzeilige Funktionen erstellen.

Beliebige Schlüsselwortargumente

Lösung