2.1.-Condicionales

2.1. Sentencias condicionales

Idea principal

Las sentencias condicionales permiten que un programa elija qué instrucciones ejecutar según los datos que recibe. En Python, if, elif y else organizan esas decisiones; las expresiones booleanas determinan qué camino se sigue.

Al validar una entrada, aplicar una regla de negocio o impedir una operación insegura, el programa necesita tomar decisiones. En esta parte de la unidad estudiarás cómo expresar esas decisiones en Python y cómo comprobar que cada caso sigue la rama prevista.

El objetivo no es memorizar palabras clave de forma aislada, sino construir condiciones correctas, legibles y seguras, y saber localizar errores cuando el resultado no sea el esperado.

La normativa del módulo de Programación relaciona este tema con el siguiente resultado de aprendizaje y sus criterios de evaluación:

Código	Descripción literal de la normativa
RA 3	Escribe y depura código, analizando y utilizando las estructuras de control del lenguaje.
CE 3.a	Se ha escrito y probado código que haga uso de estructuras de selección.
CE 3.e	Se han creado programas ejecutables utilizando diferentes estructuras de control.

Qué deberías saber al terminar

Al acabar este tema deberías poder:

• construir y combinar expresiones de comparación y lógicas;
• elegir entre if, if-else, if-elif-else y condicionales anidados;
• ordenar las condiciones para que se ejecute la rama correcta;
• usar la evaluación en cortocircuito como protección y localizar errores habituales.

Mapa del tema

Avanzaremos en este orden:

1. expresiones booleanas y operadores;
2. selección simple, alternativa y encadenada;
3. condicionales anidados y simplificación;
4. cortocircuito, patrón guardián y depuración.

1. Expresiones booleanas

Una condición se construye con una expresión cuyo resultado se interpreta como verdadero o falso. Las comparaciones, por ejemplo, permiten comprobar si dos valores son iguales, distintos o mantienen una relación de orden.

Expresión booleana

Una expresión booleana es una expresión cuyo resultado es True (verdadero) o False (falso). En Python, esos valores pertenecen al tipo bool; no son cadenas de texto.

>>> 5 == 5
True
>>> 5 == 6
False
>>> type(True)
<class 'bool'>

1.1. Operadores de comparación

Operador	Significado	Ejemplo
==	Igual a	5 == 5
!=	Distinto de	5 != 6
>	Mayor que	edad > 18
<	Menor que	temperatura < 0
>=	Mayor o igual que	nota >= 5
<=	Menor o igual que	intentos <= 3
is	Es el mismo objeto	valor is None
is not	No es el mismo objeto	valor is not None

== compara valores; is comprueba si dos referencias apuntan al mismo objeto. Para comparar valores se usa ==. El uso más habitual de is en este nivel es comprobar el valor especial None, por ejemplo, resultado is None.

Comparar no es asignar

edad = 18       # Asigna un valor a la variable.
edad == 18      # Comprueba si la variable vale 18.

Un error frecuente es escribir un solo igual (=) cuando se quiere comparar. = realiza una asignación; == realiza una comparación. En Python tampoco existen los operadores =< ni =>: se escriben <= y >=.

1.2. Operadores lógicos

Los operadores lógicos permiten combinar o negar condiciones:

Operador	Significado	Ejemplo
and	Las dos condiciones deben ser verdaderas	edad >= 18 and tiene_permiso
or	Basta con que una condición sea verdadera	divisible_por_2 or divisible_por_3
not	Invierte el valor lógico	not esta_cerrado

x = 5
n = 15

x > 0 and x < 10       # True: x cumple las dos condiciones.
n % 2 == 0 or n % 3 == 0  # True: n es divisible por 3.
not (x > 10)            # True: x no es mayor que 10.

En la última expresión, not (x > 10) equivale a x <= 10 cuando x es un número. Los paréntesis hacen explícito qué parte se está negando.

Los valores que se consideran verdaderos

Python permite usar valores que no sean de tipo bool en una condición. Por ejemplo, el número 0, una cadena vacía, una colección vacía y None se consideran falsos; los números distintos de cero y las cadenas y colecciones no vacías se consideran verdaderos. Además, and y or pueden devolver uno de sus operandos en vez de un valor bool: por ejemplo, 17 and True da True, mientras que 5 or False da 5. Para empezar, resulta más claro escribir condiciones explícitas que dependan de True o False.

2. Estructuras de selección

Las estructuras de selección evalúan una condición y determinan qué bloque del programa se ejecuta. En Python, la cabecera termina con dos puntos (:) y el bloque se marca mediante sangría. La convención es usar cuatro espacios por nivel y no mezclar tabuladores con espacios.

2.1. Selección simple: if

La forma más sencilla ejecuta un bloque solo cuando la condición es verdadera:

x = 3

if x > 0:
    print("x es positivo")

La línea que empieza por if es la cabecera y las instrucciones indentadas forman su bloque. Una estructura de este tipo es una sentencia compuesta: incluye una cabecera y un bloque de instrucciones, como también ocurre en las definiciones de funciones y en los bucles. El bloque puede tener varias instrucciones, pero no puede estar vacío. Mientras se desarrolla el programa, se puede usar pass como marcador temporal:

