Bucles y condiciones en Python: for, while, range, enumerate, break, if/elif y match/case

Los bucles en Python sirven para repetir una acción: recorrer una lista de la compra, procesar cada línea de un archivo o pedir al usuario un número válido hasta que lo introduzca bien. El lenguaje tiene dos bucles, for y while, y para tomar decisiones dentro de ellos se usan las condiciones if/elif/else y el operador match/case. A continuación repasamos cada herramienta con ejemplos prácticos.

Condiciones: if, elif, else

La sentencia condicional ejecuta un bloque de código solo si la expresión es verdadera. El bloque se marca con una sangría de 4 espacios: en Python no hay llaves, y una sangría incorrecta produce de inmediato un error IndentationError.

gastado = 4200
limite = 5000

if gastado > limite:
    print("Se ha superado el límite")
elif gastado > limite * 0.8:
    print("Queda menos del 20 % del presupuesto")
else:
    print("Todo en orden")

Las ramas elif se comprueban de arriba abajo y solo se ejecuta la primera que se cumple. Por eso las condiciones más estrictas deben ir primero: si la comprobación gastado > limite * 0.8 estuviera al principio, el mensaje de superación del límite nunca aparecería.

Qué se considera verdadero

En una condición no es obligatorio escribir una comparación. Se consideran falsos False, None, el cero (0, 0.0) y las colecciones vacías: "", [], {}. Todo lo demás es verdadero. Por eso, la comprobación «la lista no está vacía» se escribe de forma breve:

gastos = []
if not gastos:
    print("Todavía no hay gastos")

Las condiciones se combinan con and, or y not, y un rango se comprueba cómodamente con una cadena de comparaciones: if 0 < importe <= 100_000:. Para elegir un valor de forma breve existe el operador ternario: estado = "mucho" if gastado > limite else "normal".

El bucle for en Python: sintaxis y ejemplos

El bucle for de Python no es un contador como en C, sino un recorrido por los elementos. Toma uno a uno cada elemento de un objeto iterable: una lista, una cadena, un diccionario, un archivo o un rango. Es el equivalente del foreach de otros lenguajes.

gastos = [350, 1200, 89, 4500]
total = 0
for importe in gastos:
    total += importe
print(total)  # 6139

La sintaxis del bucle for es for variable in coleccion:, seguido de un bloque con sangría. Tras el bucle, la variable conserva el último valor; a veces resulta útil, pero no conviene depender de ello en programas grandes.

Recorrer una cadena, una lista o un diccionario

Una cadena se recorre carácter a carácter y una lista, elemento a elemento. El bucle sobre un diccionario recorre por defecto las claves; para obtener a la vez la clave y el valor, use .items():

por_categoria = {"comida": 3200, "transporte": 900, "cine": 600}

for categoria, importe in por_categoria.items():
    print(f"{categoria}: {importe} €")

Para recorrer solo los valores existe .values(). No se puede cambiar el tamaño de un diccionario mientras se recorre: se obtendrá RuntimeError: dictionary changed size during iteration. Si hay que eliminar elementos, recorra una copia: for clave in list(d):.

La función range: bucles con números

Cuando hace falta recorrer números, se usa range(). No crea una lista en memoria, sino que entrega los números uno a uno, por lo que range(10**9) funciona al instante.

La regla principal: el límite derecho no entra en el rango. range(1, 10) termina en 9, y este es un motivo habitual de los errores «de una unidad». El paso puede ser negativo, pero no cero.

for i in range(1, 4):
    print(f"Día {i}")
# Día 1
# Día 2
# Día 3

enumerate: contador en el bucle

Los principiantes escriben a menudo for i in range(len(items)) para conocer el número del elemento. Funciona, pero se lee peor. La función enumerate() devuelve pares «número, elemento», y el parámetro start indica desde qué número contar:

items = ["café", "taxi", "comida"]
for n, item in enumerate(items, start=1):
    print(n, item)
# 1 café
# 2 taxi
# 3 comida

Para recorrer dos listas en paralelo existe zip(): for nombre, precio in zip(nombres, precios):. Se detiene en la lista más corta; desde Python 3.10 se puede pasar strict=True, y entonces una diferencia de longitud produce un error.

El bucle while en Python

El bucle while repite el bloque mientras la condición sea verdadera. Se elige cuando no se sabe de antemano cuántas repeticiones habrá: esperar una entrada correcta, leer datos hasta el final o repetir una petición hasta que tenga éxito.

saldo = 10_000
mes = 0
while saldo > 0:
    saldo -= 2_700
    mes += 1
print(f"El dinero alcanza para {mes} meses")  # 4

El peligro principal es olvidarse de modificar la variable de la condición. Entonces el bucle no termina nunca. Si el programa se ha quedado bloqueado, pulse Ctrl+C: Python interrumpirá la ejecución con KeyboardInterrupt.

Bucle infinito y do while

A veces el bucle infinito en Python se escribe a propósito: while True: con una salida mediante break. También así se hace el bucle con comprobación al final: Python no tiene la construcción do while, y este recurso la sustituye: el bloque se ejecuta al menos una vez y la comprobación va al final.

