EIB · Tema 2: Sentencias condicionales

Análisis de las Sentencias Condicionales en Python

Resumen Ejecutivo

Este documento presenta una síntesis exhaustiva sobre el uso y la teoría de las sentencias condicionales en el lenguaje de programación Python, basándose en los materiales de la Unidad de Trabajo 02 (UT02) del Ciclo Formativo de Grado Superior para el curso 2025-2026 del CIFP César Manrique. Las estructuras condicionales son un pilar fundamental de la programación, ya que otorgan al código la capacidad de tomar decisiones y ejecutar flujos no lineales.

Los puntos clave del análisis son:

* Fundamento de las Decisiones: Las sentencias condicionales (if, elif, else) permiten que un programa evalúe una condición booleana (True o False) y ejecute bloques de código específicos en función del resultado, transformando un script secuencial en una herramienta interactiva y adaptable.
* La Indentación como Sintaxis: A diferencia de otros lenguajes, Python utiliza la indentación (sangría, convencionalmente de cuatro espacios) para definir bloques de código. Esta característica, promovida por su creador Guido Van Rossum, es obligatoria y una fuente común de errores para principiantes (IndentationError).
* Estructuras de Control: El documento detalla las tres estructuras principales: la sentencia simple (if), la compuesta con una alternativa (if-else), y la múltiple para evaluar varias condiciones secuencialmente (if-elif-else).
* Coincidencia de Patrones Estructurales: Se introduce la sentencia match-case, disponible a partir de Python 3.10, como una alternativa avanzada y legible a las estructuras anidadas de if-elif, similar a la sentencia switch de otros lenguajes.
* Lógica Booleana y Operadores: El funcionamiento de los condicionales depende de la evaluación de expresiones booleanas, que se construyen con operadores relacionales y lógicos. Se destaca el orden de prioridad de los operadores y el concepto de "cortocircuito lógico" para una evaluación eficiente y segura del código.
* Aplicación Práctica: El material incluye una serie de ejercicios propuestos, con sus soluciones, que ilustran la aplicación de estos conceptos en escenarios reales como la clasificación de edad, el cálculo de descuentos, la validación de contraseñas o la determinación de años bisiestos.

En resumen, el dominio de las sentencias condicionales es esencial para la resolución de problemas que impliquen toma de decisiones, y su correcta implementación en Python requiere una estricta adherencia a sus reglas sintácticas, especialmente la indentación.

1. Fundamentos de las Estructuras Condicionales

Las sentencias condicionales son estructuras de control que permiten a un programa tomar decisiones y alterar su flujo de ejecución. En lugar de seguir un camino secuencial de instrucciones de principio a fin, estas estructuras introducen bifurcaciones, permitiendo que el programa elija un camino de código sobre otro basándose en el cumplimiento de una o más condiciones.

Los tres principios fundamentales de su funcionamiento son:

1. Evaluación de una Condición: Se plantea una pregunta cuya respuesta solo puede ser Verdadero (True) o Falso (False).
2. Ejecución si es Verdadero: Si la condición se cumple, se ejecuta un bloque de código específico.
3. Ejecución si es Falso: Si la condición no se cumple, el programa salta ese bloque y, opcionalmente, puede ejecutar un bloque de código alternativo.

Los componentes clave de estas estructuras son:

* Condición: Una expresión que resulta en un valor booleano, típicamente usando operadores de comparación y lógicos.
* Bloque de Código: Las instrucciones que se ejecutan si la condición es True.
* Alternativas: El código que se ejecuta si la condición es False (por ejemplo, en un bloque else o elif).

Estas estructuras son la base para construir programas inteligentes que responden a diferentes entradas o estados, convirtiendo el software en una herramienta adaptable.

2. Sintaxis y Reglas Clave en Python

Python presenta reglas de escritura particulares, siendo la más distintiva el uso de la indentación para definir la estructura del código.

2.1. Definición de Bloques: La Indentación

A diferencia de muchos lenguajes que usan llaves ({}) u otros símbolos para delimitar bloques de código, Python utiliza espacios en blanco. Esta decisión de su creador, Guido Van Rossum, busca evitar caracteres considerados innecesarios.

* Regla: Los bloques de código se definen mediante indentación.
* Estándar (PEP 8): Se recomienda usar 4 espacios en blanco por cada nivel de indentación.
* Error Común: Una indentación incorrecta o inconsistente provoca un error de tipo IndentationError. Es crucial no mezclar espacios y tabulaciones.

