Summary
This chapter covers defining and using Python if statements to conditionally execute an indented code block based on a Boolean expression.

General domain of usage
Fitness tracking applications

L'**istruzione** `if` è uno strumento fondamentale in Python che permette di prendere decisioni all'interno del codice.

Analisi dei componenti principali della sintassi dell'istruzione if:
- **Parola chiave** `if`: questa parola chiave avvia l'istruzione condizionale. Attenzione, è case-sensitive—usare `If` invece di `if` genererà un errore;
- **Condizione**: la condizione è un'espressione che restituisce `True` o `False`. In questo esempio, si verifica se una variabile soddisfa un determinato requisito;
- **Due punti** `:`: i due punti indicano che il blocco indentato successivo appartiene all'istruzione `if`;
- **Blocco di codice indentato**: questo blocco contiene il codice che viene eseguito solo se la condizione è `True`.

#### Esempio 1: Esecuzione standard

steps_taken = 7500
step_goal = 10000

if steps_taken < step_goal:
    print(f"Keep going! You need {step_goal - steps_taken} more steps to reach your goal.")

### Spiegazione

1. La **condizione** `steps_taken < step_goal` verifica se il numero di passi effettuati è inferiore all'obiettivo giornaliero;
2. Se la condizione è **True**, viene eseguito il codice all'interno del blocco `if`;
3. Il messaggio utilizza una **f-string** per includere dinamicamente il numero di passi mancanti, rendendo l'output chiaro e preciso per l'utente.

**f-stringhe** permettono di incorporare espressioni all'interno di una stringa, utilizzando le parentesi graffe `{}`, per una formattazione delle stringhe più semplice e leggibile. Per creare una f-stringa, anteporre la stringa con `f`.
Ad esempio: `f"Your goal is {step_goal} steps"`.

Nota

#### Esempio 2: Quando non viene eseguito nulla

steps_taken = 10000
step_goal = 10000

if steps_taken < step_goal:
    print(f"Keep going! You need {step_goal - steps_taken} more steps to reach your goal.")

In questo caso, la condizione `steps_taken < step_goal` viene valutata come `False` perché `steps_taken` è uguale a `step_goal`. Poiché la condizione non è soddisfatta, il blocco di codice all'interno dell'istruzione `if` non viene eseguito e nulla viene stampato sulla console. Questo dimostra che il codice viene eseguito solo quando la condizione è valutata come `True`.

L'immagine mostra il flusso di un'istruzione if:
- **Verifica della condizione**: il programma valuta se la condizione è `True` o `False`;
- **Esecuzione**: se la condizione è `True`, viene eseguito il blocco di codice indentato. Altrimenti, il programma lo salta.

import unittest
import importlib
import user_code  # Import user's solution
import re

# Helper function for dynamic test naming and assertions
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_calories_burned_is_declared(self):
        """Check if `calories_burned` is declared."""
        _dynamic_test(
            self,
            hasattr(user_code, 'calories_burned'),
            "The `calories_burned` variable is declared.",
            "Expected `calories_burned` to be declared."
        )

    def test_calories_burned_is_integer(self):
        """Check if `calories_burned` is an integer."""
        _dynamic_test(
            self,
            isinstance(user_code.calories_burned, int),
            "The `calories_burned` variable is an integer.",
            "`calories_burned` should be an integer."
        )

    def test_calories_goal_is_declared(self):
        """Check if `calories_goal` is declared."""
        _dynamic_test(
            self,
            hasattr(user_code, 'calories_goal'),
            "The `calories_goal` variable is declared.",
            "Expected `calories_goal` to be declared."
        )

    def test_calories_goal_is_integer(self):
        """Check if `calories_goal` is an integer."""
        _dynamic_test(
            self,
            isinstance(user_code.calories_goal, int),
            "The `calories_goal` variable is an integer.",
            "`calories_goal` should be an integer."
        )

    def test_calories_goal_met_is_declared(self):
        """Check if `calories_goal_met` is declared."""
        _dynamic_test(
            self,
            hasattr(user_code, 'calories_goal_met'),
            "The `calories_goal_met` variable is declared.",
            "Expected `calories_goal_met` to be declared."
        )

    def test_calories_goal_met_is_boolean(self):
        """Check if `calories_goal_met` is a boolean."""
        _dynamic_test(
            self,
            isinstance(user_code.calories_goal_met, bool),
            "The `calories_goal_met` variable is a boolean.",
            "`calories_goal_met` should be a boolean."
        )

    def test_calories_goal_met_condition(self):
        """Check if the correct comparison operator (`>=` or `<=`) is used to update `calories_goal_met`."""
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()  # Read the source code of user_code.py
        
        correct_condition = (
            re.search(r'burned\s*>=', user_code_source) or
            re.search(r'<=\s*calories_burned', user_code_source)
        )

        _dynamic_test(
            self,
            correct_condition is not None,
            "The correct comparison operator (`>=` or `<=`) is used in the condition updating `calories_goal_met`.",
            "Expected `>=` or `<=` to be used in the condition updating `calories_goal_met`, but it was not found."
        )

    def test_if_statement_used(self):
        """Check if an `if` statement is used in the code."""
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()  # Read the source code of user_code.py

        _dynamic_test(
            self,
            re.search(r'if\s+', user_code_source) is not None,
            "An `if` statement is used in the code.",
            "Expected an `if` statement in the code, but none was found."
        )


# Run the tests when executing the script
if __name__ == "__main__":
    unittest.main()

test_main.py

Esplora le sfumature dell'operatore condizionale if-else in Python attraverso spiegazioni chiare ed esempi pratici. Rafforza la tua comprensione con esercizi pratici che consolidano ogni concetto e scopri come utilizzare efficacemente le istruzioni if-elif-else per prendere decisioni più complesse.

Scopri la versatilità dell'operatore condizionale if e la sua capacità di influenzare i risultati di un programma. Approfondisci il mondo degli operatori logici, padroneggia la loro applicazione pratica e impara a stabilire le priorità in modo efficace per scrivere codice chiaro ed efficiente.

Impara a prendere decisioni basate su condizioni, semplificare il codice utilizzando la parola chiave else, migliorando sia l'efficienza che la leggibilità. Scopri l'efficienza delle decisioni in una sola riga con l'operatore ternario!

Scopri la forma più avanzata delle istruzioni condizionali: if-elif-else. Familiarizza con la sua sintassi e apprendi come applicare correttamente questa costruzione per gestire molteplici scenari decisionali nei tuoi programmi.

Sintassi dell'Istruzione If in Python

Esempio 1: Esecuzione standard

Spiegazione

Esempio 2: Quando non viene eseguito nulla

Soluzione