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

Overvej en funktion, der beregner den samlede pris for flere varer, samtidig med at du kan angive et vilkårligt antal priser og valgfrie nøgleord-indstillinger så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 for kombination af vilkårlige argumenter

### Positionelle vilkårlige argumenter (`*args`)

`*args` samler alle ekstra **positionelle argumenter** i en tuple.
I dette eksempel kan funktionen tage et vilkårligt antal varepriser uden at skulle definere dem eksplicit.

**For eksempel**:

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

Her bliver `*prices` til `(500, 250, 100)`.



### Vilkårlige nøgleordsargumenter (`**kwargs`)

`**kwargs` samler alle **navngivne (nøgleords-)argumenter** i en ordbog.
Dette gør det muligt for funktionen at acceptere yderligere navngivne indstillinger såsom `discount` eller `tax`, selvom de ikke var foruddefinerede.

**For eksempel**:

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

Her bliver `**settings` til `{'discount': 10, 'tax': 5}`.



### Kombination af begge

Det er muligt at bruge både `*args` og `**kwargs` i samme funktion for at opnå **maksimal fleksibilitet** — hvilket gør det muligt at håndtere et vilkårligt antal positionelle værdier og enhver kombination af navngivne indstillinger.

Placer altid `*args` før `**kwargs` i funktionssignaturen – hvis rækkefølgen byttes om, vil det resultere i en `SyntaxError`.

Bemærk

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

Opnå en solid forståelse af, hvordan funktioner former Python-programmering. Behersk definition og kald af funktioner, arbejde med argumenter, håndtering af returværdier samt oprettelse af fleksibel og effektiv kode ved brug af rekursion og lambda-udtryk.

Undersøg hvad funktioner er, og hvorfor de er essentielle i Python. Lær at oprette funktioner, definere argumenter, håndtere returværdier og anvende indbyggede funktioner effektivt.

Lær, hvordan positionelle og valgfrie argumenter fungerer i Python. Udarbejd fleksible funktioner, der håndterer forskellige input og øger fleksibiliteten i din kode.

Forstå hvordan man arbejder med vilkårlige og nøgleordsargumenter for at håndtere variable inputstørrelser. Lær hvordan disse teknikker gør dine funktioner mere dynamiske og organiserede.

Opdag, hvordan returværdier repræsenterer en funktions output. Lær at returnere enkelt- eller flere værdier, anvende None samt udforske generatorer for mere avanceret styring af dataflow.

Lås op for avancerede funktionskoncepter med rekursion og lambda-funktioner. Forstå hvordan rekursion løser gentagne problemer, og hvordan lambda-udtryk skaber korte, énliniers funktioner.

Kombination af positionelle og navngivne vilkårlige argumenter

Regler for kombination af vilkårlige argumenter

Positionelle vilkårlige argumenter (`*args`)

Vilkårlige nøgleordsargumenter (`**kwargs`)

Kombination af begge

Løsning