Condicionales en Python: if, elif y else explicados con ejemplos

Hasta ahora los programas que has escrito hacen siempre lo mismo, en el mismo orden, sin importar lo que pase. Eso cambia aquí. Los condicionales son la primera herramienta que da al programa la capacidad de decidir: ejecutar un código u otro dependiendo de si algo es verdad o no. Sin condicionales no hay lógica, solo secuencias de instrucciones.

En Python la sintaxis de los condicionales es deliberadamente minimalista. No hay paréntesis obligatorios alrededor de la condición, no hay llaves para delimitar el bloque. Solo la indentación y dos puntos. Al principio puede desorientar si vienes de otro lenguaje, pero en cuanto lo interiorizas es difícil volver a preferir las llaves.

🔍 El if más simple: actuar solo cuando algo es verdad

Un if evalúa una expresión. Si el resultado es True (o truthy, lo veremos más adelante), ejecuta el bloque indentado debajo. Si es False, lo salta completamente.

edad = 20

if edad >= 18:
    print("Eres mayor de edad.")
    print("Puedes acceder.")

# Si edad fuera 15, las dos líneas anteriores no se ejecutarían

Dos detalles que Python exige: los dos puntos al final de la condición (if edad >= 18:) y la indentación del bloque. Todo lo que quieras que forme parte del if debe estar indentado exactamente 4 espacios más que la línea del if. Si un error te dice IndentationError, busca aquí.

# Esto funciona:
if True:
    print("uno")
    print("dos")
print("tres")   # fuera del if, siempre se ejecuta

# Esto da error:
if True:
print("falta indentación")   # IndentationError

↔️ if y else: el camino de ida y el de vuelta

Cuando necesitas ejecutar algo en ambos casos — si la condición es verdad y también si es falsa — añades un else. El programa siempre entra en uno de los dos bloques, nunca en ninguno, nunca en los dos.

temperatura = 15

if temperatura > 20:
    print("Hace calor, no te abrigues.")
else:
    print("Hace fresco, lleva chaqueta.")

# → Hace fresco, lleva chaqueta.

El else no lleva condición. Es literalmente "en todos los demás casos". Eso significa que si hay algún valor que no quisiste contemplar en el if, caerá en el else.

# Patrón habitual: valor por defecto
nombre = input("Tu nombre (opcional): ").strip()

if nombre:
    saludo = f"Hola, {nombre}!"
else:
    saludo = "Hola, visitante!"

print(saludo)

🔢 elif: cuando hay más de dos posibilidades

elif es la contracción de else if. Se evalúa solo si la condición del if anterior fue falsa. Puedes encadenar tantos elif como necesites. Python entra en el primer bloque cuya condición sea verdadera y se salta el resto.

nota = 75

if nota >= 90:
    calificacion = "Sobresaliente"
elif nota >= 70:
    calificacion = "Notable"
elif nota >= 50:
    calificacion = "Aprobado"
else:
    calificacion = "Suspenso"

print(f"Nota: {nota} → {calificacion}")
# → Nota: 75 → Notable

Observa cómo el orden importa: si nota es 95, entra en el primer if y ya no evalúa los demás aunque también serían verdaderos. Las condiciones se evalúan de arriba a abajo y la primera verdadera gana.

# Orden incorrecto — el resultado sería siempre "Aprobado o más":
if nota >= 50:
    calificacion = "Aprobado"       # ← nota=95 entraría aquí y se quedaría
elif nota >= 70:
    calificacion = "Notable"        # nunca se evalúa
elif nota >= 90:
    calificacion = "Sobresaliente"  # nunca se evalúa

# Siempre ordena de más restrictivo a menos restrictivo (o al revés, consistentemente)

💡 Truthy y falsy: qué evalúa Python como True o False

Python no necesita que la condición de un if sea un booleano literal. Cualquier valor se convierte internamente a bool cuando se evalúa en un contexto de condición. Los valores que se comportan como False se llaman falsy. Todo lo demás es truthy.

# Estos son FALSY — el if no entra con estos valores:
if None: ...       # None
if False: ...      # False
if 0: ...          # Cero entero
if 0.0: ...        # Cero decimal
if "": ...         # String vacío
if []: ...         # Lista vacía
if {}: ...         # Dict vacío
if (): ...         # Tupla vacía
if set(): ...      # Conjunto vacío

