if, elif y else en Python: Guía de Condicionales 2025 [+Ejemplos]

¿Qué son las estructuras condicionales en Python?

Las estructuras condicionales son el mecanismo que permite a tus programas tomar decisiones. Sin ellas, tu código solo podría ejecutarse de forma lineal, una instrucción tras otra, sin capacidad de adaptarse a diferentes situaciones.

Imagina que estás programando un sistema de login. Necesitas verificar si la contraseña es correcta o incorrecta, y ejecutar código diferente según el resultado. Ahí es donde entran las condicionales: te permiten crear bifurcaciones en el flujo de ejecución de tu programa.

Python ofrece tres palabras clave principales para construir condicionales:

• if – ejecuta código si una condición es verdadera
• elif – (else if) evalúa una condición alternativa si la anterior fue falsa
• else – ejecuta código si ninguna condición anterior fue verdadera

Las estructuras condicionales son fundamentales en cualquier programa Python que escribas, desde scripts simples hasta aplicaciones complejas. Dominarlas es esencial para convertirte en un pythonista competente.

La sentencia if en Python

La sentencia if es la estructura condicional más básica. Evalúa una expresión y, si el resultado es True, ejecuta el bloque de código indentado que le sigue.

Sintaxis básica

if condicion:
    # código que se ejecuta si la condición es True
    instruccion1
    instruccion2

Puntos clave sobre la sintaxis:

• La condición debe ir seguida de dos puntos :
• El bloque de código debe estar indentado (4 espacios según PEP 8)
• La indentación define qué código pertenece al if
• Sin indentación correcta, Python lanzará un IndentationError

Ejemplo básico – Verificación de contraseña

Vamos a crear un sistema simple de verificación de contraseña:

>>> password = "python123"
>>> user_input = "python123"
>>> if user_input == password:
...     print("Acceso concedido")
...     print("Bienvenido al sistema")
Acceso concedido
Bienvenido al sistema

Si la contraseña no coincide, el bloque simplemente no se ejecuta:

>>> password = "python123"
>>> user_input = "wrong_password"
>>> if user_input == password:
...     print("Acceso concedido")
>>> # No se imprime nada

if con operadores de comparación

Las condicionales suelen usar los operadores de comparación que vimos en el artículo anterior:

>>> age = 18
>>> if age >= 18:
...     print("Eres mayor de edad")
Eres mayor de edad
>>> 
>>> score = 85
>>> if score > 60:
...     print("Has aprobado el examen")
Has aprobado el examen

Caso real – Validación de datos de usuario

Imaginemos que estamos desarrollando un formulario de registro y necesitamos validar que el username tenga la longitud correcta:

>>> username = "john_doe"
>>> min_length = 5
>>> max_length = 20
>>> 
>>> if len(username) >= min_length:
...     print(f"Username '{username}' es válido")
...     print("Procediendo con el registro...")
Username 'john_doe' es válido
Procediendo con el registro...

Nota importante: El bloque if puede contener cualquier cantidad de instrucciones, siempre que mantengan la misma indentación.

if-else en Python

La estructura if-else te permite definir dos caminos: uno si la condición es verdadera y otro si es falsa. Es la bifurcación más simple del flujo de ejecución.

Sintaxis

if condicion:
    # código si la condición es True
    instruccion1
else:
    # código si la condición es False
    instruccion2

Ejemplo básico – Par o impar

Vamos a determinar si un número es par o impar:

>>> number = 42
>>> if number % 2 == 0:
...     print(f"{number} es par")
... else:
...     print(f"{number} es impar")
42 es par
>>> 
>>> number = 17
>>> if number % 2 == 0:
...     print(f"{number} es par")
... else:
...     print(f"{number} es impar")
17 es impar

Bloques de código indentados

Cada rama del if-else puede contener múltiples instrucciones:

>>> temperature = 28
>>> if temperature > 25:
...     print("Hace calor")
...     print("Recomendación: usa ropa ligera")
...     recommendation = "protector solar"
... else:
...     print("Temperatura agradable")
...     print("Recomendación: ropa normal")
...     recommendation = "chaqueta ligera"
Hace calor
Recomendación: usa ropa ligera
>>> recommendation
'protector solar'

