# Bucles y condiciones en Python: for, while, range, enumerate, break, if/elif y match/case URL: https://skillaria.top/es/guides/python/bucles-python En Python, los bucles repiten acciones: for recorre los elementos de cualquier colección o de un range(), y while se ejecuta mientras la condición sea verdadera. Para interrumpir un bucle se usa break, para saltar una iteración, continue, y el número del elemento se obtiene con enumerate(). Las decisiones las toman las condiciones if/elif/else y, desde Python 3.10, el operador 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. | Llamada | Números | | --- | --- | | `range(5)` | 0, 1, 2, 3, 4 | | `range(2, 6)` | 2, 3, 4, 5 | | `range(0, 10, 3)` | 0, 3, 6, 9 | | `range(5, 0, -1)` | 5, 4, 3, 2, 1 | 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 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. ## FAQ **¿En qué se diferencia for de while en Python?** for recorre una secuencia ya existente y sabe cuándo parar, mientras que while se repite mientras la condición sea verdadera. Si el número de repeticiones se conoce o hay una colección, use for; si espera a que ocurra un suceso, use while. **¿Cómo recorrer un bucle en orden inverso?** Use reversed(items) para una colección o range(n - 1, -1, -1) para números. La función reversed no copia la lista: la recorre desde el final. **¿Python tiene switch?** No hay un switch separado: su papel lo cumplen la cadena if/elif y el operador match/case, que apareció en Python 3.10. match puede más: desglosa listas y diccionarios según su forma y captura valores. **¿Es más rápido un bucle o una comprensión de lista?** Una comprensión de lista como [x * 2 for x in items] suele ser algo más rápida que el bucle equivalente con append y es más corta. Para lógica compleja con varias condiciones, un bucle normal se lee mejor. **¿Cómo salir de dos bucles anidados a la vez?** break interrumpe solo el bucle interior. Lo más sencillo es meter los bucles en una función y salir con return. --- Source: Skillaria.Top (https://skillaria.top)