if, elif y else en Python: varios rangos y condiciones anidadas

El elif permite que el programa elija entre tres o más caminos en una sola estructura. Funciona como un "si no, si": Python prueba la primera condición, después la segunda, después la tercera, y ejecuta el bloque de la primera que sea verdadera, ignorando todas las demás. El else del final cubre lo que sobró. Cuando una decisión solo tiene sentido después de otra, el bloque puede contener un if dentro de él, y eso se llama condición anidada.

El artículo anterior presentó el if y el else, que eligen entre dos caminos y plantean la primera cuestión de quien programa: la sangría. Este muestra cómo crecer hacia más caminos sin escribir una pila de if que se atropellan, por qué el orden de las condiciones cambia el resultado, cómo anidar con seguridad y qué problemas aparecen más en las clases.

El problema: dos opciones no bastan

Una escuela convierte la nota de cero a diez en concepto: de 9 hacia arriba, A; de 7 a menos de 9, B; de 6 a menos de 7, C; por debajo de eso, D. Son cuatro caminos, y el if con else solo distingue dos. La tentación es apilar if, uno por concepto, y la sección sobre el orden muestra qué ocurre cuando se hace eso. Por ahora, vale recordar lo que la decisión necesita: una lista de preguntas, en orden, en que la primera respuesta "sí" decide y las demás dejan de importar.

Es exactamente lo que hace el elif. La estructura completa tiene un if al comienzo, tantos elif como hagan falta y, si se quiere, un else al final.

El elif: la escalera de pruebas

for nota in (10, 9, 8.5, 7, 6, 5.99, 0):
    if nota >= 9:
        conceito = "A"
    elif nota >= 7:
        conceito = "B"
    elif nota >= 6:
        conceito = "C"
    else:
        conceito = "D"
    print(nota, conceito)

La salida es 10 A, 9 A, 8.5 B, 7 B, 6 C, 5.99 D y 0 D. El for recorre las notas, una por vez, y el bloque if y elif corre para cada una. Fíjate en los límites: la nota 9 es A, y la nota 7 es B, porque la prueba es >=. La nota 5.99 queda en D, aunque esté a una centésima de la C. Cada condición solo necesita decir el límite de abajo, porque el límite de arriba ya fue tratado por las pruebas anteriores: cuando el programa llega al nota >= 7, ya sabe que la nota es menor que 9, si no la primera prueba habría decidido.

Cada elif tiene la misma anatomía que el if: la palabra, la condición, los dos puntos y el bloque con sangría. El else sigue sin condición y sigue siendo opcional. Se puede tener if con elif y sin else, y en ese caso, si ninguna prueba es verdadera, ningún bloque corre y el programa sigue adelante.

Tres if sueltos no son un if con elif

La confusión más común de quien aprende es creer que escribir tres if en secuencia es lo mismo que escribir if, elif y elif. No lo es. Cada if nuevo es una pregunta independiente, y todas se hacen.

nota = 9.5
if nota >= 9:
    print("A")
if nota >= 7:
    print("B")
if nota >= 6:
    print("C")
print("---")
if nota >= 9:
    print("A")
elif nota >= 7:
    print("B")
elif nota >= 6:
    print("C")
print("---")
if nota >= 6:
    print("C")
elif nota >= 7:
    print("B")
elif nota >= 9:
    print("A")

La salida es A, B, C, una línea de separación, A, otra separación y C. En el primer trozo, la nota 9.5 cumple las tres condiciones, y cada if suelto ejecuta su bloque: el programa responde tres veces. En el segundo, el elif hace lo que se espera, y solo el primer True gana. En el tercero, el orden está invertido: la condición nota >= 6 es verdadera para casi todo, así que captura la nota 9.5 antes de que el nota >= 9 tenga oportunidad, y el concepto A queda inalcanzable. Ninguno de los tres trozos da error. Solo uno da la respuesta correcta.

La regla práctica que resuelve casi todo: escribe las condiciones del caso más restrictivo al menos restrictivo. En la escalera de notas, de 9 hacia abajo. En una escalera de temperaturas crecientes, la lógica se invierte, y la primera condición es la del menor valor:

for t in (12, 18, 25, 26, 31, 40):
    if t < 18:
        print(t, "frío")
    elif t < 26:
        print(t, "agradable")
    elif t < 32:
        print(t, "caluroso")
    else:
        print(t, "muy caluroso")

La salida va de 12 frío a 40 muy caluroso, y los límites quedan en los lugares correctos: 18 es agradable y 26 es caluroso, porque las pruebas son < y el valor igual al límite cae en el rango de arriba. Lo que importa en los dos ejemplos es la misma idea: los rangos se tocan sin huecos y sin superposición, y cada valor cae en exactamente uno de ellos.

Un if nuevo recomienza la conversación

Una cadena if, elif, else termina donde la sangría vuelve al margen con una línea que no es elif ni else. El if que aparece después es otra cadena, sin relación con la anterior.

x = 7
if x > 3:
    print("mayor que 3")
elif x > 5:
    print("mayor que 5")
if x > 5:
    print("mayor que 5 (if nuevo)")