2.2. Guía de Estilo: Longitud de Línea y Sintaxis

* Longitud de Línea: La guía de estilo PEP 8 recomienda una longitud máxima de 80 caracteres por línea. Aunque esto genera debate debido a las mayores resoluciones de pantalla actuales, sigue siendo una convención extendida.
* División de Líneas Largas: Python ofrece dos métodos para dividir una línea de código:
1. Uso de Paréntesis, Corchetes o Llaves (Preferido): El código dentro de (), [], o {} puede dividirse en varias líneas de forma natural.
2. Uso de la Barra Invertida (\): Se puede usar el carácter \ al final de una línea para indicar que continúa en la siguiente. Se recomienda evitarlo si es posible, ya que un espacio accidental después de la barra puede causar errores.
* Dos Puntos (:): Es obligatorio colocar dos puntos (:) al final de la línea que inicia una sentencia de control como if, elif, else, y match.

3. Tipos de Sentencias Condicionales

Python proporciona varias estructuras para manejar la lógica condicional, desde la más simple hasta construcciones más complejas.

3.1. Sentencia Simple (if)

Es la estructura más básica. Evalúa una condición y ejecuta un bloque de código únicamente si esta es True. Si es False, el bloque se ignora y el programa continúa.

Sintaxis:

if condicion:
# Bloque de código a ejecutar si la condición es True


Ejemplo de uso con operadores lógicos:

* Operador and: Requiere que todas las condiciones sean verdaderas.
* Operador or: Requiere que al menos una de las condiciones sea verdadera.
* Operador not: Invierte el valor booleano de una expresión. Es útil para verificar condiciones falsas o si una colección está vacía.

3.2. Sentencia Compuesta (if-else)

Añade un camino alternativo que se ejecuta si la condición del if es False.

Sintaxis:

if condicion:
# Bloque A (si la condición es True)
else:
# Bloque B (si la condición es False)


Ejemplo:

numero = 13
if numero % 2 == 0:
print(f"El número {numero} es PAR.")
else:
print(f"El número {numero} es IMPAR.")
# Salida: El número 13 es IMPAR.


Python también ofrece una sintaxis abreviada (operador ternario) para asignaciones condicionales en una sola línea:

puntuacion = 75
estado = "Hay Stock" if puntuacion >= 70 else "No hay Stock"


3.3. Condicionales Múltiples (if-elif-else)

Permite verificar múltiples condiciones de forma secuencial. elif es una contracción de else if. El programa evalúa las condiciones en orden y ejecuta el bloque de la primera que resulte True, ignorando el resto de la estructura.

Sintaxis:

if condicion_1:
# Bloque A (si condicion_1 es True)
elif condicion_2:
# Bloque B (si condicion_1 es False y condicion_2 es True)
else:
# Bloque C (si ninguna de las anteriores es True)


Ejemplo:

hora = 14
if hora < 12:
print("¡Buenos días!")
elif hora < 19:
print("¡Buenas tardes!")
else:
print("¡Buenas noches!")
# Salida: ¡Buenas tardes!


3.4. Anidación de Estructuras Condicionales

Ocurre cuando una sentencia condicional (if, elif o else) contiene otra estructura condicional completa dentro de su bloque. Es útil para realizar verificaciones en múltiples niveles, donde una segunda condición solo se evalúa si la primera ya se ha cumplido. Se debe mantener una indentación consistente (4 espacios por cada nivel).

Ejemplo:

edad_usuario = 25
saldo_cuenta = 1500
if edad_usuario >= 18:
print("Verificación de edad: OK.")
if saldo_cuenta >= 1000:
print("Verificación de saldo: OK. Permitiendo compra grande.")
else:
print("Saldo insuficiente para esta compra.")
else:
print("Compra denegada: Edad mínima no cumplida.")


Recomendación: Evitar la anidación profunda siempre que sea posible para mantener la simplicidad, utilizando operadores lógicos en su lugar.

4. Coincidencia de Patrones Estructurales (match-case)

Introducida en Python 3.10, la sentencia match-case ofrece una alternativa más estructurada y legible a las cadenas if-elif-else anidadas, especialmente útil para comparar un valor con múltiples literales o patrones complejos.

