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

Considera una funzione che calcola il costo totale di più articoli permettendo di passare un numero qualsiasi di prezzi e impostazioni opzionali tramite parole chiave come sconti o tasse.

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)

## Regole per combinare argomenti arbitrari

### Argomenti arbitrari posizionali (`*args`)

`*args` raccoglie tutti gli **argomenti posizionali** extra in una tupla.
In questo esempio, la funzione può accettare un numero qualsiasi di prezzi degli articoli senza doverli definire esplicitamente.

**Ad esempio**:

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

Qui, `*prices` diventa `(500, 250, 100)`.



### Argomenti Arbitrari per Parola Chiave (`**kwargs`)

`**kwargs` raccoglie tutti gli **argomenti nominati (per parola chiave)** in un dizionario.
Questo permette alla funzione di accettare impostazioni aggiuntive nominate come `discount` o `tax`, anche se non erano state predefinite.

**Ad esempio**:

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

Qui, `**settings` diventa `{'discount': 10, 'tax': 5}`.



### Combinazione di Entrambi

È possibile utilizzare sia `*args` che `**kwargs` nella stessa funzione per ottenere la **massima flessibilità** — consentendo di gestire qualsiasi numero di valori posizionali e qualsiasi combinazione di impostazioni nominate.

Inserire sempre `*args` prima di `**kwargs` nella firma della funzione – invertendo l'ordine si otterrà un `SyntaxError`.

Nota

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

Acquisisci una solida comprensione di come le funzioni influenzano la programmazione in Python. Apprendi la definizione e la chiamata di funzioni, la gestione degli argomenti, il trattamento dei valori di ritorno e la creazione di codice flessibile ed efficiente utilizzando ricorsione ed espressioni lambda.

Esplora cosa sono le funzioni e perché sono essenziali in Python. Scopri come creare funzioni, definire argomenti, gestire i valori di ritorno e utilizzare efficacemente le funzioni integrate.

Scopri come funzionano gli argomenti posizionali e opzionali in Python. Crea funzioni adattabili che gestiscono diversi input e migliorano la flessibilità del codice.

Comprendere come lavorare con argomenti arbitrari e argomenti keyword per gestire dimensioni di input variabili. Apprendere come queste tecniche rendano le funzioni più dinamiche e organizzate.

Scopri come i valori di ritorno rappresentano l'output di una funzione. Comprendi come restituire valori singoli o multipli, utilizzare None ed esplorare i generatori per un controllo più avanzato del flusso dei dati.

Scopri concetti avanzati sulle funzioni con ricorsione e funzioni lambda. Comprendi come la ricorsione risolve problemi ripetitivi e come le espressioni lambda permettono di creare funzioni concise in una sola riga.

Combinazione di argomenti arbitrari posizionali e keyword

Regole per combinare argomenti arbitrari

Argomenti arbitrari posizionali (`*args`)

Argomenti Arbitrari per Parola Chiave (`**kwargs`)

Combinazione di Entrambi

Soluzione