lección 4

Repetir sin aburrirse: bucles for y while

Los bucles permiten repetir acciones sin copiar y pegar código. La diferencia entre escribir 100 líneas o escribir 3.

⏱ 55 min

Imagina que tu jefe te pide: "envía un email de bienvenida a los 500 nuevos usuarios que se registraron hoy". ¿Vas a escribir 500 veces la instrucción de enviar email? Obviamente no. Los bucles son la tercera superpotencia de la programación (después de la secuencia y la decisión): permiten repetir una acción tantas veces como necesites escribiéndola UNA sola vez. Es la diferencia entre un artesano que clava 1000 clavos a mano y una máquina que los clava automáticamente.

### La metáfora: la lavadora

Una lavadora es un bucle perfecto. Tiene un programa (centrifugado, enjuague, etc.) que REPITE durante un tiempo determinado. "Gira el tambor 800 veces por minuto durante 10 minutos." No hay un ingeniero dentro girándolo a mano 8000 veces — hay una instrucción simple que se repite. Hay dos tipos de lavadora: una que gira un número fijo de veces (bucle for — "haz esto 10 veces") y otra que gira hasta que se cumple una condición (bucle while — "gira hasta que la ropa esté seca").

FOR: sabes cuántas veces repetir. WHILE: repites hasta que se cumpla una condición.

### El bucle for: "haz esto para cada elemento"

El bucle for en Python es elegante: "para cada cosa en esta colección, haz algo con esa cosa". La colección más simple es un rango de números generado con range(). range(5) genera los números 0, 1, 2, 3, 4 (empieza en 0 y termina ANTES del número que le dices).

1# Bucle for básico: contar del 0 al 4
2for i in range(5):
3    print(f"Iteración número {i}")
4
5# Resultado:
6# Iteración número 0
7# Iteración número 1
8# Iteración número 2
9# Iteración número 3
10# Iteración número 4
11
12# range(inicio, fin) — desde inicio hasta fin-1
13for numero in range(1, 11):
14    print(f"{numero} x 7 = {numero * 7}")
15
16# range(inicio, fin, paso) — de 2 en 2
17for par in range(0, 20, 2):
18    print(par, end=" ")  # 0 2 4 6 8 10 12 14 16 18

range(n) genera n números empezando en 0. range(a, b) va de a hasta b-1. range(a, b, c) salta de c en c.

Pero for no es solo para números. Puedes iterar sobre cualquier colección — por ejemplo, una lista de nombres:

1# Iterar sobre una lista de elementos
2frutas = ["manzana", "banana", "cereza", "dátil"]
3
4for fruta in frutas:
5    print(f"Me gusta la {fruta}")
6
7# Ejemplo práctico: enviar emails (simulado)
8usuarios = ["ana@mail.com", "bob@mail.com", "carlos@mail.com"]
9
10for email in usuarios:
11    print(f"Enviando bienvenida a {email}...")
12    print(f"  [OK] Email enviado a {email}")
13
14print(f"Proceso completado: {len(usuarios)} emails enviados")

for variable in lista recorre cada elemento de la lista, uno por uno.

Y no solo listas. Un texto también se puede recorrer, y lo que sale en cada vuelta es una letra:

1# Recorrer un texto, letra a letra
2for letra in "datos":
3    print(letra)
4
5# Resultado: d, a, t, o, s — cada una en su línea
6
7# len() funciona también con texto: cuenta las letras
8mensaje = "Hola mundo"
9print(f"El mensaje tiene {len(mensaje)} caracteres")  # 10 (incluye el espacio)
10
11# .lower() pasa todo a minúscula: útil para comparar sin importar MAY/min
12nombre = "ANA García"
13print(nombre.lower())  # "ana garcía"

Un texto se puede recorrer con for igual que una lista. len() cuenta elementos. .lower() normaliza a minúscula.

Lo de .lower() tiene un nombre: es un método. Un método es una herramienta que el texto trae de fábrica y que se escribe pegándole un punto detrás. Hay más: .upper() pone todo en mayúscula, .isdigit() te dice si un carácter es un número y .isupper() te dice si es mayúscula. No hace falta que te los aprendas — lo importante es reconocer la forma: cuando veas algo.algo(), es "esta cosa, haz esto". Los irás encontrando sobre la marcha.

### El bucle while: "repite hasta que..."

while es diferente: no sabe de antemano cuántas veces va a repetir. Simplemente comprueba una condición ANTES de cada vuelta. Si la condición es True, ejecuta el bloque. Si es False, sale del bucle. Es como un guardia de seguridad que te deja seguir entrando mientras tengas pase válido.

1# while: repetir mientras la condición sea True
2password_correcta = "secreto123"
3intentos = 0
4
5# Lo que el usuario va tecleando, simulado:
6lo_que_teclea = ["1234", "secreto", "secreto123"]
7
8password = lo_que_teclea[intentos]
9
10while password != password_correcta:
11    intentos = intentos + 1
12    if intentos >= 3:
13        print("¡Demasiados intentos! Cuenta bloqueada.")
14        break  # 'break' sale del bucle inmediatamente
15    restantes = 3 - intentos
16    print(f"Incorrecta. Te quedan {restantes} intentos.")
17    password = lo_que_teclea[intentos]
18
19if password == password_correcta:
20    print("¡Acceso concedido! Bienvenido.")
21
22# Cambia la lista: pon "secreto123" en la primera posición y verás
23# que el bucle ni siquiera arranca (la condición ya es False).