Sintaxis General:

match <expresion_a_comparar>:
case <patron_1>:
# Código si la expresión coincide con patron_1
case <patron_2> | <patron_3>: # Patrón con OR lógico
# Código si coincide con patron_2 o patron_3
case <patron_con_guarda> if <condicion>:
# Código si coincide con el patrón Y la guarda es True
case _: # Caso por defecto (comodín)
# Código si no coincide con ningún patrón anterior


Reglas Clave:

* Las sentencias match y case deben terminar con dos puntos (:).
* Los bloques de código de cada case deben estar indentados.
* Los patrones se evalúan de arriba hacia abajo; la ejecución termina en la primera coincidencia.
* El caso comodín (case _) siempre debe ir al final.

5. Evaluación de Expresiones Booleanas

La toma de decisiones se basa en la evaluación de expresiones que resultan en True o False.

5.1. Orden de Prioridad de Operadores

Python evalúa las expresiones complejas siguiendo un orden de prioridad:

1. Paréntesis ( ... ).
2. Operadores aritméticos (multiplicación, suma, etc.).
3. Operadores relacionales (<, >, ==, etc.).
4. Operadores lógicos: primero not, luego and, y finalmente or.

Se recomienda encarecidamente el uso de paréntesis para mejorar la legibilidad y evitar errores.

5.2. Cortocircuito Lógico (Short-Circuiting)

Python no evalúa una expresión lógica por completo si el resultado final ya puede determinarse.

* Con and: Si el primer operando es False, la expresión entera será False, y el segundo operando no se evalúa. Esto es útil para prevenir errores como la división por cero.
* Con or: Si el primer operando es True, la expresión entera será True, y el segundo operando no se evalúa.

5.3. Valores "Truthy" y "Falsy"

En contextos booleanos, Python interpreta ciertos valores como False:

* Cualquier número cero (ej. 0, 0.0).
* Colecciones vacías (ej. "", [], (), {}).
* El valor None.
* El booleano False. Cualquier otro valor es considerado True.

6. Aplicaciones Prácticas y Ejercicios Propuestos

El material didáctico propone una serie de ejercicios para consolidar la comprensión de las sentencias condicionales, aplicando la lógica a diversos escenarios.

Ejercicio Objetivo Conceptos Clave Aplicados
1. Verificador de Edad Clasificar a un usuario como menor de edad, adulto o adulto mayor. if-elif-else, operadores and, rangos numéricos.
2. Calculadora de Descuentos Aplicar diferentes porcentajes de descuento según el monto de la compra. if-elif-else, evaluación ordenada de condiciones de mayor a menor.
3. Clasificador de Notas Convertir una nota numérica (0-100) a una calificación en letra (A, B, C, D, F). if-elif-else, simplificación de rangos mediante evaluación secuencial.
4. Año Bisiesto Determinar si un año es bisiesto según las reglas astronómicas. if-elif-else, operador módulo (%), lógica anidada implícita.
5. Validador de Contraseña Verificar si una contraseña cumple con criterios de seguridad (longitud, mayúsculas, etc.). Banderas booleanas, bucles, métodos de cadena (isupper, islower), and.
6. Calculadora de IMC Calcular el Índice de Masa Corporal y clasificar el resultado. Operaciones aritméticas, if-elif-else, rangos con decimales.

7. Contexto Educativo y Objetivos de Aprendizaje

Este contenido forma parte de la Unidad de Trabajo 02 (UT02) del CIFP César Manrique, bajo la supervisión de la Consejería de Educación, Universidades, Cultura y Deportes del Gobierno de Canarias.

* Tiempo Estimado: 2 horas.
* Resultado de Aprendizaje (RA 2): Reconoce las sentencias condicionales en Python aplicándolas a la resolución de problemas que impliquen toma de decisiones.

Los criterios de evaluación específicos que se buscan alcanzar incluyen:

* Interpretar el concepto y las partes de una sentencia condicional.
* Aplicar correctamente el sangrado (indentación).
* Manejar la ejecución condicional y el control de variables.
* Interpretar y aplicar sentencias condicionales simples y anidadas.
* Utilizar la sintaxis correcta en estructuras compactas.
* Escribir bloques de programas utilizando las diferentes estructuras condicionales.

Guía de Estudio: Sentencias Condicionales en Python