x = -1

if x < 0:
    pass  # Pendiente de gestionar los valores negativos.

Una condición verdadera ejecuta el bloque indentado; una condición falsa lo omite.

Si escribes una estructura compuesta directamente en el intérprete interactivo de Python, deja una línea en blanco al final para indicar que has terminado el bloque. En un archivo de programa no hace falta esa línea en blanco, aunque separar bloques puede mejorar la lectura.

>>> x = 3
>>> if x < 10:
...     print("Pequeño")
...
Pequeño

2.2. Selección alternativa: if-else

Cuando hay dos alternativas excluyentes, se puede añadir else. Si la condición es verdadera se ejecuta el bloque de if; si es falsa, se ejecuta el de else:

x = 7

if x % 2 == 0:
    print("x es par")
else:
    print("x es impar")

El operador módulo (%) devuelve el resto de una división: un entero es par cuando x % 2 vale 0. En una estructura if-else se ejecuta exactamente una de las dos ramas.

La condición dirige la ejecución a una de las dos ramas.

2.3. Selección encadenada: if-elif-else

Si hay más de dos casos posibles, se puede encadenar una o varias cláusulas elif (abreviatura de else if). Python evalúa las condiciones en orden y ejecuta solo el bloque de la primera condición verdadera. La cláusula else, que recoge los demás casos, es opcional y, si aparece, debe ir al final.

x = 5
y = 7

if x < y:
    print("x es menor que y")
elif x > y:
    print("x es mayor que y")
else:
    print("x e y son iguales")

No hay un límite fijo para el número de cláusulas elif. También se puede omitir else si no hace falta hacer nada cuando ninguna condición se cumple.

opcion = "b"

if opcion == "a":
    print("Respuesta incorrecta")
elif opcion == "b":
    print("Respuesta correcta")
elif opcion == "c":
    print("Casi, pero no es correcto")

Las condiciones se comprueban en orden y solo se ejecuta la primera rama coincidente.

Aunque más de una condición pudiera ser verdadera, en una misma cadena if-elif-else solo se ejecuta la primera que se cumple. Por eso, al clasificar valores por rangos, el orden de las condiciones es importante.

3. Condicionales anidados

Un condicional está anidado cuando aparece dentro del bloque de otro condicional. El siguiente código distingue si dos valores son iguales y, si no lo son, cuál es menor:

x = 5
y = 7

if x == y:
    print("x e y son iguales")
else:
    if x < y:
        print("x es menor que y")
    else:
        print("x es mayor que y")

El segundo if solo se evalúa cuando la condición exterior es falsa. Cada nivel adicional añade sangría; si se acumulan muchos niveles, cuesta más seguir el flujo.

El segundo condicional está dentro de la rama else del primero.

Cuando las condiciones no dependen unas de otras, se puede evitar parte del anidamiento usando elif o combinando condiciones con and. Python también permite encadenar comparaciones:

# Dos condiciones anidadas:
if 0 < x:
    if x < 10:
        print("x es un número positivo de una cifra")

# La misma comprobación, expresada de forma más compacta:
if 0 < x < 10:
    print("x es un número positivo de una cifra")

La comparación encadenada 0 < x < 10 equivale a comprobar que x es mayor que 0 y menor que 10. El anidamiento sigue siendo adecuado cuando la segunda decisión solo tiene sentido después de la primera; conviene evitarlo cuando una estructura más plana expresa la misma lógica con mayor claridad.

4. Cortocircuito y depuración

4.1. Evaluación en cortocircuito y patrón guardián

Python evalúa las expresiones lógicas de izquierda a derecha. Con and, si una parte es falsa, el resultado completo ya es falso y no hace falta evaluar lo que viene después. Con or, si una parte es verdadera, el resultado completo ya es verdadero y se deja de evaluar. Esta forma de detenerse se llama evaluación en cortocircuito.

El cortocircuito permite colocar primero una comprobación que proteja una operación que podría fallar. Esa comprobación actúa como guardián:

x = 6
y = 0

if x >= 2 and y != 0 and (x / y) > 2:
    print("La condición se cumple")

La condición y != 0 evita que se evalúe x / y cuando el divisor es cero. El orden es esencial: si se intenta dividir antes de comprobar y != 0, Python lanza ZeroDivisionError.

El guardián debe ir antes

# Incorrecto: se intenta dividir antes de comprobar el divisor.
if x >= 2 and (x / y) > 2 and y != 0:
    print("La condición se cumple")

Con x = 6 e y = 0, la expresión falla antes de llegar a y != 0. La comprobación solo protege la división cuando aparece antes de ella.

# Seguro: la comprobación del índice precede al acceso a la lista.
numeros = [1, 2, 3, 4, 5]
indice = 10

if indice >= 0 and indice < len(numeros) and numeros[indice] > 3:
    print("El elemento es mayor que 3")