# Estos son TRUTHY — el if sí entra:
if 42: ...         # Número no cero (incluye negativos)
if "hola": ...     # String con contenido
if [0]: ...        # Lista con elementos (aunque el elemento sea 0)
if {"a": 1}: ...   # Dict con pares
if True: ...       # True literal

Esto permite un estilo de código muy limpio. En lugar de comparar explícitamente, aprovechas la evaluación implícita:

# Forma explícita (funciona pero es redundante):
if len(lista) > 0:
    print("La lista tiene elementos")
if nombre != "":
    print("Nombre introducido")
if numero != 0:
    print("Número no nulo")

# Forma idiomática Python (más natural):
if lista:
    print("La lista tiene elementos")
if nombre:
    print("Nombre introducido")
if numero:
    print("Número no nulo")

🔬 Operadores de comparación y lógicos en condiciones

Ya los vimos en la lección de operadores, pero en el contexto de los condicionales tienen protagonismo especial.

# Comparación:
x == y      # igual en valor
x != y      # distinto
x > y       # mayor
x >= y      # mayor o igual
x < y       # menor
x <= y      # menor o igual
x is y      # mismo objeto en memoria
x is not y  # distinto objeto

# Lógicos para combinar condiciones:
if edad >= 18 and tiene_dni:
    print("Puede votar")

if es_admin or es_superusuario:
    print("Acceso total")

if not esta_bloqueado:
    print("Cuenta activa")

# Encadenamiento de comparaciones (exclusivo de Python):
if 0 <= nota <= 100:
    print("Nota válida")

if 18 <= edad <= 65:
    print("En edad laboral")

El encadenamiento 0 <= nota <= 100 es Python puro: en otros lenguajes hay que escribirlo como dos condiciones con and. Es más legible y matemáticamente intuitivo.

# Uso correcto de is / ==
x = None
if x is None:          # ✅ correcto para comparar con None
    print("No hay valor")

a = 1000
b = 1000
print(a == b)          # True  — mismo valor
print(a is b)          # False — distintos objetos (fuera del rango -5..256)

# is solo para None, True, False (singletons de Python)

⚡ El operador ternario: if en una línea

Python tiene una forma compacta de escribir un if/else cuando solo queremos asignar un valor:

# Sintaxis: valor_si_true if condición else valor_si_false

# Forma normal (4 líneas):
if n % 2 == 0:
    tipo = "par"
else:
    tipo = "impar"

# Forma ternaria (1 línea):
tipo = "par" if n % 2 == 0 else "impar"

# Más ejemplos:
estado = "activo" if usuario.activo else "inactivo"
precio_final = precio * 0.9 if es_socio else precio
abs_valor = n if n >= 0 else -n

El ternario es elegante cuando la condición y ambos valores caben cómodamente en una línea. Cuando la expresión se alarga, el if/else normal es siempre más legible. No fuerces el ternario solo para presumir de compacidad.

# Esto ya es demasiado para una línea — mejor en 4 líneas:
resultado = procesar_datos_complejos(entrada) if entrada is not None and len(entrada) > 0 and entrada.es_valida() else obtener_valor_por_defecto()

🪆 Condicionales anidados y cómo evitarlos

Un condicional anidado es un if dentro de otro if. Es perfectamente válido, pero más de dos niveles empieza a dificultar la lectura. Hay varias técnicas para aplanar la estructura.

# Anidado (funciona pero se complica rápido):
if tiene_cuenta:
    if saldo > 0:
        if not esta_bloqueado:
            print("Transacción permitida")
        else:
            print("Cuenta bloqueada")
    else:
        print("Saldo insuficiente")
else:
    print("Sin cuenta")

# Más plano con and (para el caso happy path):
if tiene_cuenta and saldo > 0 and not esta_bloqueado:
    print("Transacción permitida")

# Técnica 'guard clause' — salir antes si algo falla:
def procesar_transaccion(cuenta, cantidad):
    if not cuenta:
        return "Sin cuenta"
    if cuenta.saldo <= 0:
        return "Saldo insuficiente"
    if cuenta.bloqueada:
        return "Cuenta bloqueada"
    # Aquí sabemos que todo está bien
    cuenta.saldo -= cantidad
    return "OK"

🃏 match/case: el switch de Python 3.10+

Python 3.10 introdujo match/case, que permite comparar un valor contra varios patrones de forma mucho más expresiva que una cadena de elif.

# Con if/elif (Python clásico):
comando = "salir"
if comando == "iniciar":
    accion = "Iniciando..."
elif comando == "pausar":
    accion = "Pausando..."
