Summary  
This chapter demonstrates how to use the return statement in a function to output different results based on conditional logic and to immediately terminate function execution once a return is encountered.  

General domain of usage  
Reminder and notification systems (e.g., task scheduling)

Creazione di una funzione `walk_the_dog` che prende come parametri il nome del cane `dog_name` e l'orario della passeggiata `walk_time`. La funzione deve **restituire** un messaggio che indica se è il momento di portare a spasso il cane.

def walk_the_dog(dog_name, walk_time):
    # Check if the walk time is between 6 and 18 hours
    if 6 <= walk_time <= 18:
        return f'Time to walk {dog_name}!'
    else:
        return f'Wait until 6 PM to walk {dog_name}!'

# Function calls with different parameters
message1 = walk_the_dog('Bella', 14)
message2 = walk_the_dog('Charlie', 20)

# Display the results
print(message1)
print(message2)

- La condizione `if 6 <= walk_time <= 18:` verifica se l'orario della passeggiata (`walk_time`) è compreso tra le 6 e le 18 (inclusi);
- Se questa condizione è **vera** (cioè l'orario è tra le 6 e le 18), viene eseguito il primo blocco di codice:
```python
return f'Time to walk {dog_name}!'
```
Questa istruzione `return` restituisce una stringa che indica che è il momento di portare a spasso il cane di nome `dog_name`;
- Se la condizione **non è vera** (cioè l'orario non è tra le 6 e le 18), viene eseguito il secondo blocco di codice:
```python
return f'Wait until 6 PM to walk {dog_name}!'
```
In questo caso, l'istruzione `return` restituisce un messaggio diverso che indica che è necessario aspettare fino alle 18 per portare a spasso il cane di nome `dog_name`.

Il `return` in questo caso specifica quale risultato viene restituito dalla funzione in base alla condizione. La funzione restituisce una stringa, che viene poi stampata utilizzando `print(message1)` e `print(message2)`.

È importante sottolineare che l'istruzione `return` non solo specifica il risultato da restituire, ma termina immediatamente l'esecuzione della funzione. Una volta incontrata una `return`, la funzione si interrompe e qualsiasi codice successivo all'interno della funzione non viene eseguito.

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 TestUserCode(unittest.TestCase):

    def test_describe_dog_with_valid_data(self):
        """Checks that `describe_dog` returns the correct description for valid input"""
        try:
            import user_code
            description = user_code.describe_dog("Buddy", "Labrador", 3)
            expected_output = "Buddy is a 3-year-old Labrador. An old dog with much wisdom!"
            
            input_values = ("Buddy", "Labrador", 3)
            condition = description == expected_output
            failure_message = f"For input `{input_values}`, expected `{expected_output}`, but got `{description}`."
        except AttributeError:
            condition = False
            failure_message = "The function `describe_dog` is not defined."
        
        _dynamic_test(self, condition, "The `describe_dog` function works correctly with valid data.", failure_message)

    def test_describe_dog_with_newborn(self):
        """Checks that `describe_dog` correctly handles the case of a newborn dog"""
        try:
            import user_code
            description = user_code.describe_dog("Rex", "German Shepherd", 0)
            expected_output = "Rex is a newborn German Shepherd. A bundle of joy!"
            
            input_values = ("Rex", "German Shepherd", 0)
            condition = description == expected_output
            failure_message = f"For input `{input_values}`, expected `{expected_output}`, but got `{description}`."
        except AttributeError:
            condition = False
            failure_message = "The function `describe_dog` is not defined."
        
        _dynamic_test(self, condition, "The `describe_dog` function correctly handles a newborn dog.", failure_message)

    def test_describe_dog_with_age_one(self):
        """Checks that `describe_dog` correctly handles the case of a 1-year-old dog"""
        try:
            import user_code
            description = user_code.describe_dog("Buddy", "Labrador", 1)
            expected_output = "Buddy is a 1-year-old Labrador. A great companion!"
            
            input_values = ("Buddy", "Labrador", 1)
            condition = description == expected_output
            failure_message = f"For input `{input_values}`, expected `{expected_output}`, but got `{description}`."
        except AttributeError:
            condition = False
            failure_message = "The function `describe_dog` is not defined."
        
        _dynamic_test(self, condition, "The `describe_dog` function correctly handles a 1-year-old dog.", failure_message)

    def test_describe_dog_with_negative_age(self):
        """Checks that `describe_dog` handles negative age gracefully"""
        try:
            import user_code
            description = user_code.describe_dog("Rex", "German Shepherd", -1)
            expected_output = "Invalid age for Rex. Age cannot be negative."
            
            input_values = ("Rex", "German Shepherd", -1)
            condition = description == expected_output
            failure_message = f"For input `{input_values}`, expected `{expected_output}`, but got `{description}`."
        except AttributeError:
            condition = False
            failure_message = "The function `describe_dog` is not defined."
        
        _dynamic_test(self, condition, "The `describe_dog` function handles negative age correctly.", failure_message)

if __name__ == '__main__':
    unittest.main()

test_main.py

Acquisire una solida comprensione di come le funzioni influenzano la programmazione in Python. Padroneggiare 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 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.
Restituzione di valori singoli o multipli.
Utilizzo di None come valore di ritorno.
Esplorazione dei generatori per un controllo avanzato del flusso dei dati.

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

Valore di Ritorno

Soluzione