Summary  
This chapter explains how to use Python comparison operators (==, !=, >, <, >=, <=) to evaluate boolean expressions in conditionals, including comparing numbers, strings, and booleans, and using chained comparisons to simplify range checks.

General domain of usage  
Health and fitness tracking applications

Agora, vamos nos aprofundar nos detalhes do que você pode realmente incluir dentro dessas condições.

Os operadores de comparação são úteis para avaliar os valores das variáveis. Seu resultado é sempre um valor booleano, que pode ser `True` ou `False`.

Você pode comparar expressões matemáticas complexas, elementos de diferentes estruturas de dados, strings e até mesmo valores booleanos. Como já sabemos como comparar números de capítulos anteriores, vamos explorar outros tipos de comparações:

#### Exemplo 1: Comparando strings para determinar tipos de exercícios

favorite_activity = "Yoga"
current_activity = "Running"

if favorite_activity != current_activity:
    print("This is not your favorite activity, but keep going!")

Isso verifica se duas strings não são iguais (correspondência exata, sensível a maiúsculas e minúsculas).
#### Exemplo 2: Comparando valores booleanos para verificar a conclusão da atividade

# Check if the user completed their morning routine
morning_run_completed = True

if morning_run_completed:
    print("Great job on completing your morning run!")

Este exemplo avalia se uma atividade específica foi concluída (neste caso, uma corrida matinal). Em vez de escrever `if morning_run_completed == True`, usamos `if morning_run_completed` porque o valor de `morning_run_completed` já é um booleano (True ou False). Escrever `== True` é redundante e menos conciso. Python permite tais simplificações para tornar o código mais limpo e fácil de ler.
#### Exemplo 3: Verificando se um número está dentro de um intervalo
Seu aplicativo pode ajudar os usuários a monitorar sua atividade física. Esta tarefa verifica se a contagem diária de passos do usuário está dentro de um intervalo recomendado e fornece feedback sobre seu progresso.

daily_steps = 7500

# Step count range check
if 5000 <= daily_steps <= 10000:
    print("You're on track with your step count!")

Este exemplo demonstra uma comparação encadeada para verificar se um valor numérico está dentro de um intervalo específico.
Em vez de escrever:</br>
`if daily_steps >= 5000 and daily_steps <= 10000:`</br>
você pode simplificar usando uma comparação encadeada para maior clareza e concisão:</br>
`if 5000 <= daily_steps <= 10000`.</br>
Evite complicar demais as verificações de intervalo — use encadeamento sempre que possível para manter seu código mais limpo e fácil de entender.

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

# 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_variables_declared(self):
        """Check if all required variables are declared."""
        variables = ['street_temperature', 'hydration_goal_met', 'running_temp']
        missing_vars = [var for var in variables if not hasattr(user_code, var)]
        
        _dynamic_test(
            self,
            not missing_vars,
            "All required variables are declared.",
            f"Missing variable(s): {', '.join(missing_vars)}."
        )

    def test_variables_types(self):
        """Check if variables have the correct data types."""
        expected_types = {
            'street_temperature': int,
            'hydration_goal_met': bool,
            'running_temp': bool
        }
        incorrect_types = {
            var: type(getattr(user_code, var)) 
            for var in expected_types if not isinstance(getattr(user_code, var), expected_types[var])
        }

        _dynamic_test(
            self,
            not incorrect_types,
            "All variables have the correct data types.",
            f"Incorrect data types detected: {incorrect_types}."
        )

    def test_running_temp_logic(self):
        """Check if `running_temp` is set correctly based on `street_temperature`."""
        expected_value = 10 <= user_code.street_temperature <= 20
        _dynamic_test(
            self,
            user_code.running_temp == expected_value,
            f"The `running_temp` variable is correctly set to {expected_value} when `street_temperature` is {user_code.street_temperature}.",
            f"Incorrect value for `running_temp`. Expected {expected_value} when `street_temperature` is {user_code.street_temperature}, but got {user_code.running_temp}."
        )

    def test_hydration_goal_condition_used(self):
        """Ensure `if hydration_goal_met:` is correctly used."""
        with open("user_code.py", "r") as f:
            user_code_source = f.read()

        correct_condition = (
          re.search(r'if\s+hydration_goal_met\s*:', user_code_source) or
          re.search(r'if\s+hydration_goal_met\s*==\s*True\s*:', user_code_source) or
          re.search(r'if\s+hydration_goal_met\s*!=\s*False\s*:', user_code_source)
        )

        _dynamic_test(
            self,
            correct_condition,
            "The correct condition `if hydration_goal_met:` is used.",
            "Expected the condition `if hydration_goal_met:`, but it was not found."
        )

    def test_if_statements_used(self):
        """Check if `if` statements are used in the code."""
        with open("user_code.py", "r") as f:
            user_code_source = f.read()

        if_found = re.search(r'^\s*if\s+.*:', user_code_source, re.MULTILINE) is not None

        _dynamic_test(
            self,
            if_found,
            "At least one `if` statement is used in the code.",
            "Expected at least one `if` statement in the code, but none were found."
        )

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 a compreensão com tarefas práticas que consolidam cada conceito e descubra como utilizar as instruções if-elif-else de forma eficaz para decisões mais complexas.

Você desvendará os mistérios do versátil operador condicional "if", descobrindo seu poder de moldar resultados. Mergulhe mais fundo no mundo dos operadores lógicos, dominando sua aplicação artística e descobrindo os segredos de priorizar seu uso de forma eficaz.

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

Você aprenderá sobre a forma mais avançada do operador condicional if-elif-else, se familiarizará com a sintaxe dessa construção e como ela é aplicada corretamente.

Operadores de Comparação

Exemplo 1: Comparando strings para determinar tipos de exercícios

Exemplo 2: Comparando valores booleanos para verificar a conclusão da atividade

Exemplo 3: Verificando se um número está dentro de um intervalo

Solução