Esta guía de estudio está diseñada para evaluar y consolidar la comprensión de las estructuras de control condicionales en Python, basándose en los materiales de la UT02 del curso 2025-2026.

Cuestionario: Preguntas Cortas

Responda a las siguientes preguntas en 2-3 frases, utilizando únicamente la información proporcionada en los materiales de estudio.

1. ¿Cuál es el propósito fundamental de las sentencias condicionales en programación?
2. ¿Cómo define Python los bloques de código y cuál es el estándar recomendado?
3. Explique la diferencia principal entre los operadores lógicos and y or.
4. ¿Qué es el cortocircuito lógico y cómo optimiza la evaluación de expresiones?
5. ¿Para qué se utiliza la estructura if-elif-else y qué ventaja ofrece sobre el uso de if anidados?
6. Describa qué es el operador ternario en Python y cuál es su sintaxis.
7. ¿Qué es la anidación de condicionales y cuál es una buena práctica recomendada para su uso?
8. ¿Qué es la estructura match/case introducida en Python 3.10 y cuál es el propósito de case _?
9. Según la guía de estilo PEP 8, ¿cuál es la longitud máxima recomendada para una línea de código y cuál es el método preferido para dividir líneas largas?
10. Además de False, None y el cero, ¿qué tipos de estructuras de datos evalúa Python como False en un contexto booleano?


--------------------------------------------------------------------------------


Clave de Respuestas

1. ¿Cuál es el propósito fundamental de las sentencias condicionales en programación? Las sentencias condicionales otorgan al código la capacidad de tomar decisiones y ejecutar diferentes acciones basándose en si una condición se cumple o no. Esto permite que el programa siga un flujo de ejecución no lineal, eligiendo un camino de código sobre otro para construir programas inteligentes y dinámicos.
2. ¿Cómo define Python los bloques de código y cuál es el estándar recomendado? A diferencia de otros lenguajes, Python no utiliza signos como llaves para definir bloques de código. En su lugar, utiliza la indentación (sangría), y el estándar recomendado por la guía de estilo PEP 8 es de 4 espacios en blanco para cada nivel de anidación.
3. Explique la diferencia principal entre los operadores lógicos and y or. El operador and requiere que todas las condiciones conectadas sean True para que la expresión completa sea verdadera. En cambio, el operador or solo necesita que al menos una de las condiciones sea True para que la expresión completa se considere verdadera.
4. ¿Qué es el cortocircuito lógico y cómo optimiza la evaluación de expresiones? El cortocircuito lógico es una optimización donde Python detiene la evaluación de una expresión lógica tan pronto como puede determinar el resultado final. Por ejemplo, en una expresión con and, si la primera condición es False, el resto de la expresión se ignora, lo que mejora la eficiencia y puede evitar errores como la división por cero.
5. ¿Para qué se utiliza la estructura if-elif-else y qué ventaja ofrece sobre el uso de if anidados? La estructura if-elif-else se utiliza para verificar múltiples condiciones de forma secuencial, ejecutando solo el bloque de la primera condición verdadera que encuentra. Sustituye la combinación de else seguido de un if, lo que evita la anidación profunda y hace el código más simple y legible.
6. Describa qué es el operador ternario en Python y cuál es su sintaxis. El operador ternario es una sintaxis abreviada para una estructura if-else que asigna un valor a una variable en una sola línea. Su sintaxis es: valor_si_true if condicion else valor_si_false.
7. ¿Qué es la anidación de condicionales y cuál es una buena práctica recomendada para su uso? La anidación de condicionales ocurre cuando una sentencia condicional se coloca dentro del bloque de código de otra. Aunque es útil para verificaciones de múltiples niveles, se recomienda evitar la anidación profunda para mantener la simplicidad y legibilidad, priorizando el uso de operadores lógicos cuando sea posible.
8. ¿Qué es la estructura match/case introducida en Python 3.10 y cuál es el propósito de case _? Es una sentencia condicional similar a un switch que permite comparar una expresión con una serie de patrones. El case _ actúa como un comodín o caso por defecto, ejecutándose si la expresión no coincide con ninguno de los patrones anteriores.
9. Según la guía de estilo PEP 8, ¿cuál es la longitud máxima recomendada para una línea de código y cuál es el método preferido para dividir líneas largas? La PEP 8 recomienda una longitud máxima de 80 caracteres por línea. El método preferido y más limpio para dividir líneas largas es hacerlo dentro de delimitadores abiertos como paréntesis (), corchetes [] o llaves {}.
10. Además de False, None y el cero, ¿qué tipos de estructuras de datos evalúa Python como False en un contexto booleano? Python evalúa como False las estructuras de datos que están vacías. Esto incluye cadenas vacías (""), listas vacías ([]), tuplas vacías, diccionarios vacíos ({}) y conjuntos vacíos.


