Summary  
This chapter explains how to define functions that accept an arbitrary number of positional arguments using `*args`, collecting them into a tuple for flexible processing inside the function.  

General domain of usage  
Aggregating numeric inputs

You already know **positional** and **optional** arguments. But when a function may receive many inputs or you don't know them in advance, you can use **arbitrary positional arguments**. They allow a function to accept any number of values.

Each argument can be any data structure (list, dict, etc.). Arbitrary arguments let you pass as many such objects as needed.

Note

To define arbitrary positional arguments, place an asterisk `*` before the parameter name. Example:

# 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))

Here, `*values` collects all passed positional arguments into a tuple. Inside the function, you use the variable name **without** `*`. The result is correct regardless of how many arguments are provided.

Although any name works, the common and readable form is `*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])

As shown:

* No arguments → `args` is `()`;
* One argument → `(1,)`;
* Multiple arguments → all values appear in a tuple, e.g., `(1, 2, 3, 'hello', [4, 5, 6])`.

`*args` behaves like any other tuple, giving you full flexibility when handling many inputs.


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 <= 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 total without discount.", 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

Gain a solid understanding of how functions shape Python programming. Master defining and calling functions, working with arguments, handling return values, and creating flexible, efficient code using recursion and lambda expressions.

Explore what functions are and why they're essential in Python. Learn how to create functions, define arguments, handle return values, and use built-in functions effectively.

Arbitrary Positional Arguments in Python

解答