Caso real – Sistema de descuentos

Supongamos que estamos construyendo un e-commerce donde aplicamos descuento a miembros premium:

>>> total_purchase = 150.00
>>> is_premium_member = True
>>> 
>>> if is_premium_member:
...     discount = total_purchase * 0.15
...     final_price = total_purchase - discount
...     print(f"Descuento aplicado: ${discount:.2f}")
...     print(f"Total a pagar: ${final_price:.2f}")
... else:
...     final_price = total_purchase
...     print("Sin descuento disponible")
...     print(f"Total a pagar: ${final_price:.2f}")
Descuento aplicado: $22.50
Total a pagar: $127.50

Consejo: Usa nombres de variables descriptivos en las condiciones. is_premium_member es mucho más claro que algo como flag o status.

if-elif-else: múltiples condiciones

Cuando necesitas evaluar más de dos posibilidades, la estructura if-elif-else te permite crear una cascada de condiciones que se evalúan en orden.

Sintaxis

if condicion1:
    # código si condicion1 es True
elif condicion2:
    # código si condicion1 es False y condicion2 es True
elif condicion3:
    # código si condicion1 y condicion2 son False y condicion3 es True
else:
    # código si todas las condiciones anteriores son False

Importante: Python evalúa las condiciones en orden. Cuando encuentra una condición verdadera, ejecuta ese bloque y sale de toda la estructura sin evaluar el resto.

Ejemplo básico – Calculadora de notas

Vamos a crear un sistema que asigna calificaciones según la puntuación:

>>> score = 85
>>> if score >= 90:
...     grade = "A"
...     print("Excelente")
... elif score >= 80:
...     grade = "B"
...     print("Notable")
... elif score >= 70:
...     grade = "C"
...     print("Bien")
... elif score >= 60:
...     grade = "D"
...     print("Suficiente")
... else:
...     grade = "F"
...     print("Insuficiente")
Notable
>>> grade
'B'

Diferencia con múltiples if

Es crucial entender la diferencia entre elif y múltiples if separados:

>>> # Con elif (solo se ejecuta UNO)
>>> score = 85
>>> if score >= 80:
...     print("Aprobado con buena nota")
... elif score >= 60:
...     print("Aprobado")  # Esto NO se ejecuta
Aprobado con buena nota
>>> 
>>> # Con múltiples if (se evalúan TODOS)
>>> score = 85
>>> if score >= 80:
...     print("Aprobado con buena nota")
... # Segunda condición INDEPENDIENTE
>>> if score >= 60:
...     print("Aprobado")  # Esto SÍ se ejecuta
Aprobado con buena nota
Aprobado

Caso real – Sistema de envío con múltiples zonas

Imaginemos que estamos calculando el costo de envío según el país de destino:

>>> country = "Spain"
>>> order_total = 150.00
>>> 
>>> if country == "Spain":
...     shipping_cost = 5.00
...     delivery_days = 2
...     print(f"Envío nacional: €{shipping_cost}")
... elif country in ["Portugal", "France", "Italy"]:
...     shipping_cost = 12.00
...     delivery_days = 5
...     print(f"Envío Europa cercana: €{shipping_cost}")
... elif country in ["Germany", "UK", "Netherlands"]:
...     shipping_cost = 15.00
...     delivery_days = 7
...     print(f"Envío Europa: €{shipping_cost}")
... else:
...     shipping_cost = 25.00
...     delivery_days = 14
...     print(f"Envío internacional: €{shipping_cost}")
Envío nacional: €5.00
>>> 
>>> final_total = order_total + shipping_cost
>>> print(f"Total con envío: €{final_total}")
>>> print(f"Entrega estimada: {delivery_days} días")
Total con envío: €155.00
Entrega estimada: 2 días

Caso avanzado – Sistema de autenticación con roles

Vamos a construir un sistema más complejo que verifica credenciales y roles de usuario:

