Summary  
The chapter explains how to define functions using both *args and **kwargs to accept an arbitrary number of positional and keyword parameters, and safely retrieve optional values from kwargs using the dictionary get method.

General domain of usage  
Billing and cost calculation

Tänk dig en funktion som beräknar den totala kostnaden för flera varor och låter dig ange valfritt antal priser samt valfria nyckelordsinställningar som rabatt eller moms.

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)

## Regler för att kombinera godtyckliga argument

### Positionella godtyckliga argument (`*args`)

`*args` samlar alla extra **positionella argument** i en tuple.
I det här exemplet kan funktionen ta emot valfritt antal varupriser utan att de behöver definieras i förväg.

**Till exempel**:

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

Här blir `*prices` till `(500, 250, 100)`.



### Godtyckliga nyckelordsargument (`**kwargs`)

`**kwargs` samlar alla **namngivna (nyckelords-)argument** i en ordbok.
Detta gör att funktionen kan ta emot ytterligare namngivna inställningar som `discount` eller `tax`, även om de inte var fördefinierade.

**Till exempel**:

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

Här blir `**settings` till `{'discount': 10, 'tax': 5}`.



### Kombinera båda

Du kan använda både `*args` och `**kwargs` i samma funktion för att uppnå **maximal flexibilitet** – vilket gör att du kan hantera valfritt antal positionella värden och valfri kombination av namngivna inställningar.

Placera alltid `*args` före `**kwargs` i funktionssignaturen – om du vänder på ordningen uppstår ett `SyntaxError`.

Observera

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

Få en gedigen förståelse för hur funktioner formar Python-programmering. Bemästra att definiera och anropa funktioner, arbeta med argument, hantera returvärden och skapa flexibel, effektiv kod med rekursion och lambda-uttryck.

Utforska vad funktioner är och varför de är viktiga i Python. Lär dig hur man skapar funktioner, definierar argument, hanterar returvärden och använder inbyggda funktioner effektivt.

Lär dig hur positionella och valfria argument fungerar i Python. Skapa anpassningsbara funktioner som hanterar olika indata och förbättrar flexibiliteten i din kod.

Förstå hur man arbetar med godtyckliga och nyckelordsargument för att hantera variabla inmatningsstorlekar. Lär dig hur dessa tekniker gör dina funktioner mer dynamiska och organiserade.

Upptäck hur returvärden representerar en funktions utdata. Lär dig att returnera enskilda eller flera värden, använda None och utforska generatorer för mer avancerad kontroll av dataflöde.

Lås upp avancerade funktionskoncept med rekursion och lambda-funktioner. Lär dig hur rekursion löser repetitiva problem och hur lambda-uttryck skapar koncisa, enradiga funktioner.

Kombination av positionella och nyckelordsbaserade godtyckliga argument

Regler för att kombinera godtyckliga argument

Positionella godtyckliga argument (`*args`)

Godtyckliga nyckelordsargument (`**kwargs`)

Kombinera båda

Lösning