Summary  
This chapter shows how to define a function that uses both positional arbitrary arguments (*args) and keyword arbitrary arguments (**kwargs) to flexibly accept any number of inputs and optional settings, then process and printing the results.  

General domain of usage  
Billing and invoicing

Consider a function that calculates the total cost of multiple items while allowing you to pass any number of prices and optional keyword settings such as discounts or taxes.

def calculate_total_cost(*prices, **settings):
    subtotal = sum(prices)
    discount = settings.get("discount", 0)
    tax = settings.get("tax", 0)
    
    discount_amount = subtotal * (discount / 100)
    taxed_amount = (subtotal - discount_amount) * (1 + tax / 100)
    
    print(f"Subtotal: ${subtotal:.2f}")
    
    if discount > 0:
        print(f"Discount: {discount}% (-${discount_amount:.2f})")
    else:
        print("No discount applied.")
    
    if tax > 0:
        print(f"Tax: {tax}% (+${taxed_amount - (subtotal - discount_amount):.2f})")
    
    print(f"Final total: ${taxed_amount:.2f}")
    print()

# Examples of using the function
calculate_total_cost(1000, 250, 50)
calculate_total_cost(1200, 800, discount=10)
calculate_total_cost(500, 750, 250, discount=5, tax=8)

## Rules for Combining Arbitrary Arguments

### Positional Arbitrary Arguments (`*args`)

`*args` collects all extra **positional arguments** into a tuple.
In this example, the function can take any number of item prices without needing to define them explicitly.

**For example**:

```python
calculate_total_cost(500, 250, 100)
```

Here, `*prices` becomes `(500, 250, 100)`.



### Keyword Arbitrary Arguments (`**kwargs`)

`**kwargs` collects all **named (keyword) arguments** into a dictionary.
This allows the function to accept additional named settings such as `discount` or `tax`, even if they weren’t predefined.

**For example**:

```python
calculate_total_cost(1000, 500, discount=10, tax=5)
```

Here, `**settings` becomes `{'discount': 10, 'tax': 5}`.



### Combining Both

You can use both `*args` and `**kwargs` in the same function to achieve **maximum flexibility** — letting you handle any number of positional values and any combination of named settings.

Always place `*args` before `**kwargs` in the function signature – reversing the order will result in a `SyntaxError`.

Note

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 TestGenerateReport(unittest.TestCase):
    def test_pass_with_label(self):
        import user_code
        try:
            result = user_code.generate_report(80, 90, 70, label="Math", passing_score=75)
            expected = "Math | Average: 80.00 | Status: Pass"
            condition = result == expected
            failure_message = f"Expected `{expected}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `generate_report` is not defined."
        _dynamic_test(self, condition, "The function correctly returns a passing report with a label.", failure_message)

    def test_fail_without_label(self):
        import user_code
        try:
            result = user_code.generate_report(50, 60, 40, passing_score=65)
            expected = "Report | Average: 50.00 | Status: Fail"
            condition = result == expected
            failure_message = f"Expected `{expected}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `generate_report` is not defined."
        _dynamic_test(self, condition, "The function correctly returns a failing report without a label.", failure_message)

    def test_no_passing_score(self):
        import user_code
        try:
            result = user_code.generate_report(95, 88, 92, label="Science")
            expected = "Science | Average: 91.67"
            condition = result == expected
            failure_message = f"Expected `{expected}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `generate_report` is not defined."
        _dynamic_test(self, condition, "The function correctly omits status when no passing score is provided.", failure_message)

if __name__ == '__main__':
    unittest.main()

test_code.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.

Learn how positional and optional arguments work in Python. Build adaptable functions that handle different inputs and improve flexibility in your code.

Understand how to work with arbitrary and keyword arguments to handle variable input sizes. Learn how these techniques make your functions more dynamic and organized.

Discover how return values represent a function's output. Learn to return single or multiple values, use None, and explore generators for more advanced data flow control.

Unlock advanced function concepts with recursion and lambda functions. Learn how recursion solves repetitive problems and how lambda expressions create concise, one-line functions.

Combination of Positional and Keyword Arbitrary Arguments

Rules for Combining Arbitrary Arguments

Positional Arbitrary Arguments (`*args`)

Keyword Arbitrary Arguments (`**kwargs`)

Combining Both

Solution