El bucle while

Imagina que quieres imprimir los números del 1 al 5. Con lo que sabes hasta ahora tendrías que escribir cinco print. Del 1 al 1000 ya no es una opción. Y si ni siquiera sabes cuántas veces hay que repetir, porque depende de lo que escriba el usuario, es directamente imposible.

Los bucles resuelven eso: un trozo de código escrito una sola vez que se ejecuta muchas. El primero de los dos que tiene Python se llama while, y repite mientras una condición sea verdadera.

La forma básica#

contador = 1

while contador <= 5:
        print(f"Vuelta {contador}")
    contador += 1

print("Fin del bucle.")

Vuelta 1
Vuelta 2
Vuelta 3
Vuelta 4
Vuelta 5
Fin del bucle.

La sintaxis es idéntica a la del if: la palabra clave, la condición, dos puntos y un bloque sangrado cuatro espacios. La diferencia está en lo que ocurre al llegar al final del bloque:

1. Python comprueba la condición.
2. Si es verdadera, ejecuta el bloque entero.
3. Vuelve al paso 1.
4. Cuando la condición es falsa, se salta el bloque y continúa por la primera línea sin sangrar.

Un if mira la condición una vez; un while la mira antes de cada vuelta. Cada una de esas vueltas se llama iteración.

La condición se comprueba antes#

Si la condición es falsa desde el principio, el bloque no se ejecuta ni una sola vez:

intentos = 0

while intentos > 3:
        print("Esto no se imprime nunca")

print("El bucle no se ha ejecutado ni una vez.")

El bucle no se ha ejecutado ni una vez.

No es un error, es el comportamiento normal. Un while puede dar cero vueltas.

El contador#

En el primer ejemplo había tres líneas repartidas que forman un patrón que verás miles de veces:

contador = 1               # 1. inicializar antes del bucle
while contador <= 5:       # 2. comparar en la condición
        print(contador)
    contador += 1          # 3. modificar dentro del bucle

Las tres son imprescindibles, y la tercera es la que se olvida. Si no cambias nunca la variable que aparece en la condición, la condición nunca dejará de ser verdadera.

segundos = 3

while segundos > 0:
        print(f"{segundos}...")
    segundos -= 1

print("Despegue.")

3...
2...
1...
Despegue.

El bucle infinito#

Es el error clásico de esta lección. Este programa no termina nunca:

contador = 1

while contador <= 5:
        print(f"Vuelta {contador}")

Falta el contador += 1, así que contador vale 1 para siempre, 1 <= 5 es verdadero para siempre y el programa imprime Vuelta 1 hasta que lo pares tú.

Para cortarlo, pulsa Ctrl + C en la terminal. Python interrumpe la ejecución y, después de los miles de Vuelta 1 que hayan salido, te deja este mensaje:

Traceback (most recent call last):
  File "/tmp/bucle_infinito.py", line 3, in <module>
    print(f"Vuelta {contador}")
    ~~~~~^^^^^^^^^^^^^^^^^^^^^^
KeyboardInterrupt

Si te ocurre con un bucle que imprime mucho, la terminal se te llenará de miles de líneas. Es incómodo pero inofensivo: nada se rompe y el ordenador no sufre.

Cuando el bucle infinito es intencionado#

Hay un caso en el que un bucle sin fin es exactamente lo que quieres: cuando no sabes cuántas vueltas hará y la salida depende de algo que pasa dentro. Entonces se escribe así, con la condición siempre verdadera:

while True:
    # ... y aquí dentro se decide cuándo salir

True es verdadero por definición, así que el bucle no termina solo. Necesita una instrucción específica para salir, break, que es el tema de la lección siguiente. Hasta entonces usaremos una variable de control.

Patrón 1: el acumulador#

Una variable que va guardando el total de todas las vueltas. Se inicializa a cero antes del bucle y va creciendo dentro:

numero = 1
suma = 0

while numero <= 100:
        suma += numero
    numero += 1

print(f"La suma de 1 a 100 es {suma}")

La suma de 1 a 100 es 5050

Dos variables con papeles distintos: numero controla el bucle y suma acumula. No las mezcles en una sola.

El acumulador vale para cualquier cosa que se combine: sumar precios, contar cuántos elementos cumplen algo, multiplicar para calcular un factorial. Este ejemplo acumula y además cuenta, para poder sacar la media:

total = 0.0
articulos = 0
precio = 10.0

while articulos < 4:
        total += precio
    articulos += 1
    precio += 2.5

print(f"{'Artículos:':<14}{articulos}")
print(f"{'Total:':<14}{total:.2f} €")
print(f"{'Media:':<14}{total / articulos:.2f} €")

Artículos:    4
Total:        55.00 €
Media:        13.75 €

Los contadores también sirven para descomponer números, combinando la división entera y el resto que ya conoces:

numero = 4071
suma_digitos = 0

while numero > 0:
        suma_digitos += numero % 10      # el último dígito
    numero //= 10                    # quita el último dígito

print(f"Suma de los dígitos: {suma_digitos}")

Suma de los dígitos: 12

Aquí la condición no depende de un contador, sino del propio dato, que se va encogiendo hasta llegar a cero. Es el while en su forma más natural: repetir hasta que algo se acabe.

Patrón 2: la validación#

Insistir con la misma pregunta hasta que la respuesta sirva. Fíjate en que el input aparece dos veces, una antes del bucle y otra dentro:

edad_texto = input("Edad: ").strip()

while not edad_texto.isdigit():
        print("Eso no es un número entero.")
    edad_texto = input("Edad: ").strip()

edad = int(edad_texto)
print(f"Gracias. Has escrito {edad}.")

Edad: treinta
Eso no es un número entero.
Edad: -5
Eso no es un número entero.
Edad: 34
Gracias. Has escrito 34.

Con esto se acaba el problema del ValueError que arrastrábamos desde la lección de input(): la conversión a int de la penúltima línea no puede fallar, porque el bucle no deja pasar nada que no sea un número.

La pregunta duplicada es fea y tiene arreglo. Es justo lo que resuelve el while True con break de la lección siguiente.

Patrón 3: el menú#

El bucle mantiene el programa vivo mostrando opciones hasta que la persona decide salir:

saldo = 1000.00
salir = False

while not salir:
        print()
    print("BANCO")
    print("1. Ver saldo")
    print("2. Ingresar")
    print("3. Salir")

    opcion = input("Opción: ").strip()

    if opcion == "1":
                print(f"Saldo actual: {saldo:.2f} €")
    elif opcion == "2":
                cantidad = float(input("Cantidad a ingresar: "))
        saldo += cantidad
        print(f"Nuevo saldo: {saldo:.2f} €")
    elif opcion == "3":
                salir = True
        print("Hasta luego.")
    else:
                print("Opción no válida.")

BANCO
1. Ver saldo
2. Ingresar
3. Salir
Opción: 1
Saldo actual: 1000.00 €

BANCO
1. Ver saldo
2. Ingresar
3. Salir
Opción: 2
Cantidad a ingresar: 250
Nuevo saldo: 1250.00 €

BANCO
1. Ver saldo
2. Ingresar
3. Salir
Opción: 3
Hasta luego.

Este programa junta casi todo el módulo: variables, input, conversiones, f-strings con formato, una cadena de elif y un bucle. La variable salir se llama bandera: un booleano que existe solo para controlar cuándo acaba el bucle. Fíjate en que la opción no válida no rompe nada; el bucle vuelve a preguntar.