--------------------------------------------------------------------------------


Preguntas para Ensayo

1. Analice la importancia de la indentación en Python como mecanismo para definir la estructura del código. Compare este enfoque con el de otros lenguajes que utilizan delimitadores explícitos (como {}), y discuta las ventajas y desventajas, incluyendo la naturaleza del error IndentationError.
2. Describa detalladamente el orden de prioridad que sigue Python al evaluar expresiones booleanas complejas que combinan operaciones aritméticas, relacionales y lógicas (not, and, or). Ilustre el proceso con un ejemplo propio, explicando paso a paso cómo se resolvería la expresión.
3. Compare y contraste las estructuras if-elif-else y match/case. Explique en qué escenarios es más apropiado usar una sobre la otra, y detalle las capacidades avanzadas de match/case, como la desestructuración de tuplas y los patrones con guardas condicionales.
4. Explique el concepto de "cortocircuito lógico" en el contexto de los operadores and y or. Proporcione ejemplos prácticos de cómo esta característica no solo mejora la eficiencia, sino que también permite escribir código más seguro, previniendo errores comunes en tiempo de ejecución.
5. Defina la "concatenación de comparaciones" en Python (ej., if 10 < x < 20:). Explique cómo funciona internamente y compárela con la forma tradicional que utiliza el operador and. Discuta las implicaciones de esta sintaxis en la legibilidad y simplicidad del código.


--------------------------------------------------------------------------------


Glosario de Términos Clave

Término Definición
Anidación de Estructuras Condicionales Ocurre cuando una sentencia condicional (if, elif, o else) contiene otra sentencia condicional completa dentro de su bloque de código. Es útil cuando la decisión a tomar depende de múltiples niveles de verificación.
Barra Invertida (Backslash) Un carácter (\) que se puede usar al final de una línea para indicar que el código continúa en la línea siguiente. La PEP 8 recomienda evitar su uso en favor de romper líneas dentro de paréntesis, corchetes o llaves.
Bloque de Código Conjunto de instrucciones que se ejecutan juntas. En Python, los bloques se definen mediante la indentación (generalmente 4 espacios).
Concatenación de comparaciones Una sintaxis que Python permite para verificar si un valor está dentro de un rango, como if 10 < x < 20:, que es equivalente a if x > 10 and x < 20:.
Condición Una expresión que siempre resulta en un valor booleano (True o False). Se utiliza en las sentencias condicionales para determinar qué bloque de código ejecutar.
Cortocircuito Lógico Una optimización en la que las expresiones lógicas no se evalúan por completo si se puede determinar el resultado antes. Por ejemplo, si el primer operando de and es falso, el segundo no se evalúa.
Indentación (Sangría) El uso de espacios en blanco (estándar de 4) al inicio de una línea para definir bloques de código. Es una regla sintáctica obligatoria en Python.
Operador Ternario Una sintaxis abreviada para if-else que permite asignar un valor a una variable en una sola línea, con el formato: valor_si_true if condicion else valor_si_false.
Operadores Lógicos Operadores (and, or, not) que se utilizan para conectar varias comparaciones o invertir un valor booleano, permitiendo construir condiciones complejas.
Operadores Relacionales Operadores (==, !=, >, <, >=, <=) que comparan dos valores y devuelven un resultado booleano (True o False).
PEP 8 La guía de estilo oficial para el código Python, que establece convenciones para mejorar la legibilidad y consistencia del código, como la indentación de 4 espacios y la longitud de línea de 80 caracteres.
Sentencias Condicionales Estructuras de control (if, if-else, if-elif-else) que permiten a un programa tomar decisiones y ejecutar diferentes bloques de código basándose en el cumplimiento de una o más condiciones.
Structural Pattern Matching (match/case) Una sentencia condicional introducida en Python 3.10 que permite comparar un valor con una serie de patrones de forma estructurada, similar a la sentencia switch de otros lenguajes.