Summary  
This chapter covers defining functions with arbitrary positional arguments (using *args) to collect any number of inputs into a tuple for flexible handling, including iterating over values and managing empty cases with truthiness or len() checks.  

General domain of usage  
Mathematical computations

**Positionsargumente** und **optionale Argumente** sind bereits bekannt. Wenn eine Funktion jedoch viele Eingaben erhalten kann oder diese im Voraus nicht bekannt sind, können **beliebige Positionsargumente** verwendet werden. Sie ermöglichen es einer Funktion, eine beliebige Anzahl von Werten zu akzeptieren.

Jedes Argument kann eine beliebige Datenstruktur sein (Liste, Dict, usw.). Beliebige Argumente ermöglichen es, so viele solcher Objekte wie nötig zu übergeben.

Hinweis

Um beliebige Positionsargumente zu definieren, wird ein Sternchen `*` vor den Parameternamen gesetzt. Beispiel:

# Define function with arbitrary positional arguments named values
def calculate_sum(*values):
	return sum(values)

# Test the function using different number of arguments
print(calculate_sum(1, 2, 3))
print(calculate_sum(1, 2, 3, 4))
print(calculate_sum(1, 2, 3, 4, 5))

Hier sammelt `*values` alle übergebenen Positionsargumente in einem Tupel. Innerhalb der Funktion wird der Variablenname **ohne** `*` verwendet. Das Ergebnis ist unabhängig von der Anzahl der übergebenen Argumente korrekt.

Obwohl jeder Name funktioniert, ist die gebräuchliche und lesbare Form `*args`.

def example_function(*args):
    print(type(args))
    print(args)
    for arg in args:
        print(arg)

print("Call without arguments:")
example_function()

print("\nCall with one argument:")
example_function(1)

print("\nCall with multiple arguments:")
example_function(1, 2, 3, 'hello', [4, 5, 6])

Wie gezeigt:

* Keine Argumente → `args` ist `()`;
* Ein Argument → `(1,)`;
* Mehrere Argumente → alle Werte erscheinen in einem Tupel, z. B. `(1, 2, 3, 'hello', [4, 5, 6])`.

`*args` verhält sich wie jedes andere Tupel und bietet volle Flexibilität beim Umgang mit vielen Eingaben.


Da `*args` einfach ein Tupel ist, kann jede beliebige Logik auf dessen Werte angewendet werden – einschließlich Bedingungen. Beispielsweise kann nach der Summierung aller Preise das Gesamtergebnis überprüft und je nach Ergebnis unterschiedliche Regeln angewendet werden.

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 TestCalculateTotal(unittest.TestCase):
    def test_no_items_in_cart(self):
        """Checks that an empty cart returns the correct message"""
        import user_code
        try:
            result = user_code.calculate_total()
            expected_output = "Your cart is empty."
            condition = result == expected_output
            failure_message = f"For input `()`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `calculate_total` is not defined."
        _dynamic_test(self, condition, "The function correctly handles an empty cart.", failure_message)
    
    def test_no_discount(self):
        """Checks that no discount is applied for a total below $100"""
        import user_code
        try:
            result = user_code.calculate_total(20, 20, 50)
            expected_output = "Final total: $90.00"
            condition = result == expected_output
            failure_message = f"For input `(20, 20, 50)`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `calculate_total` is not defined."
        _dynamic_test(self, condition, "The function correctly calculates the total without a discount (total below $100).", failure_message)
    
    def test_ten_percent_discount(self):
        """Checks that a 10% discount is applied for a total between 100 and 200"""
        import user_code
        try:
            result = user_code.calculate_total(100, 20, 30)
            expected_output = "Final total: $135.00"
            condition = result == expected_output
            failure_message = f"For input `(100, 20, 30)`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `calculate_total` is not defined."
        _dynamic_test(self, condition, "The function correctly applies a 10% discount.", failure_message)
    
    def test_twenty_percent_discount(self):
        """Checks that a 20% discount is applied for a total greater than 200"""
        import user_code
        try:
            result = user_code.calculate_total(150, 100)
            expected_output = "Final total: $200.00"
            condition = result == expected_output
            failure_message = f"For input `(150, 100)`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `calculate_total` is not defined."
        _dynamic_test(self, condition, "The function correctly applies a 20% discount.", 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, das Arbeiten mit Argumenten, das Verarbeiten von Rückgabewerten sowie das Erstellen flexibler und effizienter Codes mithilfe von Rekursion und Lambda-Ausdrücken.

Erkunden, was Funktionen sind und warum sie in Python unverzichtbar sind. Lernen, 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 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.

Entdecken Sie, wie Rückgabewerte die Ausgabe einer Funktion repräsentieren. 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.

Beliebige Positionsargumente

Lösung