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

La **sentencia** `if` es una herramienta fundamental en Python que permite tomar decisiones en el código.

Desglose de los componentes clave de la sintaxis de la sentencia if:
- **Palabra clave** `if`: esta palabra clave inicia la sentencia condicional. Recuerda que distingue entre mayúsculas y minúsculas—usar `If` en lugar de `if` provocará un error;
- **Condición**: la condición es una expresión que se evalúa como `True` o `False`. En este ejemplo, se verifica si una variable cumple con un requisito determinado;
- **Dos puntos** `:`: los dos puntos indican que el bloque indentado siguiente pertenece a la sentencia `if`;
- **Bloque de código indentado**: este bloque contiene el código que se ejecuta solo si la condición es `True`.

#### Ejemplo 1: Ejecución estándar

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.")

### Explicación

1. La **condición** `steps_taken < step_goal` verifica si el número de pasos dados es menor que el objetivo diario;
2. Si la condición es **True**, se ejecuta el código dentro del bloque `if`;
3. El mensaje utiliza un **f-string** para incluir dinámicamente el número de pasos restantes, haciendo que la salida sea clara y precisa para el usuario.

**f-strings** permiten incrustar expresiones dentro de una cadena, utilizando llaves `{}`, para un formato de cadena más sencillo y legible. Para crear una f-string, antepón la cadena con `f`.
Por ejemplo: `f"Your goal is {step_goal} steps"`.

Nota

#### Ejemplo 2: Cuando no se ejecuta nada

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.")

En este caso, la condición `steps_taken < step_goal` se evalúa como `False` porque `steps_taken` es igual a `step_goal`. Dado que la condición no se cumple, el bloque de código dentro de la instrucción `if` no se ejecuta y no se imprime nada en la consola. Esto demuestra que el código solo se ejecuta cuando la condición se evalúa como `True`.

La imagen muestra el flujo de una instrucción if:
- **Verificación de la condición**: el programa evalúa si la condición es `True` o `False`;
- **Ejecución**: si la condición es `True`, se ejecuta el bloque de código indentado. De lo contrario, el programa lo omite.

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

Explora los matices del operador condicional if-else en Python a través de explicaciones claras y ejemplos prácticos. Fortalece tu comprensión con tareas prácticas que refuerzan cada concepto y descubre cómo utilizar las sentencias if-elif-else de manera efectiva para una toma de decisiones más compleja.

Descubre la versatilidad del operador condicional if y su capacidad para influir en los resultados de un programa. Profundiza en el mundo de los operadores lógicos, domina su aplicación práctica y aprende a priorizarlos de manera efectiva para escribir código claro y eficiente.

Aprende a tomar decisiones basadas en condiciones, simplificar el código utilizando la palabra clave else, mejorando tanto la eficiencia como la legibilidad. Descubre la eficiencia de las decisiones en una sola línea con el operador ternario.

Descubre la forma más avanzada de las sentencias condicionales: if-elif-else. Familiarízate con su sintaxis y aprende a aplicar esta construcción correctamente para manejar múltiples escenarios de toma de decisiones en tus programas.

Sintaxis de la Sentencia If en Python

Ejemplo 1: Ejecución estándar

Explicación

Ejemplo 2: Cuando no se ejecuta nada

Solución