>>> username = "admin"
>>> password = "secure123"
>>> role = "administrator"
>>> 
>>> correct_password = "secure123"
>>> 
>>> if password != correct_password:
...     print("ERROR: Contraseña incorrecta")
...     access_granted = False
... elif role == "administrator":
...     print("Acceso total concedido")
...     print("Panel de administración cargado")
...     access_granted = True
...     permissions = ["read", "write", "delete", "admin"]
... elif role == "moderator":
...     print("Acceso de moderador concedido")
...     print("Panel de moderación cargado")
...     access_granted = True
...     permissions = ["read", "write", "moderate"]
... elif role == "user":
...     print("Acceso de usuario concedido")
...     print("Panel de usuario cargado")
...     access_granted = True
...     permissions = ["read"]
... else:
...     print("ERROR: Rol no reconocido")
...     access_granted = False
...     permissions = []
Acceso total concedido
Panel de administración cargado
>>> 
>>> print(f"Permisos: {permissions}")
Permisos: ['read', 'write', 'delete', 'admin']

Tip Pro: Ordena las condiciones de más específica a más general. Si una condición amplia va primero, las siguientes nunca se evaluarán.

Condicionales anidados en Python

Las condicionales anidadas son estructuras if dentro de otras estructuras if. Aunque son potentes, pueden hacer el código difícil de leer si se anidan demasiado.

Sintaxis básica

if condicion1:
    if condicion2:
        # código si ambas condiciones son True
    else:
        # código si condicion1 es True pero condicion2 es False
else:
    # código si condicion1 es False

Ejemplo básico – Sistema de acceso con doble verificación

>>> is_authenticated = True
>>> has_permission = True
>>> 
>>> if is_authenticated:
...     print("Usuario autenticado")
...     if has_permission:
...         print("Permiso concedido")
...         print("Accediendo al recurso...")
...     else:
...         print("Permiso denegado")
... else:
...     print("Debe iniciar sesión primero")
Usuario autenticado
Permiso concedido
Accediendo al recurso...

Caso real – Validación de formulario con múltiples campos

Vamos a validar un formulario de registro paso a paso:

>>> email = "user@example.com"
>>> password = "SecurePass123!"
>>> age = 25
>>> terms_accepted = True
>>> 
>>> # Validación anidada
>>> if "@" in email and "." in email:
...     print("✓ Email válido")
...     if len(password) >= 8:
...         print("✓ Contraseña suficientemente larga")
...         if age >= 18:
...             print("✓ Edad válida")
...             if terms_accepted:
...                 print("✓ Términos aceptados")
...                 print("--- Registro completado exitosamente ---")
...                 registration_complete = True
...             else:
...                 print("✗ Debe aceptar los términos")
...                 registration_complete = False
...         else:
...             print("✗ Debe ser mayor de 18 años")
...             registration_complete = False
...     else:
...         print("✗ Contraseña muy corta (mínimo 8 caracteres)")
...         registration_complete = False
... else:
...     print("✗ Email inválido")
...     registration_complete = False
✓ Email válido
✓ Contraseña suficientemente larga
✓ Edad válida
✓ Términos aceptados
--- Registro completado exitosamente ---

Cuándo evitar anidamiento excesivo

Si tu código tiene más de 2-3 niveles de anidamiento, considera refactorizarlo. El ejemplo anterior podría mejorarse usando operadores lógicos:

>>> email = "user@example.com"
>>> password = "SecurePass123!"
>>> age = 25
>>> terms_accepted = True
>>> 
>>> # Versión mejorada con operadores lógicos
>>> email_valid = "@" in email and "." in email
>>> password_valid = len(password) >= 8
>>> age_valid = age >= 18
>>> 
>>> if email_valid and password_valid and age_valid and terms_accepted:
...     print("Registro completado exitosamente")
...     registration_complete = True
... else:
...     print("ERROR: Formulario inválido")
...     if not email_valid:
...         print("- Email inválido")
...     if not password_valid:
...         print("- Contraseña muy corta")
...     if not age_valid:
...         print("- Edad insuficiente")
...     if not terms_accepted:
...         print("- Términos no aceptados")
...     registration_complete = False
Registro completado exitosamente

Consejo profesional: Si encuentras que necesitas más de 3 niveles de indentación, es momento de extraer lógica a funciones separadas o usar operadores lógicos para simplificar.

Operador ternario vs if-else

El operador ternario es una forma compacta de escribir una sentencia if-else simple en una sola línea. Es útil para asignaciones condicionales rápidas.

