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 de programmeertaal bestaat er een speciale syntaxis om een willekeurig aantal benoemde parameters aan een functie door te geven, bekend als `**kwargs`.

Met `**kwargs` kan een functie een willekeurig aantal benoemde argumenten accepteren en deze behandelen als een dictionary.

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 dit voorbeeld ontvangt `**kwargs` benoemde argumenten en worden hun sleutels en waarden afgedrukt.



De methode `.items()` wordt gebruikt om een lijst van sleutel-waardeparen uit een dictionary in Python te verkrijgen. Elk element in deze lijst wordt weergegeven als een tuple (key, value).

Opmerking

Je kunt `**kwargs` ook gebruiken om gegevens te filteren op basis van een voorwaarde. Bijvoorbeeld, alleen de items behouden waarvan de waarde een bepaalde drempel overschrijdt:


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 wordt `result` opgebouwd door elk sleutel-waarde paar te controleren en alleen die toe te voegen die aan de voorwaarde voldoen.

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

Verkrijg een grondig begrip van hoe functies de Python-programmering vormgeven. Beheers het definiëren en aanroepen van functies, het werken met argumenten, het omgaan met returnwaarden en het creëren van flexibele, efficiënte code met behulp van recursie en lambda-expressies.

Ontdek wat functies zijn en waarom ze essentieel zijn in Python. Leer hoe functies worden gemaakt, argumenten worden gedefinieerd, returnwaarden worden afgehandeld en ingebouwde functies effectief worden gebruikt.

Leer hoe positionele en optionele argumenten werken in Python. Ontwikkel aanpasbare functies die verschillende invoer verwerken en de flexibiliteit van uw code verbeteren.

Inzicht in het werken met willekeurige en sleutelwoordargumenten om variabele invoergroottes te verwerken. Begrijpen hoe deze technieken functies dynamischer en georganiseerder maken.

Ontdek hoe returnwaarden de output van een functie vertegenwoordigen. Leer hoe u één of meerdere waarden retourneert, gebruikmaakt van None en generatoren inzet voor geavanceerdere beheersing van gegevensstromen.

Ontgrendel geavanceerde functiethema's met recursie en lambda-functies. Begrijp hoe recursie herhalende problemen oplost en hoe lambda-expressies beknopte, eenregelige functies creëren.

Willekeurige Sleutelwoordargumenten

Oplossing