Bucles en Python — 3 programas que por fin tienen sentido

Los bucles en Python práctica real es lo que toca ahora. En el artículo anterior vimos la teoría de for y while. Ahora construimos tres programas desde cero en VS Code: un validador de contraseña con intentos limitados, una calculadora de factorial y una cuenta atrás. Además comparamos cómo el mismo problema se resuelve con for y con while para que quede claro cuándo usar cada uno.

Practicar los bucles en Python con programas reales es la forma más efectiva de entender cuándo usar for y cuándo usar while.

Crea una carpeta llamada practica_bucles y un archivo separado para cada programa. Si quieres ir más allá, usa pythontutor.com y ejecuta el código paso por paso

Bucles en Python práctica — Programa 1: Validador de contraseña con intentos limitados

Este programa usa while porque no sabemos cuántos intentos necesitará el usuario. Crea el archivo validador_contrasena.py.

Versión simple:

# Validador de contraseña — versión simple
CONTRASENA_CORRECTA = "Python2024"
MAX_INTENTOS = 3
intentos = 0

while intentos < MAX_INTENTOS:
    contrasena = input("Introduce la contraseña: ")
    intentos += 1

    if contrasena == CONTRASENA_CORRECTA:
        print("✓ Acceso concedido")
        break
    else:
        restantes = MAX_INTENTOS - intentos
        if restantes > 0:
            print(f"✗ Contraseña incorrecta — {restantes} intento/s restante/s")
        else:
            print("✗ Cuenta bloqueada — demasiados intentos fallidos")
```

Resultado con contraseña incorrecta tres veces:
```
Introduce la contraseña: python
✗ Contraseña incorrecta — 2 intento/s restante/s
Introduce la contraseña: Python
✗ Contraseña incorrecta — 1 intento/s restante/s
Introduce la contraseña: PYTHON2024
✗ Cuenta bloqueada — demasiados intentos fallidos

Versión mejorada con tiempo de espera simulado y feedback de seguridad:

# Validador de contraseña — versión mejorada
import time

CONTRASENA_CORRECTA = "Python2024"
MAX_INTENTOS = 3
intentos = 0
bloqueado = False

print("=== SISTEMA DE ACCESO ===\n")

while intentos < MAX_INTENTOS and not bloqueado:
    contrasena = input(f"Contraseña (intento {intentos + 1}/{MAX_INTENTOS}): ")
    intentos += 1

    if contrasena == CONTRASENA_CORRECTA:
        print(f"\n✓ Acceso concedido en el intento {intentos}")
        print("Bienvenido al sistema.")
        break
    else:
        restantes = MAX_INTENTOS - intentos
        if restantes > 0:
            print(f"✗ Incorrecta — {restantes} intento/s restante/s\n")
            time.sleep(1)    # simula tiempo de espera entre intentos
        else:
            bloqueado = True
            print("\n🔒 Cuenta bloqueada por seguridad")
            print("Contacta con el administrador para recuperar el acceso")

if bloqueado:
    print(f"\nRegistro: {intentos} intentos fallidos")

Fíjate en el while con dos condiciones combinadas: intentos < MAX_INTENTOS and not bloqueado. Si cualquiera de las dos falla el bucle termina. Esto es mucho más limpio que tener un if dentro para comprobar el bloqueo.

Bucles en Python práctica — Programa 2: Calculadora de factorial

El factorial de un número n (escrito n!) es el producto de todos los números del 1 al n. Por ejemplo 5! = 5 × 4 × 3 × 2 × 1 = 120. Crea el archivo factorial.py.

Este programa es perfecto para comparar for vs while:

# Factorial — comparativa for vs while
numero = int(input("Introduce un número entero positivo: "))

if numero < 0:
    print("Error: el factorial no existe para números negativos")
elif numero == 0:
    print("0! = 1  (por definición matemática)")
else:
    # CON FOR — sabemos exactamente cuántas veces repetir
    factorial_for = 1
    for i in range(1, numero + 1):
        factorial_for *= i

    # CON WHILE — misma lógica, diferente estructura
    factorial_while = 1
    i = 1
    while i <= numero:
        factorial_while *= i
        i += 1

    print(f"\n{numero}! calculado con for:   {factorial_for}")
    print(f"{numero}! calculado con while: {factorial_while}")
    print(f"\n¿Son iguales?: {factorial_for == factorial_while}")

    # Mostramos el proceso paso a paso
    print(f"\nProceso: ", end="")
    acumulado = 1
    for i in range(1, numero + 1):
        acumulado *= i
        if i < numero:
            print(f"{i}×", end="")
        else:
            print(f"{i} = {acumulado}")
```

Resultado con número 5:
```
5! calculado con for:   120
5! calculado con while: 120

¿Son iguales?: True

Proceso: 1×2×3×4×5 = 120

Esta comparativa directa deja muy claro por qué para el factorial usamos for, sabemos exactamente que vamos del 1 al n, así que el for con range() es la opción natural. El while funciona igual pero necesita más código para hacer lo mismo.

Bucles en Python práctica — Programa 3: Cuenta atrás con pausa

Crea el archivo cuenta_atras.py. Este programa usa for con range() en orden inverso, un uso de range() que no siempre se explica en clase:

# Cuenta atrás
import time

print("=== CUENTA ATRÁS ===\n")

segundos = int(input("¿Desde cuántos segundos? "))

if segundos <= 0:
    print("Error: introduce un número mayor que 0")
else:
    print()

    # range con paso negativo — cuenta hacia atrás
    for i in range(segundos, 0, -1):
        print(f"{i}...")
        time.sleep(1)    # espera 1 segundo real

    print("🚀 ¡Despegue!")

    # Bonus — versión con while para comparar
    print("\n--- Misma cuenta atrás con while ---\n")
    i = segundos
    while i > 0:
        print(f"{i}...")
        time.sleep(1)
        i -= 1
    print("🚀 ¡Despegue!")
```

Resultado con 3 segundos:
```
=== CUENTA ATRÁS ===

¿Desde cuántos segundos? 3

3...
2...
1...
🚀 ¡Despegue!

--- Misma cuenta atrás con while ---

3...
2...
1...
🚀 ¡Despegue!

El range(segundos, 0, -1) es clave, empieza en segundos, va hasta 1 (el 0 no se incluye) y va de uno en uno hacia abajo. El paso negativo -1 es lo que hace la cuenta regresiva.

De nuevo la comparativa es reveladora, aquí tanto for como while son igual de naturales porque sabemos el número de segundos de antemano. En estos casos usa for, es más limpio y pythónico.

El patrón del acumulador en los tres programas

Los tres programas usan el mismo patrón fundamental que vimos en teoría:

# Patrón acumulador — aparece en los tres programas
acumulador = valor_inicial    # antes del bucle

for/while ...:
    acumulador = acumulador operacion elemento    # dentro del bucle

usar(acumulador)              # después del bucle

# En el validador: intentos = 0 → intentos += 1
# En el factorial: factorial = 1 → factorial *= i
# En la cuenta atrás: i = segundos → i -= 1

Cuando veas un ejercicio de bucles en FP1 y no sepas por dónde empezar, pregúntate: ¿qué variable necesito acumular? Eso te da el punto de partida.

Resumen y siguiente paso

En este artículo de bucles en Python práctica construiste tres programas reales usando for y while en situaciones concretas. Viste while para intentos limitados con condición compuesta, for con range() normal e inverso, la comparativa directa for vs while en factorial y cuenta atrás, y el patrón del acumulador en los tres casos.

En el siguiente artículo encontrarás ejercicios propuestos para practicar por tu cuenta, con solución comentada al final.