Sintaxis

valor_si_true if condicion else valor_si_false

Cuándo usar cada uno

Usa el operador ternario cuando:

• La asignación es simple y directa
• Solo hay dos posibles valores
• Mejora la legibilidad (es obvio qué hace)

Usa if-else tradicional cuando:

• Necesitas ejecutar múltiples instrucciones
• La lógica es compleja
• Hay más de dos posibilidades

Comparación directa

>>> # Versión con if-else tradicional
>>> age = 20
>>> if age >= 18:
...     status = "adult"
... else:
...     status = "minor"
>>> status
'adult'
>>> 
>>> # Versión con operador ternario
>>> age = 20
>>> status = "adult" if age >= 18 else "minor"
>>> status
'adult'

Ejemplo práctico – Aplicar descuento condicional

>>> quantity = 15
>>> unit_price = 50.00
>>> 
>>> # Descuento del 10% si compra más de 10 unidades
>>> discount_rate = 0.10 if quantity > 10 else 0.00
>>> final_price = unit_price * quantity * (1 - discount_rate)
>>> 
>>> print(f"Cantidad: {quantity}")
>>> print(f"Precio unitario: ${unit_price}")
>>> print(f"Descuento: {discount_rate * 100}%")
>>> print(f"Total: ${final_price:.2f}")
Cantidad: 15
Precio unitario: $50.0
Descuento: 10.0%
Total: $675.00

Llevando las condicionales al siguiente nivel

En el libro Python a fondo encontrarás patrones avanzados de condicionales, casos de uso complejos y mejores prácticas para escribir código decisional limpio y mantenible.

Ver el libro

Alternativas a if-elif-else: diccionarios como switch

Python tradicionalmente no tenía una sentencia switch (como C, Java o JavaScript), pero se puede simular usando diccionarios. Esta técnica es especialmente útil cuando tienes muchas condiciones que verifican el mismo valor.

Patrón con diccionarios

>>> # En lugar de múltiples elif...
>>> def get_day_name(day_number):
...     if day_number == 1:
...         return "Lunes"
...     elif day_number == 2:
...         return "Martes"
...     elif day_number == 3:
...         return "Miércoles"
...     # ... etc
>>> 
>>> # Usa un diccionario
>>> day_names = {
...     1: "Lunes",
...     2: "Martes",
...     3: "Miércoles",
...     4: "Jueves",
...     5: "Viernes",
...     6: "Sábado",
...     7: "Domingo"
... }
>>> day_number = 3
>>> day_name = day_names.get(day_number, "Día inválido")
>>> day_name
'Miércoles'

Caso real – Menú de opciones con dict

Imaginemos que estamos construyendo un menú de consola para una aplicación:

>>> def option_new():
...     return "Creando nuevo documento..."
>>> 
>>> def option_open():
...     return "Abriendo documento existente..."
>>> 
>>> def option_save():
...     return "Guardando documento..."
>>> 
>>> def option_exit():
...     return "Cerrando aplicación..."
>>> 
>>> # Diccionario que mapea opciones a funciones
>>> menu_options = {
...     '1': option_new,
...     '2': option_open,
...     '3': option_save,
...     '4': option_exit
... }
>>> 
>>> user_choice = '2'
>>> action = menu_options.get(user_choice)
>>> if action:
...     result = action()
...     print(result)
... else:
...     print("Opción inválida")
Abriendo documento existente...

Ventajas del patrón diccionario

1. Más legible cuando hay muchas opciones
2. Más fácil de mantener (añadir/quitar opciones)
3. Más eficiente para muchas condiciones (O(1) vs O(n))
4. Extensible dinámicamente en tiempo de ejecución

Diccionario con valores calculados

>>> # Calculadora simple
>>> operations = {
...     '+': lambda x, y: x + y,
...     '-': lambda x, y: x - y,
...     '*': lambda x, y: x * y,
...     '/': lambda x, y: x / y if y != 0 else "Error: división por cero"
... }
>>> 
>>> num1 = 10
>>> num2 = 3
>>> operator = '*'
>>> 
>>> if operator in operations:
...     result = operations[operator](num1, num2)
...     print(f"{num1} {operator} {num2} = {result}")
... else:
...     print("Operador no válido")
10 * 3 = 30

