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

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

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 artikelpriser utan att de behöver definieras uttryckligen.

**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 – omvänd ordning leder till ett `SyntaxError`.

Notera

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. Behärska att definiera och anropa funktioner, arbeta med argument, hantera returvärden samt skapa flexibel och 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.

Utforska hur returvärden representerar en funktions utdata. Lär dig att returnera enstaka eller flera värden, använda None samt undersöka generatorer för mer avancerad styrning av dataflöde.

Lås upp avancerade funktionskoncept med rekursion och lambda-funktioner. Utforska 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