Summary  
This chapter explains how Python determines the order of evaluation in expressions using operator precedence for logical operators and how parentheses can alter that order.

General domain of usage  
Fitness tracking applications

Al desarrollar una aplicación en Python, es importante comprender cómo maneja Python la precedencia de operadores, que determina el orden en que se realizan las operaciones en las expresiones. Esto garantiza que las condiciones se evalúen correctamente. El uso de paréntesis también puede ayudar a aclarar y controlar el orden de las operaciones.

### Precedencia de operadores lógicos
Entre los operadores lógicos, Python sigue esta precedencia:

#### Ejemplo: Objetivos de un rastreador de actividad física
Aclaramos con ejemplos en el contexto de un rastreador de actividad física:

# Example 1: AND has higher precedence than OR
steps_taken = 8000
step_goal = 10000
calories_burned = 450
calorie_goal = 500

first_result = steps_taken >= step_goal or calories_burned >= calorie_goal and False
# Same as: steps_taken >= step_goal or (calories_burned >= calorie_goal and False)

# Example 2: Parentheses change the precedence
second_result = (steps_taken >= step_goal or calories_burned >= calorie_goal) and True

# Example 3: NOT has the highest precedence
third_result = not (steps_taken >= step_goal) or calories_burned >= calorie_goal
# Same as: (not (steps_taken >= step_goal)) or (calories_burned >= calorie_goal)

print('The first expression is:', first_result)
print('The second expression is:', second_result)
print('The third expression is:', third_result)

Al igual que los operadores lógicos, otros operadores como los **operadores de comparación** (`>=`, `<=`, `==`, etc.) y los **operadores matemáticos** (`+`, `-`, `*`, `/`, etc.) también siguen un orden específico de precedencia.

Por ejemplo:
1. Los operadores matemáticos como `*` y `/` tienen mayor precedencia que `+` y `-`;
2. Los operadores de comparación (`<`, `>`, `==`, etc.) se evalúan después de las operaciones matemáticas;
3. Los operadores lógicos (<code>not</code>, <code>and</code>, <code>or</code>) se evalúan al final.

El uso de paréntesis <code>( )</code> puede ayudar a clarificar y controlar el orden de evaluación en tus expresiones.

Nota

import unittest
from contextlib import redirect_stdout
import io
import importlib
import user_code
import ast

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_if_statement_is_single(self):
 with open("user_code.py", "r") as f:
 tree = ast.parse(f.read())

 # Count all If statements in the AST
 if_statements = [node for node in ast.walk(tree) if isinstance(node, ast.If)]

 # Check if any If statement contains another If inside it (nested If)
 nested_if_found = any(
 any(isinstance(child, ast.If) for child in ast.iter_child_nodes(if_node))
 for if_node in if_statements
 )

 _dynamic_test(
 self,
 len(if_statements) == 1 and not nested_if_found,
 "The solution correctly uses a single `if` statement without unnecessary nesting.",
 "The solution should contain only one `if` statement without nested conditions. Nested `if` statements make the code unnecessarily complex."
 )

 def test_variables_declared(self):
 """Check if all required variables are declared."""
 variables = ['steps_taken', 'step_goal', 'calories_burned', 'calorie_goal', 'morning_exercise', 'all_conditions_met']
 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 each variable has the correct data type."""
 expected_types = {
 'steps_taken': int,
 'step_goal': int,
 'calories_burned': int,
 'calorie_goal': int,
 'morning_exercise': bool,
 'all_conditions_met': bool
 }

 for var_name, expected_type in expected_types.items():
 actual_value = getattr(user_code, var_name, None)
 actual_type = type(actual_value)

 _dynamic_test(
 self,
 isinstance(actual_value, expected_type),
 f"The `{var_name}` variable has the correct data type ({expected_type.__name__}).",
 f"Incorrect data type for `{var_name}`. Expected {expected_type.__name__}, but got {actual_type.__name__}."
 )


 def test_all_conditions_met_logic(self):
 """Check if `all_conditions_met` is correctly updated based on conditions."""
 # Extract values from user_code
 steps_taken = user_code.steps_taken
 step_goal = user_code.step_goal
 calories_burned = user_code.calories_burned
 calorie_goal = user_code.calorie_goal
 morning_exercise = user_code.morning_exercise

 # Expected logic
 expected_value = not (steps_taken <= step_goal and calories_burned <= calorie_goal and not morning_exercise)

 _dynamic_test(
 self,
 user_code.all_conditions_met == expected_value,
 f"The `all_conditions_met` variable is correctly set to {expected_value}.",
 f"Incorrect value for `all_conditions_met`. Expected {expected_value}, but got {user_code.all_conditions_met}."
 )

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.

Operator Precedence in Python

Precedencia de operadores lógicos

Ejemplo: Objetivos de un rastreador de actividad física

Solución