Match-case en Python 3.10+: el verdadero switch

A partir de Python 3.10, el lenguaje finalmente incluye una sentencia de coincidencia de patrones (pattern matching) similar al switch de otros lenguajes, pero mucho más potente.

Sintaxis básica

match variable:
    case valor1:
        # código si variable == valor1
    case valor2:
        # código si variable == valor2
    case _:
        # caso por defecto (como else)

Ejemplo básico – Clasificador de códigos HTTP

>>> status_code = 404
>>> match status_code:
...     case 200:
...         message = "OK - Solicitud exitosa"
...     case 201:
...         message = "Created - Recurso creado"
...     case 400:
...         message = "Bad Request - Solicitud incorrecta"
...     case 401:
...         message = "Unauthorized - No autorizado"
...     case 404:
...         message = "Not Found - Recurso no encontrado"
...     case 500:
...         message = "Internal Server Error - Error del servidor"
...     case _:
...         message = f"Código de estado: {status_code}"
>>> 
>>> print(message)
Not Found - Recurso no encontrado

Diferencias con switch de otros lenguajes

A diferencia del switch tradicional:

1. No hay fall-through – no necesitas break
2. Pattern matching – puedes hacer coincidencias complejas
3. Puede hacer destructuring – extraer valores de estructuras

Caso real – Procesador de comandos

>>> command = "create user john"
>>> parts = command.split()
>>> 
>>> match parts:
...     case ["create", "user", username]:
...         print(f"Creando usuario: {username}")
...         result = f"Usuario {username} creado exitosamente"
...     case ["delete", "user", username]:
...         print(f"Eliminando usuario: {username}")
...         result = f"Usuario {username} eliminado"
...     case ["list", "users"]:
...         print("Listando usuarios...")
...         result = "Usuarios: admin, john, jane"
...     case ["help"]:
...         result = "Comandos disponibles: create, delete, list, help"
...     case _:
...         result = "Comando no reconocido"
>>> 
>>> print(result)
Creando usuario: john
Usuario john creado exitosamente

Patrones avanzados con match-case

El pattern matching de Python puede hacer cosas muy sofisticadas:

>>> # Matching con tipos y condiciones
>>> data = {"type": "user", "name": "John", "age": 30}
>>> 
>>> match data:
...     case {"type": "user", "name": name, "age": age} if age >= 18:
...         print(f"Usuario adulto: {name}, {age} años")
...     case {"type": "user", "name": name, "age": age}:
...         print(f"Usuario menor: {name}, {age} años")
...     case {"type": "admin"}:
...         print("Administrador detectado")
...     case _:
...         print("Tipo de dato no reconocido")
Usuario adulto: John, 30 años

Wildcard pattern con _

El guion bajo _ actúa como el caso por defecto, similar al else en if-elif-else:

>>> def get_http_method_description(method):
...     match method:
...         case "GET":
...             return "Obtener recurso"
...         case "POST":
...             return "Crear recurso"
...         case "PUT":
...             return "Actualizar recurso completo"
...         case "PATCH":
...             return "Actualizar recurso parcialmente"
...         case "DELETE":
...             return "Eliminar recurso"
...         case _:
...             return "Método HTTP desconocido"
>>> 
>>> get_http_method_description("POST")
'Crear recurso'
>>> get_http_method_description("OPTIONS")
'Método HTTP desconocido'

¿Cuándo usar cada alternativa?

Elegir entre if-elif-else, diccionarios o match-case depende del contexto:

Usa if-elif-else cuando:

• Las condiciones son expresiones complejas o diferentes
• Necesitas evaluar rangos o múltiples variables
• Estás haciendo comparaciones no exactas (>, <, >=, etc.)
• Tu código debe ser compatible con Python < 3.10

Ejemplo:

if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"

Usa diccionarios cuando:

• Estás mapeando valores específicos a resultados
• La tabla de mapeo puede cambiar dinámicamente
• Tienes muchas opciones simples (>5-6)
• Necesitas eficiencia para muchas opciones

Ejemplo:

status_messages = {
    200: "OK",
    404: "Not Found",
    500: "Server Error"
}