elif comando == "salir":
    accion = "Cerrando..."
else:
    accion = f"Comando desconocido: {comando}"

# Con match/case (Python 3.10+):
match comando:
    case "iniciar":
        accion = "Iniciando..."
    case "pausar":
        accion = "Pausando..."
    case "salir":
        accion = "Cerrando..."
    case _:
        accion = f"Comando desconocido: {comando}"
# El _ es el comodín, equivale al else

match/case va mucho más allá del simple valor literal: puede hacer desestructuración de listas, tuplas y clases, lo que lo hace especialmente potente. Pero eso ya es materia avanzada.

# Múltiples valores en un mismo case:
match codigo_http:
    case 200 | 201 | 204:
        print("Éxito")
    case 400 | 422:
        print("Error del cliente")
    case 500 | 503:
        print("Error del servidor")
    case _:
        print("Código no manejado")

🛠️ Programa completo: clasificador de notas con historial

def calificar(nota):
    """Devuelve la calificación textual para una nota de 0 a 10."""
    if not (0 <= nota <= 10):
        return "Nota fuera de rango"
    elif nota >= 9:
        return "Sobresaliente"
    elif nota >= 7:
        return "Notable"
    elif nota >= 5:
        return "Aprobado"
    else:
        return "Suspenso"

def pedir_nota(asignatura):
    """Pide una nota al usuario con validación robusta."""
    while True:
        try:
            n = float(input(f"  Nota de {asignatura}: "))
            if 0 <= n <= 10:
                return n
            print("  La nota debe estar entre 0 y 10.")
        except ValueError:
            print("  Introduce un número válido.")

# Programa principal
asignaturas = ["Matemáticas", "Lengua", "Historia"]
resultados = {}

print("=== CALCULADORA DE NOTAS ===\n")

for asignatura in asignaturas:
    nota = pedir_nota(asignatura)
    cal = calificar(nota)
    resultados[asignatura] = (nota, cal)
    estado = "✅" if nota >= 5 else "❌"
    print(f"  → {cal} {estado}\n")

# Resumen
print("=" * 35)
print("RESUMEN FINAL")
print("=" * 35)

total = 0
aprobadas = 0
for asig, (nota, cal) in resultados.items():
    total += nota
    if nota >= 5:
        aprobadas += 1
    print(f"  {asig:<15} {nota:>4.1f}  {cal}")

media = total / len(asignaturas)
print(f"\n  Media: {media:.2f}")
print(f"  Aprobadas: {aprobadas}/{len(asignaturas)}")

if aprobadas == len(asignaturas):
    print("\n  🎉 ¡Todas aprobadas!")
elif aprobadas == 0:
    print("\n  😞 Todas suspensas. Ánimo.")
else:
    pendientes = len(asignaturas) - aprobadas
    print(f"\n  Tienes {pendientes} asignatura(s) pendiente(s).")

🐛 Errores clásicos con condicionales

1. Usar = en lugar de == (asignación en vez de comparación)

x = 5
if x = 10:          # SyntaxError — el = es asignación
    print("Es 10")

if x == 10:         # ✅ == compara
    print("Es 10")

2. Error de indentación

if True:
print("hola")       # IndentationError — falta indentación

if True:
    print("hola")   # ✅

3. Olvidar los dos puntos

if x > 0            # SyntaxError — faltan los dos puntos
    print(x)

if x > 0:           # ✅
    print(x)

4. Confundir and/or con &&/||

if x > 0 && y > 0:   # SyntaxError — Python no usa &&
    ...

if x > 0 and y > 0:  # ✅
    ...

5. El elif nunca alcanzado por orden incorrecto

nota = 95

if nota >= 50:          # Entra aquí para cualquier nota >= 50
    print("Aprobado")
elif nota >= 90:        # Nunca llega — ya entró en el if anterior
    print("Sobresaliente")

✅ Resumen y próximos pasos

El if evalúa una condición y ejecuta el bloque si es verdadera. El elif añade ramas alternativas. El else captura todo lo que no cumplió ninguna condición anterior. Python evalúa cualquier valor como truthy o falsy automáticamente. El operador ternario condensa un if/else de asignación en una línea. Y el match/case de Python 3.10+ ofrece una alternativa más expresiva para múltiples valores concretos.

La siguiente lección: los bucles while y for. Con bucles y condicionales ya puedes escribir prácticamente cualquier algoritmo básico.

❓ Preguntas frecuentes