Summary  
This chapter covers the use of anonymous one-line functions (lambda) to define concise operations with single or multiple arguments, inline conditional logic, and integration with higher-order functions like map, filter, and max.

General domain of usage  
Data transformation and filtering

Le funzioni lambda sono funzioni anonime, cioè non hanno un nome. Vengono create utilizzando la parola chiave `lambda` e sono spesso utilizzate per definire funzioni brevi dove è possibile specificare una funzione al momento.

La sintassi di base di una funzione lambda è la seguente:

```python
lambda arguments: expression
```

- `lambda`: la parola chiave che indica l'inizio della definizione di una funzione lambda;
- `arguments`: l'elenco degli argomenti che la funzione accetta;
- `expression`: l'espressione eseguita quando la funzione viene chiamata. Il risultato dell'espressione viene restituito come valore della funzione.

La caratteristica principale delle funzioni lambda è la loro sintassi concisa. Sono utili quando è necessario definire una funzione semplice senza scrivere molto codice.

## Argomenti singoli e multipli

Una funzione lambda può accettare uno o più argomenti:

# Single argument
square = lambda x: x**2
print(square(5))  # 25

# Multiple arguments
add = lambda x, y: x + y
print(add(3, 5))  # 8

## Logica condizionale nelle funzioni lambda

È possibile utilizzare un'espressione ternaria per aggiungere logica condizionale all'interno di una lambda:

is_even = lambda x: "even" if x % 2 == 0 else "odd"
print(is_even(4))  # "even"
print(is_even(7))  # "odd"

## Utilizzo di lambda con funzioni integrate

Un caso d'uso comune è la combinazione delle funzioni lambda con funzioni integrate come `map()` e `filter()`:


prices = [100, 200, 300]

# Apply 10% discount to each price
discounted = list(map(lambda price: price * 0.9, prices))
print(discounted)  # [90.0, 180.0, 270.0]

# Keep only prices above 150
expensive = list(filter(lambda price: price > 150, prices))
print(expensive)  # [200, 300]

È possibile utilizzare anche `max()` all'interno di una lambda per gestire i casi limite direttamente nell'espressione:

safe_value = lambda x: max(x, 0)  # Returns 0 if x is negative
print(safe_value(-5))  # 0
print(safe_value(10))  # 10

Le funzioni lambda sono più adatte per logiche brevi e composte da una sola espressione. Se la funzione richiede più righe o una logica complessa, è preferibile utilizzare una funzione `def` tradizionale.

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 TestApplyTax(unittest.TestCase):
    def test_apply_tax_single_value(self):
        """Checks tax deduction on a single price"""
        import user_code
        try:
            result = user_code.apply_tax(200)
            expected_output = 174.0
            condition = result == expected_output
            failure_message = f"For input `200`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `apply_tax` is not defined."
        _dynamic_test(self, condition, "The function correctly calculates tax for a single price.", failure_message)
    
    def test_apply_tax_zero(self):
        """Checks that tax deduction on zero returns zero"""
        import user_code
        try:
            result = user_code.apply_tax(0)
            expected_output = 0.0
            condition = result == expected_output
            failure_message = f"For input `0`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `apply_tax` is not defined."
        _dynamic_test(self, condition, "The function correctly handles zero input.", failure_message)

    def test_negative_price(self):
        """Checks that negative prices are handled correctly and return 0"""
        import user_code
        result = user_code.apply_tax(-123)
        expected_output = 0
        condition = result == expected_output
        failure_message = f"For input `-123`, expected `{expected_output}`, but got `{result}`."
        _dynamic_test(self, condition, "The function correctly handles negative values.", failure_message)
    
    def test_apply_tax_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'apply_tax'),
            "The `apply_tax` variable is declared.",
            "Expected `apply_tax` to be declared."
        )
if __name__ == '__main__':
    unittest.main()

test_main.py

Acquisire una solida comprensione di come le funzioni modellano la programmazione in Python. Padroneggiare la definizione e la chiamata delle 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. Sviluppo di funzioni adattabili che gestiscono diversi input e migliorano la flessibilità del codice.

Comprendere come lavorare con argomenti arbitrari e 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. Impara a 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 la ricorsione e le funzioni lambda. Impara come la ricorsione risolve problemi ripetitivi e come le espressioni lambda permettono di creare funzioni concise in una sola riga.

Funzioni Lambda

Argomenti singoli e multipli

Logica condizionale nelle funzioni lambda

Utilizzo di lambda con funzioni integrate

Soluzione