while repite mientras la condición sea True. break fuerza la salida del bucle.

PELIGRO: el bucle infinito. Si la condición del while NUNCA se vuelve False, tu programa se queda girando eternamente (como una lavadora que nunca para). while True: sin un break dentro es un bucle infinito. Si al ejecutar en el navegador la pestaña se queda "colgada", probablemente tienes un bucle infinito: recarga la página y revisa que la condición del while pueda volverse False en algún momento. (Cuando en Python desde cero ejecutes desde la terminal, la parada de emergencia será Ctrl+C.)

### ¿for o while? Cuándo usar cada uno

USA FOR cuando sabes cuántas veces repetir: "haz esto 10 veces", "para cada usuario en la lista", "para cada número del 1 al 100".
USA WHILE cuando NO sabes cuántas veces: "pide la contraseña hasta que sea correcta", "lee datos hasta que el usuario escriba salir", "intenta conectar hasta que funcione".
En la duda, usa for. Es más seguro (no puedes crear un bucle infinito accidentalmente con for).

### Acumuladores: construir un resultado durante el bucle

Uno de los patrones más útiles con bucles es el ACUMULADOR: una variable que empieza en 0 (o vacía) y va creciendo en cada vuelta del bucle. Es como un cerdito hucha — cada vuelta metes una moneda y al final cuentas el total.

1# Patrón acumulador: sumar gastos
2gastos = [12.50, 8.99, 45.00, 3.20, 22.15]
3
4total = 0  # El acumulador empieza en 0
5
6for gasto in gastos:
7    total = total + gasto
8    print(f"  + {gasto:.2f}€ → Acumulado: {total:.2f}€")
9
10print(f"Total de gastos: {total:.2f}€")
11
12# Otro ejemplo: contar cuántos aprobados hay
13notas = [7.5, 4.2, 9.0, 3.8, 6.1, 8.4, 5.0]
14aprobados = 0
15suspensos = 0
16
17for nota in notas:
18    if nota >= 5:
19        aprobados = aprobados + 1
20    else:
21        suspensos = suspensos + 1
22
23print(f"Aprobados: {aprobados}, Suspensos: {suspensos}")

El acumulador es una variable que crece en cada iteración. Patrón fundamental en programación.

Consejo de senior: el patrón acumulador es el 90% de lo que harás con bucles en tu carrera. Sumar totales, contar ocurrencias, construir listas, concatenar texto... todo sigue el mismo patrón: inicializar → iterar → acumular → resultado. Graba esto a fuego.

### Ejemplo completo: el cajero automático

1# Mini cajero automático con bucle
2saldo = 1000.00
3# Lo que el usuario va tecleando, simulado (así puedes ejecutarlo aquí):
4acciones = ["consultar", "retirar", "ingresar", "salir"]
5cantidades = [0, 200.0, 50.0, 0]
6
7print("=== CAJERO BIGDATABANK ===")
8print(f"Saldo actual: {saldo:.2f}€")
9
10turno = 0
11opcion = ""
12while opcion != "salir":
13    opcion = acciones[turno]
14    print("")
15    print("Opciones: consultar / retirar / ingresar / salir")
16    print(f"¿Qué deseas hacer? {opcion}")
17
18    if opcion == "consultar":
19        print(f"Tu saldo es: {saldo:.2f}€")
20    elif opcion == "retirar":
21        cantidad = cantidades[turno]
22        if cantidad > saldo:
23            print("¡Saldo insuficiente!")
24        else:
25            saldo = saldo - cantidad
26            print(f"Retirados {cantidad:.2f}€. Nuevo saldo: {saldo:.2f}€")
27    elif opcion == "ingresar":
28        cantidad = cantidades[turno]
29        saldo = saldo + cantidad
30        print(f"Ingresados {cantidad:.2f}€. Nuevo saldo: {saldo:.2f}€")
31    elif opcion == "salir":
32        print("¡Hasta luego! Recoge tu tarjeta.")
33
34    turno = turno + 1
35
36# Cambia la lista de acciones y vuelve a ejecutar: el bucle se adapta solo.
37# Y fíjate: si quitas "salir" del final, el bucle no termina nunca.

Combina while (menú que se repite), if/elif (decisiones) y variables (saldo que cambia). ¡Esto ya es un programa de verdad!

### Resumen

for recorre una colección o un rango de números. Sabes cuántas veces se repite.
while repite mientras una condición sea True. No sabes cuántas veces de antemano.
range(n) genera números del 0 al n-1. range(a, b) va de a hasta b-1.
break sale del bucle inmediatamente.
El patrón acumulador: inicializar variable → iterar → acumular → resultado.
CUIDADO con bucles infinitos: asegúrate de que la condición del while eventualmente sea False.

Regístrate para guardar tu progreso.

## comentarios

Reporta erratas, ayuda a otros o comparte tu opinión. Sé constructivo.

Inicia sesión para comentar y responder.

cargando comentarios...