Bucles en Python: for, while, range, break y continue
Actualizado el 29 de septiembre de 2026
Un bucle repite un bloque de código varias veces. Sin bucles, sumar los números del 1 al 100 obligaría a escribir 100 sumas; con un bucle son tres líneas. Python tiene dos: for, para recorrer una secuencia de valores conocida, y while, para repetir mientras se cumpla una condición.
En esta guía vas a ver ambos, la función range(), cómo cortar o saltar una vuelta y los patrones de acumulador y contador, que aparecen en la mayoría de los ejercicios.
for: recorrer una secuencia
for fruta in ["manzana", "pera"]:
print(fruta)
# manzana
# pera
for letra in "hola":
print(letra) # h, o, l, a (una por línea)En cada vuelta, la variable (fruta, letra) toma el siguiente valor de la secuencia. El nombre lo eliges tú; conviene que describa qué es cada elemento.
range(): repetir un número de veces
range() genera una secuencia de enteros. Igual que en el slicing de listas, el valor final no se incluye:
list(range(5)) # [0, 1, 2, 3, 4]
list(range(2, 6)) # [2, 3, 4, 5]
list(range(0, 10, 3)) # [0, 3, 6, 9] (de 3 en 3)
list(range(5, 0, -1)) # [5, 4, 3, 2, 1] (hacia atrás)Así, para repetir algo del 1 al 5 se escribe for n in range(1, 6).
Acumuladores y contadores
Casi todo bucle que calcula algo sigue el mismo patrón: una variable que parte en un valor inicial antes del bucle y se actualiza en cada vuelta.
total = 0 # acumulador: parte en 0
for n in range(1, 6):
total += n
print(total) # 15
pares = 0 # contador
for n in [3, 8, 10, 7]:
if n % 2 == 0:
pares += 1
print(pares) # 2La inicialización va antes del bucle. Si la pones adentro, se reinicia en cada vuelta y el resultado final solo refleja la última.
while: repetir mientras se cumpla una condición
while se usa cuando no se sabe de antemano cuántas vueltas hay que dar: pedir una clave hasta que sea correcta, dividir un número hasta que llegue a 0, esperar a que termine algo.
n = 1234
digitos = 0
while n > 0:
n = n // 10 # quita el último dígito
digitos += 1
print(digitos) # 4Antes de cada vuelta se revisa la condición; cuando deja de cumplirse, el bucle termina. Dentro del bucle tiene que cambiar algo que haga que la condición eventualmente sea falsa.
break y continue
for n in [3, 8, 11, 4]:
if n > 10:
print("Encontré", n) # Encontré 11
break # sale del bucle: el 4 no se revisa
for n in range(1, 7):
if n % 2 == 0:
continue # salta al siguiente n
print(n) # 1, 3, 5break termina el bucle de inmediato y continue salta el resto de la vuelta actual. Úsalos con moderación: un bucle con varios break y continue se vuelve difícil de seguir.
Errores comunes
Bucle infinito
contador = 0
while contador < 5:
print(contador)
# falta: contador += 1Si nada cambia la condición, el while nunca termina. Si tu programa se queda "pegado", revisa qué variable debería avanzar en cada vuelta. En la terminal, Ctrl+C detiene el programa.
Quedarse corto por uno con range
range(1, n) llega hasta n - 1. Si quieres incluir n, el límite es n + 1. Es el error más común con range, y por eso conviene probar siempre el caso más pequeño: con n = 1, ¿el bucle da una vuelta?
Cambiar la variable del for dentro del bucle
for i in range(3):
i = 10
print(i) # 10, 10, 10 — pero el bucle igual da 3 vueltasAsignar la variable del for no cambia la secuencia que se está recorriendo: en la vuelta siguiente, i toma el próximo valor de range. Si necesitas controlar el avance a mano, usa while.
Ejercicios resueltos
Intenta resolver cada ejercicio antes de abrir la solución: equivocarse y corregir es la parte que más enseña.
1.Sumar del 1 al n
Escribe una función sumar_hasta(n) que devuelva la suma de todos los enteros del 1 al n, incluido n. Si n es 0, debe devolver 0.
sumar_hasta(5)→15sumar_hasta(1)→1sumar_hasta(100)→5050
def sumar_hasta(n):
...Ver soluciónOcultar solución
def sumar_hasta(n):
total = 0
for i in range(1, n + 1):
total += i
return totalEs el patrón del acumulador. El detalle está en range(1, n + 1): sin el + 1, la suma se quedaría corta en n. Con n = 0, range(1, 1) está vacío, el bucle no da ninguna vuelta y se devuelve el 0 inicial.
Existe una fórmula directa, n * (n + 1) // 2, y también sum(range(1, n + 1)). Vale la pena saberlas, pero el objetivo del ejercicio es practicar el bucle.
2.Contar vocales
Escribe una función contar_vocales(texto) que devuelva cuántas vocales tiene el texto, sin distinguir mayúsculas y contando las vocales con tilde.
contar_vocales("Murciélago")→5contar_vocales("xyz")→0contar_vocales("AEIOU")→5
def contar_vocales(texto):
...Ver soluciónOcultar solución
def contar_vocales(texto):
contador = 0
for letra in texto.lower():
if letra in "aeiouáéíóú":
contador += 1
return contadorUn for sobre un texto recorre sus letras. Convertir a minúsculas con .lower() antes de recorrer evita tener que listar también "AEIOU", y in pregunta si la letra está entre las vocales. Es el patrón del contador: parte en 0 y suma 1 cada vez que se cumple la condición.
3.¿Es primo?
Escribe una función es_primo(n) que devuelva True si n es primo: mayor que 1 y divisible solo por 1 y por sí mismo.
es_primo(7)→Truees_primo(1)→Falsees_primo(91)→False(7 × 13)es_primo(97)→True
def es_primo(n):
...Ver soluciónOcultar solución
def es_primo(n):
if n < 2:
return False
divisor = 2
while divisor * divisor <= n:
if n % divisor == 0:
return False
divisor += 1
return TrueSe prueban divisores desde el 2. Apenas uno divide exacto, ya se sabe que no es primo y return False corta todo. Si el bucle termina sin encontrar ninguno, es primo.
No hace falta probar hasta n: si n tuviera un divisor mayor que su raíz cuadrada, tendría también uno menor, que ya se habría encontrado. Por eso la condición es divisor * divisor <= n. Para 97 son 9 pruebas en vez de 95.