while True:
    texto = input("Importe: ")
    if texto.isdigit():
        importe = int(texto)
        break
    print("Introduzca un número entero")

El bucle for infinito es raro: solo ocurre al recorrer un iterador sin fin, por ejemplo itertools.count().

break y continue: salir del bucle y saltar una iteración

break interrumpe el bucle de inmediato y la ejecución continúa con el código que hay después de él. continue omite el resto de la iteración actual y pasa a la siguiente.

gastos = [350, -10, 1200, 0, 99_999, 89]

for importe in gastos:
    if importe <= 0:
        continue          # saltar esta iteración
    if importe > 50_000:
        print("Importe sospechoso, parada")
        break             # salir del bucle
    print(importe)

Se imprimirán 350 y 1200, después el mensaje; el bucle no llegará al 89. Ambas sentencias actúan solo sobre el bucle más cercano en el que se encuentran.

else en el bucle

Los bucles for y while tienen una rama else poco habitual: se ejecuta si el bucle terminó por sí mismo, sin break. Resulta útil para buscar:

for importe in gastos:
    if importe > 50_000:
        print("Se ha encontrado un gasto grande")
        break
else:
    print("No hay gastos grandes")

Bucles anidados

Un bucle dentro de otro ejecuta el interior por completo en cada iteración del exterior. Así se recorren tablas, matrices o pares de valores.

for fila in range(1, 4):
    for columna in range(1, 4):
        print(fila * columna, end="\t")
    print()

Hay que tener en cuenta dos cosas. Primero, la complejidad crece deprisa: dos bucles anidados sobre 10 000 elementos suponen 100 millones de operaciones. Segundo, break sale solo del bucle interior. Para interrumpir ambos, conviene meter los bucles en una función y usar return, que resulta más limpio que las banderas.

El operador match/case

Desde Python 3.10, una cadena larga de if cmd == ... elif ... puede sustituirse por el operador match (PEP 634). No es un simple switch: compara el valor con un patrón según la forma de los datos y reparte sus partes en variables.

def interpretar(texto):
    match texto.split():
        case ["add", producto, importe]:
            return f"Añadir {producto}: {importe}"
        case ["list"] | ["ls"]:
            return "Mostrar gastos"
        case ["quit"]:
            return "Salir"
        case _:
            return "Comando desconocido"

print(interpretar("add Café 250"))  # Añadir Café: 250
print(interpretar("add Café"))      # Comando desconocido

El patrón de lista ["add", producto, importe] solo coincide con una lista de exactamente tres elementos cuyo primer elemento es "add". Por eso un comando sin importe cae en la rama _, que recoge todo lo demás. El símbolo | une varias opciones.

Diccionarios, tipos y condición de guarda

Un patrón de diccionario comprueba solo las claves enumeradas; las demás se ignoran. La expresión int(a) comprueba el tipo y captura el valor, y un if después del patrón añade una condición adicional (guard):

match evento:
    case {"tipo": "gasto", "importe": int(a)} if a > 10_000:
        print("Gasto grande", a)
    case {"tipo": "gasto", "importe": int(a)}:
        print("Gasto", a)

La trampa principal de match

Un nombre suelto en case es una captura, no una comparación con una variable. case limite: coincide con cualquier valor y lo guarda en limite. Para comparar con constantes hay que usar un nombre con punto, por ejemplo case Color.ROJO:, o literales.

La sintaxis de match apenas ha cambiado desde la 3.10. En Python 3.15 se corrigió una pequeña asimetría: antes, en los patrones literales, solo se permitía el signo menos delante de un número; ahora también se puede escribir case +1:. En versiones anteriores, ese código produce un error de sintaxis.

Errores típicos en los bucles

• Modificar la lista mientras se recorre. Eliminar elementos dentro de un for salta los vecinos. Mejor construir una lista nueva: limpia = [x for x in items if x > 0].
• El límite de range. range(1, n) no incluye n.
• Olvidar cambiar la condición en while, lo que produce un bucle infinito.
• Unir cadenas con += dentro de un bucle es más lento con grandes volúmenes que "".join(partes).
• Asignar en lugar de comparar: if x = 5 es un error de sintaxis; la comparación se escribe con ==.

Ejercicios de bucles para practicar

1. Calcule la suma y la media de una lista de gastos, omitiendo los valores negativos.
2. Muestre la tabla de multiplicar del 1 al 9 con bucles anidados.
3. Pida números al usuario hasta que introduzca una cadena vacía y después muestre el máximo.
4. Busque en una lista el primer número mayor que 1000 e informe si no existe (con for ... else).
5. Interprete los comandos add, del y list con match.

Resumen

Los bucles de Python se reducen a dos construcciones: for recorre los elementos de una colección o de range(), y while funciona mientras se cumpla una condición. break y continue dirigen el curso del bucle, enumerate() y zip() evitan los contadores manuales, y if/elif/else y match/case se encargan de las decisiones. Todas estas herramientas se practican en la lección del curso de Python sobre un registro de gastos.