elif x > 100:
    print("enorme")
else:
    print("ninguno de los dos")

La salida es mayor que 3 y mayor que 5 (if nuevo). En la primera cadena, el x > 3 ya decidió y el elif x > 5 ni se miró. La segunda cadena empieza de cero con el if x > 5, y por eso el 7 recibe los dos mensajes. Si la intención era una sola cadena, el segundo if debería ser elif.

Condiciones anidadas

A veces la segunda pregunta solo tiene sentido después de la primera. Para saber si alguien puede manejar, solo se pregunta por la licencia si la persona ya es mayor de edad. Eso se escribe con un if dentro de otro, un nivel de sangría hacia adentro.

idade = 20
tem_carteira = False
if idade >= 18:
    if tem_carteira:
        print("puede manejar")
    else:
        print("necesita sacar la licencia")
else:
    print("menor de edad")
if idade >= 18 and tem_carteira:
    print("puede manejar")
elif idade >= 18:
    print("necesita sacar la licencia")
else:
    print("menor de edad")

Las dos versiones dan la misma salida, necesita sacar la licencia dos veces. La primera anida: la pregunta de la licencia solo ocurre dentro del bloque de los mayores de edad, y cada else queda en la sangría del if al que pertenece. La segunda es plana: usa and y elif. Cuál es mejor depende del problema. Anidar deja más clara la dependencia ("solo pregunto esto si aquello es verdad"), y la versión plana suele quedar más corta cuando las condiciones son del mismo nivel. Más de tres niveles de sangría, en general, es señal de que conviene reorganizar.

¿A qué if pertenece el else?

Con if anidados, la pregunta que más confunde es esa, y la respuesta es siempre la misma: al if que tiene la misma sangría.

a = 5
b = 0
if a > 3:
    if b > 3:
        print("x")
else:
    print("else del externo")
print("---")
if a > 3:
    if b > 3:
        print("x")
    else:
        print("else del interno")
print("fin")

En la primera parte, el else está en el margen, alineado con el if a > 3. Como a > 3 es verdadero, el else del externo no corre, y no se imprime nada, ni siquiera x, porque b > 3 es falso. En la segunda, el else se movió un nivel y pasó a pertenecer al if b > 3: la salida es else del interno y fin. Es el mismo texto con una diferencia de cuatro espacios, y el programa pasa a responder una pregunta distinta.

Qué cambia en la ESP32

La estructura y las reglas del elif son las mismas en MicroPython. Dos puntos piden cuidado en la placa. El primero es la precisión del float, que con 32 bits no separa números muy próximos:

print(5.9999999 >= 6, 5.9999999, 5.99999 >= 6, 5.99999)
nota = 5.9999999
if nota >= 6:
    print("aprobado")
else:
    print("reprobado")

En el simulador, la salida es True 6.0 False 5.99999 y aprobado: el valor 5.9999999 se redondea a 6.0 en el momento en que el programa lo lee, y la comparación con 6 pasa. En el Python del computador, con el float de 64 bits, 5.9999999 >= 6 es False y el programa respondería reprobado. Con notas escritas esto casi no importa, pero un promedio calculado o una lectura de sensor que queda a una fracción del límite puede caer en un rango o en otro según el tipo de float. Cuando una decisión importa de verdad, deja un margen entre los rangos o trabaja con enteros.

El segundo punto es el uso más común del elif en hardware: convertir una lectura en niveles. El conversor analógico de la ESP32 devuelve valores de 0 a 4095, y un sensor de luz puede volverse tres estados:

for valor in (0, 500, 1500, 3000, 4095):
    if valor < 1000:
        nivel = "oscuro"
    elif valor < 2500:
        nivel = "penumbra"
    else:
        nivel = "claro"
    print(valor, nivel)

La salida es 0 oscuro, 500 oscuro, 1500 penumbra, 3000 claro y 4095 claro. Las lecturas reales fluctúan, y cuando una de ellas queda pegada a un límite el estado parpadea entre dos niveles. La solución, con un margen a cada lado, es uno de los temas del artículo sobre ADC y atenuación.

Los mensajes para los errores típicos del elif también difieren:

En el simulador, todos se vuelven el mismo invalid syntax, y lo que ayuda es el número de la línea. El ejemplo clásico de quien viene de C o JavaScript:

x = 5
if x > 9:
    print("a")
else if x > 3:
    print("b")

Traceback (most recent call last):
  File "main.py", line 4
SyntaxError: invalid syntax

Python no tiene else if. La palabra es una sola, elif, y va junto con la condición y los dos puntos.

En el aula: dónde suele tropezar el elif

Los problemas de abajo se repiten en casi todo grupo que llega a este tema. Cada uno da un programa que corre, lo que hace difícil encontrar la causa.

Varios if en lugar de un elif

El programa pide el concepto y responde tres veces para la misma nota, o imprime un "aprobado" y un "reprobado" juntos. La causa es la que muestra la figura de las tres versiones: cada if suelto es una pregunta nueva. La pregunta que hay que hacerse es si las respuestas son mutuamente excluyentes. Si lo son, es un elif.