Usa match-case cuando:

• Usas Python 3.10 o superior
• Necesitas pattern matching complejo
• Quieres destructuring de estructuras de datos
• El código es más legible que if-elif-else

Ejemplo:

match response:
    case {"status": 200, "data": data}:
        process_data(data)

Tabla comparativa

Errores comunes en condicionales

Error 1: Olvidar los dos puntos

# Incorrecto
>>> if age >= 18
...     print("Mayor de edad")
  File "<stdin>", line 1
    if age >= 18
                ^
SyntaxError: invalid syntax

# Correcto
>>> if age >= 18:
...     print("Mayor de edad")

Error 2: Problemas de indentación

# Incorrecto
>>> if temperature > 30:
... print("Hace calor")
  File "<stdin>", line 2
    print("Hace calor")
    ^
IndentationError: expected an indented block

# Correcto
>>> if temperature > 30:
...     print("Hace calor")

Error 3: Comparación vs asignación

# Incorrecto (asignación en lugar de comparación)
>>> if score = 100:
...     print("Perfecto")
  File "<stdin>", line 1
    if score = 100:
             ^
SyntaxError: invalid syntax

# Correcto
>>> if score == 100:
...     print("Perfecto")

Error 4: Usar elif sin if previo

# Incorrecto
>>> elif age >= 18:
...     print("Adulto")
  File "<stdin>", line 1
    elif age >= 18:
    ^^^^
SyntaxError: invalid syntax

# Correcto
>>> if age < 13:
...     print("Niño")
... elif age >= 18:
...     print("Adulto")

Error 5: Condiciones siempre verdaderas

# Incorrecto (siempre True)
>>> if username:  # Esto es True si username no está vacío
...     print("Usuario válido")

# Puede que quisieras:
>>> if username and len(username) >= 3:
...     print("Usuario válido")

Error 6: Orden incorrecto de condiciones

# Incorrecto (la primera condición captura todo)
>>> score = 85
>>> if score >= 0:  # Esto siempre será True para valores válidos
...     print("Insuficiente")
... elif score >= 60:
...     print("Aprobado")  # Nunca se ejecuta
Insuficiente

# Correcto (de más específico a más general)
>>> if score >= 90:
...     print("Excelente")
... elif score >= 60:
...     print("Aprobado")
... elif score >= 0:
...     print("Insuficiente")

Puntos clave para recordar

Las estructuras condicionales son el corazón de la toma de decisiones en Python. Dominarlas te permite crear programas que se adaptan y responden a diferentes situaciones.

Pepitas de conocimiento

1. Los dos puntos son obligatorios – Toda sentencia if, elif o else debe terminar con :
2. La indentación define el alcance – Python usa espacios (4 según PEP 8) para agrupar código
3. elif evalúa en orden – Se detiene en la primera condición verdadera
4. else es opcional – Solo úsalo cuando necesites manejar todos los demás casos
5. Evita anidamiento excesivo – Más de 2-3 niveles indica que deberías refactorizar
6. match-case requiere Python 3.10+ – Para versiones anteriores, usa if-elif-else o diccionarios
7. Diccionarios para mapeos simples – Son más eficientes y legibles que largas cadenas de elif
8. Usa el operador ternario con moderación – Solo para asignaciones simples y obvias
9. Condiciones de más específica a más general – Evita que condiciones amplias capturen casos específicos
10. El guion bajo _ en match-case – Es el caso por defecto, equivalente a else

Próximos pasos

Ahora que dominas las condicionales, es momento de aprender a repetir código de forma eficiente con bucles. En el siguiente artículo descubrirás cómo automatizar tareas repetitivas con bucles for.

Siguiente paso: Domina los bucles en Python

Ya sabes tomar decisiones con if-elif-else. Ahora aprende a repetir código eficientemente:

Bucles for y while en Python – Guía completa

¿Te ha gustado este artículo? Compártelo con otros pythonistas que estén aprendiendo a programar.

Déjanos un comentario con tus dudas sobre condicionales o comparte casos de uso interesantes que hayas implementado.

Para profundizar más con patrones avanzados de condicionales, mejores prácticas y proyectos reales, no te pierdas Python a fondo.