En este segundo ejemplo, el acceso numeros[indice] solo se alcanza si el índice está dentro del intervalo permitido. Comprobar también que indice >= 0 evita que un índice negativo, que en Python puede seleccionar un elemento desde el final, se acepte por accidente.

4.2. Interpretar errores y depurar

Un traceback es el informe que muestra Python cuando una excepción interrumpe el programa. Para empezar a investigarlo, localiza el tipo de error y la línea señalada. Esa línea indica dónde se detectó el problema, pero el dato o la decisión que lo originó pueden estar antes.

Los errores de sintaxis e indentación suelen deberse a detalles de escritura. Por ejemplo, una sangría inesperada puede señalar la línea donde Python ya no puede interpretar el bloque:

x = 5
    y = 6  # IndentationError: sangría inesperada.

También puede fallar una operación aunque la sintaxis sea válida. Considera el cálculo de la relación señal-ruido en decibelios:

import math

potencia_senal = 0
potencia_ruido = 10
relacion = potencia_senal / potencia_ruido
decibelios = 10 * math.log10(relacion)

El error aparece al llamar a math.log10, porque el logaritmo de 0 no está definido y Python lanza ValueError: math domain error. Hay que revisar los valores de entrada y garantizar que ambas potencias sean positivas antes de calcularlo. Además, en Python 3, 9 / 10 produce 0.9: / no realiza división entera entre dos valores int. Por tanto, no se debe atribuir un resultado cero a una división entera en este ejemplo.

Para depurar, puedes mostrar temporalmente valores intermedios con print, colocar un punto de interrupción en el depurador del IDE, ejecutar el programa paso a paso e inspeccionar variables. Estas herramientas ayudan a averiguar qué condición se ha evaluado y por qué se ha elegido una rama.

5. Buenas prácticas

Al escribir condicionales, conviene aplicar estas pautas:

• Prioriza la claridad: elige nombres descriptivos, añade espacios alrededor de los operadores y utiliza paréntesis si hacen más evidente una condición compleja.
• Ordena los casos con intención: en una cadena if-elif, coloca primero los casos especiales y ordena los rangos para que el primer caso coincidente sea el correcto.
• Reduce el anidamiento innecesario: usa elif o combina condiciones relacionadas; reserva el anidamiento para decisiones que realmente dependan de otra.
• Protege las operaciones de riesgo: comprueba antes de dividir, acceder a una posición o calcular una operación con requisitos de dominio.
• Prueba los límites: comprueba valores justo por debajo, en y por encima de cada frontera, además de los valores especiales como 0.
• Depura con evidencias: inspecciona el tipo de excepción, la línea indicada y los valores que intervienen antes de cambiar el código.

6. Errores frecuentes

Error frecuente	Por qué ocurre	Cómo evitarlo
Usar = en lugar de ==	Se confunde asignar un valor con comparar dos valores.	Usa = para asignar y == para comparar.
Olvidar : o indentar mal el bloque	En Python los dos puntos y la indentación forman parte de la sintaxis.	Comprueba cada cabecera y configura el editor para usar cuatro espacios.
Ordenar mal las condiciones de un if-elif	Se ejecuta la primera condición verdadera y las posteriores ya no se comprueban.	Revisa los rangos en orden y prueba casos frontera.
Usar is para comparar valores	is compara identidad de objetos, no igualdad de contenido.	Usa == para valores; reserva is None para comprobar None.
Colocar una operación insegura antes de su guardián	El cortocircuito solo ayuda si la comprobación se evalúa primero.	Comprueba primero el divisor, el índice o el requisito de la operación.
Suponer que todo error se origina en la línea del traceback	Python señala dónde detectó el problema, que puede deberse a un valor calculado antes.	Inspecciona el estado del programa y los valores intermedios.

7. Resumen

En este tema has aprendido que:

• las comparaciones producen valores lógicos, y and, or y not permiten combinarlos;
• if, else y elif eligen qué bloques se ejecutan, y el orden de evaluación importa;
• el anidamiento permite expresar dependencias, pero conviene evitar niveles innecesarios;
• el cortocircuito puede proteger operaciones y los tracebacks, junto con el depurador, ayudan a localizar errores.

Idea clave

Un condicional correcto expresa con claridad los casos posibles y el orden en que deben comprobarse; después hay que probar sus límites y proteger las operaciones que pueden fallar.

8. Para seguir practicando

• Resuelve los ejercicios de la práctica de sentencias condicionales, empezando por la comprobación de edad, la paridad y la división con divisor cero.
• Prueba tus propias condiciones con valores frontera y casos especiales; comprueba qué rama se ejecuta y si el resultado coincide con lo esperado.
• En el siguiente tema, aplica condicionales dentro de bucles: sentencias iterativas.

Bibliografía y fuentes

• Python para todos: ejecución condicional.
• Código de ejemplo de relación señal-ruido.
• Normativa oficial del título de Desarrollo de Aplicaciones Web.
• Tutorial oficial de Python: control de flujo.
• Referencia oficial de Python: expresiones y comparaciones.
• Juan José Lozano Gómez: j2logo.
• Aprende con Alf.

Presentación

Puedes repasar las estructuras de selección con la presentación de condicionales.