Bucles while: repetir mientras una condición se cumple

El problema que vamos a resolver

En el capítulo anterior aprendimos a detectar entradas incorrectas: cuando alguien escribe twenty, el programa puede decir «eso no es un número».

Pero ¿qué hace después de decirlo? Se detiene. La persona tiene que volver a ejecutar todo el programa. Ningún software real se comporta así: vuelve a preguntar, y sigue preguntando hasta recibir una respuesta válida.

Para eso sirven los bucles: para repetir el mismo trabajo tantas veces como haga falta. Hoy aprenderemos while, que se ejecuta mientras una condición se mantenga verdadera.

Hoy también te espera una experiencia nueva: un programa que no se detiene, con texto que pasa a toda velocidad por la terminal. No hay nada que temer: en este mismo capítulo aprenderás a pararlo.

Al terminar este capítulo podrás

• Escribir un bucle while y decir cuándo va a terminar
• Reconocer por qué se producen los bucles infinitos, y detener uno con Ctrl + C
• Acumular una suma o un contador dentro de un bucle
• Usar break y continue en el lugar adecuado
• Seguir preguntando hasta que la entrada sea válida

Requisitos previos: Tomar decisiones: if, elif, else.

El bucle más sencillo

count = 3

while count > 0:
    print(count)
    count = count - 1

print("Go")

3
2
1
Go

La forma se parece a la de un if: condición, dos puntos y bloque con sangría. Hay una diferencia, y es la que lo cambia todo: un if comprueba la condición una sola vez; un while la vuelve a comprobar cada vez que termina el bloque.

Esto es lo que hizo el programa de arriba:

1. count vale 3. La condición 3 > 0 es verdadera → se ejecutó el bloque, imprimió 3 y count pasó a valer 2
2. Vuelve a comprobar la condición: 2 > 0 es verdadera → imprimió 2 y count pasó a valer 1
3. Otra vez la condición: 1 > 0 es verdadera → imprimió 1 y count pasó a valer 0
4. Condición de nuevo: 0 > 0 es falsa → el bucle terminó y la ejecución continuó

Todo bucle while que funciona tiene tres partes, y necesita las tres:

• Un valor inicial: antes del bucle (count = 3)
• Una condición: cuándo seguir (count > 0)
• Un cambio: algo dentro que, tarde o temprano, hará que la condición sea falsa (count = count - 1)

Bucles infinitos

Conviene ver qué pasa cuando falta la tercera parte:

count = 3

while count > 0:
    print(count)

Esto imprime 3 sin parar. count nunca cambia, así que count > 0 nunca se vuelve falsa.

Cómo detenerlo: pulsa Ctrl + C en la terminal. Se detiene al instante y muestra algo como esto:

Traceback (most recent call last):
  File "D:\python-lab\lesson-10\loop.py", line 4, in <module>
    print(count)
KeyboardInterrupt

La línea File mostrará la ruta completa de tu archivo, y el número de línea depende del momento exacto en que pulsaste las teclas. KeyboardInterrupt significa que lo detuviste tú. Eso no es un error en tu código, es una decisión tuya.

Los bucles infinitos forman parte del aprendizaje. Todos los programadores han escrito uno, y siguen haciéndolo. No hay nada que temer: saber usar Ctrl + C lo convierte en una simple molestia. Al escribir un bucle, pregúntate una vez: «¿cómo va a volverse falsa esta condición?» Si no sabes responder, el bucle no terminará.

Acumular

El trabajo más habitual de un bucle es ir construyendo algo poco a poco: una suma, un contador, el valor más grande visto hasta el momento:

total = 0
number = 1

while number <= 5:
    total = total + number
    number = number + 1

print("Sum of 1 to 5:", total)

Sum of 1 to 5: 15

total se llama acumulador: es el recipiente en el que vas reuniendo valores. Fíjate en que empieza fuera del bucle, en 0. Si lo inicializaras dentro, se reiniciaría en cada vuelta y al final solo quedaría el último número.

break — salir ahora mismo

break termina el bucle al instante, digan lo que digan la condición:

number = 1

while number <= 100:
    if number % 7 == 0:
        print("First multiple of 7:", number)
        break
    number = number + 1

First multiple of 7: 7

La condición decía que había que llegar hasta 100, pero el trabajo terminó en cuanto apareció el 7, así que no tenía sentido dar otras 93 vueltas.

break también hace posible un patrón muy útil: escribir True como condición y salir desde el lugar adecuado dentro del bucle:

while True:
    answer = input("Type 'quit' to exit: ").strip().lower()
    if answer == "quit":
        print("Goodbye")
        break
    print(f"You typed: {answer}")

Type 'quit' to exit: hello
You typed: hello
Type 'quit' to exit: QUIT
Goodbye

while True significa «repite para siempre», así que el break interior es obligatorio; si no está, el bucle es infinito.

continue — saltar esta vuelta

continue no termina el bucle; salta el resto del bloque y pasa directamente a la siguiente vuelta:

number = 0

while number < 10:
    number = number + 1
    if number % 2 == 0:
        continue
    print(number)