El orden de los rangos cambiado

El concepto A nunca aparece, porque la prueba nota >= 6 viene antes que el nota >= 9. Es un error que pasa todas las pruebas con notas bajas y solo aparece cuando alguien con nota alta usa el programa. Escribir la lista de rangos en el papel, del más restrictivo al menos restrictivo, antes de teclear, evita el problema.

El límite con el signo equivocado

Con nota > 6 en lugar de nota >= 6, quien sacó exactamente 6 cae en D. Es el tipo de defecto que solo aparece en el valor límite, y la defensa es probar siempre los límites: el propio valor, uno por encima y uno por debajo.

Comparar con varios valores usando or

if conceito == "A" or "B" no compara con A y con B. ¿Recuerdas el x == 1 or 2 del artículo sobre operadores lógicos? El texto "B" solo es siempre verdadero, y la condición pasa para todo concepto. La forma correcta es repetir la variable, conceito == "A" or conceito == "B", o usar in: conceito in ("A", "B").

La pirámide de if

Cinco o seis niveles de if anidado, cada vez más hacia la derecha, con el else al final de la página y ya nadie recordando a qué pregunta responde. Casi siempre se puede aplanar: un and junta dos preguntas del mismo nivel, y un elif reemplaza un anidamiento que solo sirve para elegir entre alternativas.

El else perdido

El else con sangría de más o de menos, y el programa pasa a responder a la pregunta equivocada, como en la figura de las dos versiones. La comprobación es visual: el else y el if al que pertenece empiezan en la misma columna.

Faltó el else final

El programa funciona para todo lo que se previó, y para lo que nadie previó simplemente no hace nada: ningún mensaje, ningún error. En un registro, el usuario escribe una opción que no existe y el programa queda mudo. Un else con un mensaje como "opción inválida" transforma el silencio en una pista.

Ejercicio: ¿qué tipo de triángulo es este?

Dados los tres lados de un triángulo, el programa debe decir si es equilátero (tres lados iguales), isósceles (dos iguales) o escaleno (todos distintos). Pero antes hay que saber si los lados forman un triángulo: cada lado tiene que ser menor que la suma de los otros dos. Es una decisión con dos capas, y ahí es donde el anidamiento ayuda.

for lados in ((3, 3, 3), (3, 3, 5), (3, 4, 5), (1, 2, 10), (2, 2, 4)):
    a, b, c = lados
    if a < b + c and b < a + c and c < a + b:
        if a == b == c:
            print(lados, "equilátero")
        elif a == b or b == c or a == c:
            print(lados, "isósceles")
        else:
            print(lados, "escaleno")
    else:
        print(lados, "no forma triángulo")

La salida tiene cinco líneas: (3, 3, 3) equilátero, (3, 3, 5) isósceles, (3, 4, 5) escaleno, (1, 2, 10) no forma triángulo y (2, 2, 4) no forma triángulo. El último caso merece atención: los lados 2, 2 y 4 tienen dos iguales, pero 4 no es menor que 2 más 2, y un if que solo mirara la igualdad lo llamaría isósceles. La pregunta externa filtra, y la escalera de adentro clasifica. Fíjate en el orden de la escalera interna: el caso equilátero, el más restrictivo, viene primero, porque un equilátero también tiene dos lados iguales y sería capturado por el isósceles si este viniera antes. Para leer los lados del teclado, cambia la primera línea por tres int(input()), como en el artículo sobre conversión de tipos.

Preguntas frecuentes

¿Cuántos elif puedo usar?

Los que necesites. Pero una escalera con más de cinco o seis peldaños suele pedir otra estructura, y el próximo artículo de la serie muestra una alternativa con diccionarios para el caso en que cada peldaño es solo una comparación de igualdad.

¿El else es obligatorio al final?

No, pero es una buena red de protección. Sin él, un valor que no encaja en ningún rango pasa sin hacer nada, y el defecto tarda en aparecer.

¿Cuál es la diferencia entre elif y un nuevo if?

El elif pertenece a la cadena que abrió el if y solo se evalúa si todas las condiciones anteriores son falsas. Un if nuevo abre otra cadena, y se evalúa siempre.

¿Puedo poner un elif dentro de un bloque anidado?

Puedes. Cada if anidado puede tener sus propios elif y else, y quedan en la misma sangría del if al que pertenecen. La sangría es lo que dice quién es quién.

¿Python tiene switch?

No como C o Java. Para elegir entre muchos valores exactos, la salida es la escalera de elif o un diccionario, que el próximo artículo explica.

Para continuar

La ruta Lógica con Python tiene desafíos con varios rangos. El Positivo o negativo pide más de dos respuestas, el Día de la semana y la Estación del año exigen escaleras con límites, y la Calculadora con menú elige la operación a partir de una opción escrita. Si la sangría todavía estorba, relee el artículo sobre if y else, que reúne los errores de indentación más comunes.

El próximo tema es la elección entre muchas opciones: cuando la escalera de elif se vuelve demasiado larga, qué resuelve mejor un diccionario y por qué MicroPython no tiene match y case.