El flujo dentro de un bucle tiene tres palancas: dejarlo correr, saltarse una iteración, o abortarlo por completo. break y continue las conoces de cualquier lenguaje. Lo que Python añade —y que casi nadie espera— es una cláusula else adjunta al propio bucle, con una semántica que no tiene equivalente directo en C, Java ni JavaScript.
break termina el bucle inmediatamente y transfiere el control a la primera instrucción después de él. continue abandona el resto del cuerpo de la iteración actual y salta directamente a la siguiente evaluación de la condición (en while) o al siguiente elemento (en for). Hasta aquí, nada sorprendente.
La cláusula else de un bucle es donde Python se separa del resto. Su contrato es preciso: el bloque else se ejecuta si y solo si el bucle terminó de forma natural, es decir, sin que ningún break lo interrumpiera. Si break dispara, el else se salta. Si el iterable se agota o la condición del while se vuelve falsa, el else corre.
¿Por qué existe esto? Porque el problema de “buscar algo en una secuencia y reaccionar si no se encontró” aparece constantemente, y sin esta cláusula necesitas una variable bandera (found = False) que ensucia el alcance y obliga al lector a rastrear dos cosas en paralelo. El else del bucle convierte ese patrón en una sola estructura de control cohesiva.
El error conceptual más común viene de importar el significado de else desde los condicionales if. En un if/else, el else significa “cuando la condición es falsa”. En un bucle, la analogía correcta no es “cuando la condición es falsa” sino “cuando no hubo break“. El nombre else es discutiblemente desafortunado —Guido van Rossum lo admitió—, pero el comportamiento es preciso y útil una vez que lo internalizas.
# Buscar un número primo en un rango sin variable bandera auxiliar
def first_prime_in_range(start: int, end: int) -> int | None:
for candidate in range(start, end + 1):
if candidate < 2:
continue # los menores de 2 no son primos; saltar sin abortar
for divisor in range(2, int(candidate**0.5) + 1):
if candidate % divisor == 0:
break # candidate no es primo; salir del bucle interior
else:
# este else pertenece al `for divisor`, no al `for candidate`
# llega aquí solo si ningún divisor dividió exactamente → es primo
return candidate
return None # ningún candidato superó la prueba
def find_user(user_id: int, records: list[dict]) -> None:
for record in records:
if record["id"] == user_id:
print(f"Usuario encontrado: {record['name']}")
break
else:
# se ejecuta solo si el for agotó records sin break
print(f"No existe usuario con id={user_id}")
if __name__ == "__main__":
print(first_prime_in_range(10, 20)) # 11
users = [{"id": 1, "name": "Ana"}, {"id": 2, "name": "Luis"}]
find_user(2, users) # Usuario encontrado: Luis
find_user(99, users) # No existe usuario con id=99
Desglosando las decisiones
first_prime_in_range anida dos bucles y cada uno tiene su propia semántica de control. El continue en el bucle exterior descarta candidatos menores de 2 sin complejidad adicional: el cuerpo del bucle no necesita un if/else envolvente, simplemente vuelve al principio.
El bucle interior sobre divisor es donde el else brilla de verdad. La pregunta que queremos responder es “¿llegamos al final de todos los divisores posibles sin encontrar ninguno que divida a candidate?”. Eso es exactamente lo que garantiza el else: si el for divisor se interrumpió con break, hay un divisor exacto y candidate no es primo; si terminó naturalmente, candidate pasó todas las pruebas. Sin el else, necesitarías is_prime = True antes del bucle, is_prime = False dentro del break, y un if is_prime después —tres líneas adicionales y un nombre extra para rastrear.
Fíjate también en el indentado: el else va al mismo nivel que el for al que pertenece. En el ejemplo anidado, el else está alineado con for divisor, no con for candidate. Ese alineamiento es la única pista visual de a qué bucle pertenece, así que léelo con cuidado cuando veas estructuras anidadas.
find_user muestra el patrón canónico de búsqueda lineal. La alternativa con variable bandera sería:
found = False
for record in records:
if record["id"] == user_id:
print(f"Usuario encontrado: {record['name']}")
found = True
break
if not found:
print(f"No existe usuario con id={user_id}")
Funciona, pero found contamina el alcance de la función y el if not found después del bucle está desacoplado visualmente de la lógica que lo produce. El else del bucle mantiene la rama de “no encontrado” junto a la estructura que define cuándo se activa.
Errores que debes conocer
Error: asumir que el else del bucle corre cuando el iterable estaba vacío desde el inicio, y tratarlo como “el bucle hizo algo”.
# ❌ Wrong
items = []
for item in items:
process(item)
else:
print("procesamiento completado") # se imprime aunque no hubo ninguna iteración
# ✅ Right
items = []
if items:
for item in items:
process(item)
# aquí sabes que procesaste al menos uno
else:
print("lista vacía, nada que procesar")
Un iterable vacío agota el for inmediatamente sin break, así que el else dispara. Si tu lógica necesita distinguir “terminé sin romper” de “nunca empecé”, guarda esa comprobación fuera del bucle.
Error: usar continue en lugar de break cuando se quiere abortar la búsqueda, haciendo que el bucle siga recorriendo elementos innecesariamente.
# ❌ Wrong
for record in large_dataset:
if record["id"] == target_id:
result = record
continue # sigue iterando en lugar de detenerse → O(n) completo siempre
# ✅ Right
for record in large_dataset:
if record["id"] == target_id:
result = record
break # detiene el bucle en cuanto encuentra el objetivo
continue no sale del bucle, solo avanza a la siguiente iteración; break es lo que realmente corta la búsqueda y permite que el else del bucle señale la ausencia del elemento.
N° 52