1
3
5
7
9

Para cada número par, continue se ejecutó y el print se saltó.

Cuidado al escribir continue. Si la línea que hace avanzar la condición (number = number + 1) está después del continue, este la salta, y el bucle se queda atascado para siempre. Por eso, en el código de arriba, el incremento va primero. Cada vez que uses continue, comprueba ese orden.

Por fin: volver a preguntar hasta que la entrada sea válida

Esto es lo que llevamos dos capítulos esperando:

while True:
    raw = input("Your age: ").strip()
    if raw.isdigit():
        age = int(raw)
        break
    print("Please type a whole number, digits only.")

print(f"Thank you. Age recorded as {age}.")

Your age: twenty
Please type a whole number, digits only.
Your age: 22.5
Please type a whole number, digits only.
Your age: 22
Thank you. Age recorded as 22.

Este es el patrón que usarás durante el resto de tu vida profesional: repetir sin fin, validar dentro, break cuando el valor es válido, y mostrar un mensaje y dar otra vuelta cuando no lo es. El programa ya no se viene abajo con una entrada incorrecta, y la persona no tiene que empezar de nuevo.

Un ejemplo completo

shopping.py:

# Keep taking item prices until the user is done, then summarise
total = 0.0
item_count = 0

print("Enter item prices. Type 'done' to finish.")

while True:
    entry = input("Price: ").strip().lower()

    if entry == "done":
        break

    if entry == "":
        print("  Nothing typed — try again.")
        continue

    # Accept only digits and at most one decimal point
    if entry.replace(".", "", 1).isdigit():
        price = float(entry)
        total = total + price
        item_count = item_count + 1
        print(f"  Added {price:.2f}. Running total {total:.2f}")
    else:
        print(f"  '{entry}' is not a price. Try again.")

print()
if item_count == 0:
    print("No items were entered.")
else:
    average = total / item_count
    print(f"Items   : {item_count}")
    print(f"Total   : {total:.2f}")
    print(f"Average : {average:.2f}")

Enter item prices. Type 'done' to finish.
Price: 120
  Added 120.00. Running total 120.00
Price: abc
  'abc' is not a price. Try again.
Price: 85.5
  Added 85.50. Running total 205.50
Price: done

Items   : 2
Total   : 205.50
Average : 102.75

Tres cosas funcionan juntas aquí, y las tres son el material de hoy:

• break — salir del bucle cuando la persona escribe done
• continue — saltar el resto y volver a preguntar si la línea está vacía
• Acumuladores — total y item_count empiezan fuera del bucle y crecen dentro

Piensa por qué hace falta ese if item_count == 0 final. Si alguien escribe done de inmediato, sin introducir nada, item_count vale 0, y total / item_count rompería el programa con un ZeroDivisionError. Antes de usar cualquier cosa que haya acumulado un bucle, hazte siempre la pregunta: «¿ha acumulado algo en realidad?»

Cuando algo falla

El programa no se detiene y el texto pasa a toda velocidad Pulsa Ctrl + C. Después, comprueba que el cuerpo del bucle contiene la línea que hace avanzar la condición, y que no está después de un continue.

El bucle nunca se ejecutó La condición ya era falsa desde el principio. Compara el valor inicial con la condición: while count > 0 partiendo de count = 0 nunca entra en el bucle.

Da una vuelta de más o de menos Se han confundido < y <=. Partiendo de n = 1, while n < 5 se ejecuta cuatro veces (con n valiendo 1, 2, 3 y 4), y while n <= 5 se ejecuta cinco. Si cambias el valor inicial, cambia también el número de vueltas: partiendo de n = 0, while n < 5 se ejecuta cinco veces. Por eso, comprueba siempre el valor inicial y la condición juntos.

IndentationError: expected an indented block after 'while' statement La línea que sigue al while no tiene sangría.

NameError después del bucle: la variable no existe La variable solo se creó dentro del bucle, y si el bucle nunca se ejecutó, nunca llegó a crearse. Da un valor inicial a cualquier variable que necesites después del bucle, antes del bucle.

El total es incorrecto al final del bucle Revisa si el acumulador se inicializa dentro del bucle. La línea total = 0 tiene que estar fuera.

Tu turno

Escribe un juego de adivinar un número, guess.py:

1. Fija en el código un número secreto entre 1 y 100
2. Pide a la persona que adivine, y dile «más alto» o «más bajo» en cada intento
3. Si acierta, felicítala y sal del bucle
4. Muestra cuántos intentos ha necesitado
5. Si escribe algo que no es un número, el programa no debe romperse: muestra un mensaje y vuelve a preguntar
6. Después de siete intentos, el juego termina y revela el número secreto

El punto seis es el que te hará pensar: tu bucle puede ahora terminar por dos motivos distintos, un acierto o que se acaben los intentos. Cómo organizas las dos salidas es la verdadera cuestión de este ejercicio. Y cuando funcione, vuelve a leer tu código una vez más y pregúntate: ¿hay algún estado al que este bucle podría llegar en el que se ejecute para siempre?