Pensamiento Computacional · Unidad 3 — Estructuras de control
Ciclo while
while repite mientras una condición sea verdadera. Si nada la vuelve falsa, el programa no termina nunca.
La explicación
Repetir sin saber cuántas veces
while n <= 3:
print(n)
n = n + 1
Imprime 1, 2, 3. La condición se revisa antes de cada vuelta: si al llegar ya es falsa, el cuerpo no se ejecuta ni una vez.
for o while
while cuando depende de algo (hasta que el usuario acierte)
Todo for se puede escribir con while, pero queda peor. Usá
while cuando de verdad no sabés cuántas vueltas van a ser.
Las tres partes que no pueden faltar
while bien escrito siempre tiene:
- Antes: inicializar la variable de la condición.
- La condición.
- Adentro: algo que acerque la condición a ser falsa.
n = n + 1 olvidado.
while n <= 3:
print(n) ← n nunca cambia: imprime 1 para siempre
break y continue
continue saltea el resto de esta vuelta y va a la siguiente
break es útil cuando encontraste lo que buscabas y no tiene sentido seguir:
clave = input("Clave: ")
if clave == "abc":
break
print("Incorrecta, probá de nuevo")
while True sería infinito, pero el break le da una salida. Es un patrón
válido y muy usado — siempre que exista un camino al break.
El ciclo que se cuelga con datos, no con código
A veces el while está bien escrito y aun así no termina, porque el dato que entra no
es el esperado. Un contador que baja de a 2 nunca llega exactamente a 1 si arrancó en par.
Por eso conviene usar <= o >= en vez de != en la
condición: while n != 0 es mucho más frágil que while n > 0.
Escribir una función que reciba un número y devuelva cuántas veces hay que dividirlo por 2 (división entera) hasta llegar a 1.
Por qué va while y no for. No sabés de antemano cuántas
vueltas van a ser: depende del número. Eso es exactamente el caso de while.
contador = 0
while n > 1:
n = n // 2 # esto acerca la condición a ser falsa
contador = contador + 1
return contador
Con n = 100:
Son 6 divisiones.
1. La condición es
n > 1 y no n != 1. Con
!=, si n llegara a 0 nunca sería exactamente 1 y el ciclo seguiría
para siempre. Con >, 0 tampoco cumple y corta igual.2. La línea que divide está adentro del ciclo. Si estuviera afuera,
n nunca cambiaría.
Control: probá con n = 1. Tiene que dar 0, porque la condición es falsa desde el principio y el cuerpo no se ejecuta nunca. Ese caso — el ciclo que da cero vueltas — es el que más se olvida de probar.
Escribir una función que devuelva la suma de los dígitos de un número usando un while, y otra que calcule su "raíz digital": sumar los dígitos repetidamente hasta que quede un solo dígito. Con 4729 tienen que dar 22 y 4.
Cómo se saca un dígito por vez. Dos operaciones alcanzan, y conviene entenderlas antes de escribir nada:
n // 10 → el número sin él 4729 // 10 = 472
La primera función:
s = 0
while n > 0:
s = s + n % 10
n = n // 10
return s
El ciclo, vuelta por vuelta, con 4729:
n = 472 → s = 11, n = 47
n = 47 → s = 18, n = 4
n = 4 → s = 22, n = 0
n = 0 → el while corta
Por qué while y no for. No se sabe de antemano cuántos dígitos tiene el número, así que no hay un rango que recorrer. El while es para cuando la condición de corte depende de lo que va pasando.
El n = n // 10 es lo que hace que el ciclo termine. Si se olvida, n nunca cambia, la condición n > 0 siempre se cumple y el programa se cuelga para siempre. Todo while tiene que tener adentro algo que empuje hacia la condición de salida, y conviene señalarlo con el dedo al escribirlo.
La segunda función, que usa la primera:
while n >= 10:
n = suma_digitos(n)
return n
La condición es >= 10, no > 10. Un número de un solo dígito es cualquiera entre 0 y 9; el 10 ya tiene dos y hay que seguir. Con > 10, el número 10 se devolvería tal cual, que tiene dos dígitos y no es una raíz digital.
Con 4729:
22 → 2+2 = 4 (un dígito, corta)
Y ahora el control independiente, que es lo mejor del ejercicio. La raíz digital coincide con el resto de dividir por 9, con la salvedad de que los múltiplos de 9 dan 9 en vez de 0:
999 % 9 = 0 → pero la raíz digital de 999 es 9
Se comprobó para los primeros 3.000 números y coincide en todos. Ese es un control de verdad: compara dos caminos completamente distintos —uno que suma dígitos y otro que divide por 9— y si el programa tuviera un error, no coincidirían.
De dónde sale esa coincidencia. 10 dividido 9 da resto 1, así que 100, 1000 y todas las potencias de 10 también dan resto 1. Entonces un número y la suma de sus dígitos dejan el mismo resto al dividir por 9 — que es exactamente la vieja "prueba del nueve" de la escuela primaria.
Dónde se pierde el punto: olvidar el n = n // 10 y colgar el programa, o escribir la raíz digital con un if en vez de un while. Con if se suma una sola vez, y un número como 199 necesita tres pasadas (199 → 19 → 10 → 1).
Dónde se cae la mayoría
- Olvidar la línea que modifica la variable de la condición: ciclo infinito.
- Usar != en la condición en vez de < o >, y pasarse de largo del valor de corte.
- Inicializar la variable adentro del ciclo, con lo que la condición nunca avanza.
Hasta acá la explicación. La práctica es la otra mitad: 8 ejercicios de este tema, en cuatro niveles, que no te dicen sólo si está bien al final sino que te corrigen en cada paso y te explican por qué. Y uno para escribir el programa vos, que se prueba ejecutándolo en Python ahí mismo, en el navegador. Además trae una animación que muestra la idea en movimiento.
Practicar Ciclo while →Dónde entra este tema en el parcial
- Primer parcial — Completar: buscar con un while20 puntos · resuelto paso a paso
- Primer parcial — Encontrar los errores y explicarlos30 puntos · resuelto paso a paso
- Segundo parcial — Encontrar y explicar los errores30 puntos · resuelto paso a paso
Los otros temas de la unidad 3
Estructuras de control