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

A **instrução** `if` é uma ferramenta fundamental em Python que permite tomar decisões no código.

Vamos analisar os principais componentes da sintaxe da instrução if:
- **Palavra-chave** `if`: esta palavra-chave inicia a instrução condicional. Lembre-se, ela diferencia maiúsculas de minúsculas—usar `If` em vez de `if` causará um erro;
- **Condição**: a condição é uma expressão que resulta em `True` ou `False`. Neste exemplo, verificamos se uma variável atende a um determinado requisito;
- **Dois-pontos** `:`: os dois-pontos indicam que o bloco indentado a seguir pertence à instrução `if`;
- **Bloco de código indentado**: este bloco contém o código que será executado apenas se a condição for `True`.

#### Exemplo 1: Execução padrão

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

### Explicação

1. A **condição** `steps_taken < step_goal` verifica se o número de passos dados é menor que a meta diária;
2. Se a condição for **True**, o código dentro do bloco `if` é executado;
3. A mensagem utiliza um **f-string** para incluir dinamicamente o número de passos restantes, tornando a saída clara e precisa para o usuário.

**f-strings** permitem incorporar expressões dentro de uma string, usando chaves `{}`, para facilitar e tornar mais legível a formatação de strings. Para criar uma f-string, adicione o prefixo `f` à string.
Por exemplo: `f"Your goal is {step_goal} steps"`.

Nota

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

Neste caso, a condição `steps_taken < step_goal` é avaliada como `False` porque `steps_taken` é igual a `step_goal`. Como a condição não é satisfeita, o bloco de código dentro da declaração `if` não é executado e nada é impresso no console. Isso demonstra que o código só é executado quando a condição é avaliada como `True`.

A imagem ilustra o fluxo de uma declaração if:
- **Verificação da Condição**: o programa avalia se a condição é `True` ou `False`;
- **Execução**: se a condição for `True`, o bloco de código indentado é executado. Caso contrário, o programa o ignora.

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

Explore as nuances do operador condicional if-else em Python por meio de explicações claras e exemplos práticos. Reforce sua compreensão com tarefas práticas que consolidam cada conceito e descubra como utilizar as instruções if-elif-else de forma eficaz para tomadas de decisão mais complexas.

Descubra a versatilidade do operador condicional if e sua capacidade de moldar os resultados de um programa. Explore o universo dos operadores lógicos, domine sua aplicação prática e aprenda a priorizá-los de forma eficaz para escrever códigos claros e eficientes.

Aprenda a tomar decisões com base em condições, simplifique o código utilizando a palavra-chave else, melhorando tanto a eficiência quanto a legibilidade. Descubra a eficiência de decisões em uma linha com o operador ternário!

Descubra a forma mais avançada de declarações condicionais: if-elif-else. Familiarize-se com sua sintaxe e aprenda a aplicar essa construção corretamente para lidar com múltiplos cenários de tomada de decisão em seus programas.

Sintaxe da Instrução If em Python

Exemplo 1: Execução padrão

Explicação

Exemplo 2: Quando Nada é Executado

Solução