El ciclo while

Se puede cancelar un ciclo infinito si presionas Ctrl + c.
Espero este aporte apoye a alguien!

Para que no tengan que poner el str en el print lo mejor es poner f’ ’ y las variables entre corchetes {}. Esto lo aprendí de Aoresti

def run():
    LIMITE = 1000000
    contador = 0
    pontencia_2 = 2**contador
    while pontencia_2 < LIMITE:
        print(f'2 elevado a la {contador} es igual a {pontencia_2}')
        contador = contador + 1
        pontencia_2 = 2**contador

if __name__ == "__main__":
    run()```

Para quienes usen VS Code y quieran ahorrarse el escribir el inicializador, empiecen escribiendo dos guiones bajos “__” seguido de la m, entonces les aparecera un shortcut, le dan Enter y el inicializador

if __name__ == "__main__":
    pass

Se colocara automaticamente.

El unico loop infinito que debes tener es el de Aprendizaje, para que nunca pares de aprender B) XD

Un bucle while permite repetir la ejecución de un grupo de instrucciones mientras se cumpla una condición (es decir, mientras la condición tenga el valor True).

La sintaxis del bucle while es la siguiente:

while condicion:
    cuerpo del bucle

Python evalúa la condición:
si el resultado es True se ejecuta el cuerpo del bucle. Una vez ejecutado el cuerpo del bucle, se repite el proceso (se evalúa de nuevo la condición y, si es cierta, se ejecuta de nuevo el cuerpo del bucle) una y otra vez mientras la condición sea cierta.
Si el resultado es False , el cuerpo del bucle no se ejecuta y continúa la ejecución del resto del programa.

Para algunos será una pendejadita, pero llegué al siguiente video y vi el reto de programar las tablas, intenté y no pude. Estaba por decirme: UY, esto no es pa’ ti, déjate de vainas… Ok, tranquila, algo no has entendido. Revisa los videos nuevamente.
Ahora sí entendí mejor… dale, hazlo con WHILE primero y aquí está. Ahora voy para el FOR y lo haré.

son pequeños logros propios los que nos hacen felices y seguir avanzando. ❤️

def run():

    print("Tablas de multiplicar")
    tabla = int(input("Introduce la tabla de multiplicar que quieres ver: "))
    print(" ")
    print("La tabla del "+ str(tabla) + " es: ")
    contador = 0
    resultado = tabla*contador
    while contador < 13:
        print(str(tabla) + " X " + str(contador) + " = " + str(resultado))
        contador = contador + 1
        resultado = tabla*contador

if __name__ == "__main__":
    run()```

contador+=1

Hice el ejercicio viendo la clase sólo una vez en 2x y fue realmente duro porque jamás había hecho ni estudiado nada de programación, entonces esto fue un gran logro para mí y quiero compartirlo con la comunidad.

Si algun dia estan cansaditos de estudiar, y quieren relajarse un poco, PERO la conciencia les dice que tienen que estudiar, checken esta pagina https://codecombat.com/play/level/haunted-kithmaze?

Te enseña a programar python jugando! esta super cool!

otra manera de incrementar el contador de 1 en 1 seria:

contador +=1

En Python tiene una palabra reservada llamada while que nos permite ejecutar ciclos, o bien secuencias periódicas que nos permiten ejecutar código múltiples veces.

El ciclo while nos permite realizar múltiples iteraciones basándonos en el resultado de una expresión lógica que puede tener como resultado un valor True o False.

Haciendo este ejercicio por mi cuenta descubrí la importancia de el orden en que debe ir el código jajajjajja, estaba haciendo la de Superman, primero los pantalones y después los calzoncillos

No me malinterpreten pero estoy enamorandome de Python y de cómo enseña Facundo. Un MAESTRO.

def run():
    LIMITE = 1000
    
    contador = 0
    potencia_2 = 2**contador

    while potencia_2 < LIMITE:
        print("2 elevado a " + str(contador) + 
							" es igual a: " + str(potencia_2))
        contador = contador + 1
        potencia_2 = 2**contador


if __name__ == "__main__":
    run()

Cabe mencionar que el ciclo while es considerado un ciclo del tipo 0.X, debido a que es posible que el ciclo se repita de manera indefinida (X), o que dependiendo de la condición, no se ejecute ni una sola vez (0)

En el siguiente ejemplo, el ciclo while nunca se ejecutará, dado que la condición es falsa antes de empezar el ciclo

a=10
while a<5:
	print(a)

En el siguiente ejemplo, el ciclo while se ejecutará indefinidamente dado que la condición siempre será verdadera

a=10
while a>5:
	print(a)
	a=a+1

Nota: Para terminar la ejecución de un programa que entra en un bucle infinito, pulsar la combinación **CTRL+C**

Ahora el limite lo eliges tu en la consola 😃

def run():
    LIMITE = int(input("Escribe un número limite: "))

    contador = 0
    potencia_2 = 2**contador
    while potencia_2 < LIMITE:
        print("2 elevado a " + str(contador) + " es igual a: " + str(potencia_2))
        contador = contador + 1
        potencia_2 = 2**contador


if __name__ == "__main__":
    run()

**El entry point: **
Que menciono el profesor al principio…

Es lo que empieza a hacer el computador.

Recuerda que: Los computadores hacen solo lo que les decimos

Cuando le decimos al computador que ejecute un archivo bucle.py

El computador no sabe por donde empezar a ejecutar las instrucciones.

Por eso el if name == ‘main’: Siempre debe estar en los archivos .py que vayamos a ejecutar directamente:

En este caso python3 bucle.py

Eso le dice al computador, empiece desde esta linea (if __name…) y no importa si las funciones que va a ejecutar estan en otra parte del codigo como en este caso que estan antes.

Una forma más “elegante” de incrementar el valor de una variable, para no hacer lo siguiente:

contador = contador  + 1

Es esta:

contador += 1

En muchos lenguajes se usa de esta manera

Y la solución del vídeo.

def run():
LIMITE = 1000
contador = 0
potencia = 0
while potencia < 1000000:
print(potencia)
contador += 1
potencia = potencia = 2**contador

if name == ‘main’:
run()

Pude modificar el valor de una constante que creé sin problemas. Por qué el profe dijo que al definir una constante ésta se mantiene siempre invariable?

Podríamos decir que un ciclo se divide en cuatro partes:

• Declaración de variables globales: Son fundamentales para comenzar el ciclo, sin estas, while no tendría la suficiente información para comenzar.
• Declaración del ciclo: En esta parte va while junto a la condición, esta condición esta estrechamente relacionada con las variables globales anteriormente definidas.
• Bloque de código a repetir: El cuerpo del ciclo, aquello que se repetirá y que dará sentido a la función que estamos buscando.
• Contadores: Antes de terminar el ciclo, es esencial añadir valor incrementado a los contadores, para que el ciclo sea finito.

👾 En un ciclo while lo más importante es definir la condición.

def run():
    LIMITE = 1000

    contador = 0
    potencia = 2**contador
    while potencia < LIMITE:
        print('2 elevado a ' + str(contador) +
              ' es igual a: ' + str(potencia))
        contador = contador + 1
        potencia = 2**contador


if __name__ == '__main__':
    run()

Siempre pense que el ciclo for er mas fundamental que el ciclo while, en todas las clases se aprende algo diferente.

Por otro lado, es genial que el profesor este tan pendiente de las buenas practicas. Por experiencia digo, tener un archivo de codigo desordenado y sin estandarzar es un desastre.

Mi versión simplona.

base = 2
i = 0
limit = 1000000

while base ** i < limit:
    print(base ** i)
    i += 1

no sabia al respecto de la sintaxis de las constantes, bastante util, son detalles minimos peroq eu ayudan a mantener o agrega calidad al codigo

Excelente c:

El ciclo Platzi con la expresión ‘Nunca pares de aprender’ es un ciclo infínito c:

Variables Constanste: Son variables que no cambian atraves del tiempo su valor, es decir son variables constantes y dentro de Python para declararse se tiene que declarar de forma mayuscula:

* CONSTANTE = 1

**While: **Es un bucle que trabaja siempre y cuando los parametros sean verdaderos, en este caso tenemos los siguiente:

LIMITE = 1000
contador = 0
potencia_2 = 2**contador
while potencia_2 < LIMITE:
pass



--> Esto creara un bucle hasta que la variable potencia_2 deje de ser menor a LIMITE

limite = int(input("""
Bienvenido al programa joputa 😎
Encontraremos una potencia de 2 que resulte menor o igual al número que escribas 💻
Límite: """))
n = 0
potencia = 0

while potencia < limite:
    print(potencia)
    potencia = 2 ** n
    n += 1

“In Python, While Loops is used to execute a block of statements repeatedly until a given condition is satisfied. And when the condition becomes false, the line immediately after the loop in the program is executed. While loop falls under the category of indefinite iteration”

Así quedó mi código:

Así quedó mi código 💚

Download 'CodeSnap' in your VisualStudio to take some good screenshots of your code! Once downloaded. Click right-click over your code and use it.

def run():
LIMITE =1000
contador = 0
potencia_2 = 2 ** contador
while potencia_2 < LIMITE:
print(‘2 elevado a’+ str(contador)+‘es igual a :’+ str(potencia_2))
contador = contador + 1
potencia_2 = 2 ** contador

if name == ‘main’:
run()

En el “Curso de Buenas Prácticas para el Desarrollo de Código” aquí en Platzi, menciona acerca de evitar usar constantes, aunque aquí solo es para aprender lo básico de programación, trataré de programar con lo mínimo o cero de constantes 😉
Pero el curso es fantástico

Si quieren practicar la lógica de bucles les recomiendo el juego gratuito de Ubisoft: Rabbids Coding!

En mi caso, lo hice de esta forma:

def num (num, rept):
    while num <= rept:
        LIMITE = 1000
        potencia = pow(2,num)        
        if potencia >= 1000:
            break
        print(str(potencia))
        num += 1


if __name__ == "__main__":
    repeticiones = int(input("Cuantas potencias: "))
    num(0, repeticiones)

Así me quedó:

def main():
    for p in range(11):
        potencia = 2**p
        print("2 elevado a la",p,"=",potencia)

if __name__=="__main__":
    main()

Tabla de multiplicar el numero que quieras, hasta donde quieras.

def main():
    num = int(input("""Hola, que tabla de multiplicar deseas conocer?: """))
    LIMIT = int(input("Hasta que numero deseas conocer tu tabla: "))
    cont = 0

    while cont <= LIMIT: 
        print (""+ str(num) +" x "+ str(cont) +" = "+ str(num*cont) +"")
        cont = 1 + cont
            
if __name__ == "__main__":
    main()```

def run():
    LIMITE = 11
    contador = 0
    potencia = 2 ** contador

    while contador < LIMITE:
        print(f"2 elevado a {contador} es igual a {potencia}")
        contador += 1
        potencia = 2 ** contador


if __name__ == "__main__":
    run()

😄

def run():
    limite = input("Hasta que numero quiere que elevemos a la potencia al 2\n");
    limite = int(limite);
    contador = 0;
    potencia_2 = 2**contador;

    while contador <= limite:
        print("2 elevado a " + str(contador) + " es: " + str(potencia_2));
        contador = contador + 1;
        potencia_2 = 2**contador;

if __name__ == "__main__":
    run()

Resultado

Sin la posibilidad de los ciclos sería más largo que la biblia escribir un programa. Súper herramienta.

Otra forma muy similar:

Tambien pueden usar “format” para concatenar.

def run():
    LIMITE = 1000
    contador = 0
    potencia_2  = 2**contador
    while potencia_2 < LIMITE:
        print("2 elevado a {} es igual a : {}".format(contador, potencia_2))
        contador = contador +1
        potencia_2 = 2**contador

if __name__ == "__main__":
    run()```

Se me ocurrió que sea el usuario que determine el limite, en este caso la potencia máxima y que también escoja que numero desea elevar.

def run():
    limite = int(input("¿Limite maximo de la potencia? " ))
    contador = 0
    numero = int(input("¿Que numero quieres elevar? "))
    pontencia_2 = numero ** contador
    while contador <= limite:
        print(str(numero) + ' elevado a ' + str(contador) + ' es igual a ' + str(pontencia_2))
        contador = contador + 1
        pontencia_2 = numero ** contador


if __name__ == "__main__":
    run()
    import getpass
    getpass.getpass("enter")

#While
#constante lo opuesto a una variable las constantes no cambian. Las constantes van en mayusculas.

def run ():
    LIMITE = 1000

    contador = 0
    potencia_2 = 2**contador
    while potencia_2 < LIMITE:
        print('2 elevado a ' + str(contador) + ' es igual a: ' + str(potencia_2))
        contador = contador + 1
        potencia_2 = 2**contador

if __name__ == '__main__':
    run()

Yo lo hice de esta forma, así la persona puede introducir qué valor desea elevar.

def run ():
    LIMIT = 1000


    potencia = 0
    base = int(input('Introduce el valor que deseas elevar: ')) 
    resultado = base**potencia
    while resultado <= LIMIT:
        print (str(base) + ' elevada a ' + str(potencia) + ' es igual a ' + str(resultado))
        potencia = potencia + 1
        resultado = base**potencia
   

if __name__ == "__main__":
    run()

Yo hice este, el usuario puede seleccionar la base y el limite. 😛

#menu
menu = """
Bienvenido al calculador de potencias.
Para iniciar selecciona una base: """

menu2 = """
Selecciona el limite del resultado: """


#programa
def main():
    base = int(input(menu))
    limite = int(input(menu2))
    contador = 0
    potencia = 0
    
    while potencia < limite:
        print(str (base) + " elevadoa a " + str(contador) + " es igual a= " + str(potencia))
        contador = contador + 1
        potencia = base**contador


if __name__ == "__main__":
    main()```

Un pequeño ejemplo

def run():
LIMITE = 10000

contador = 0
potencia_2 = 2**contador
while potencia_2 < LIMITE:
    # str cambia a strings
    print('2 elevado a la: ' + str(contador) +
          ' es igual a : ' + str(potencia_2))
    contador = contador + 1
    potencia_2 = 2**contador

if name == ‘main’:
run()

Así quedo el código

def run():
    LIMITE = 1000

    contador = 0
    potenciador = 2**contador

    while potenciador < LIMITE:
        print("2 elavado a" + str(contador) + "es igual a: " + str(potenciador))
        contador += 1
        potenciador = 2**contador


if __name__ == '__main__':
    run()

#we need to print al the 2 pow numbers from 1 to 10
def main():
    LIMIT = 10
    counter = 0
    two_Power = 2**counter
    while counter < LIMIT:
        counter += 1
        two_Power = 2**counter
        print(two_Power)

if __name__ == '__main__':
    main()

un poco difererente

def main():
    num=int(input("escribe el numero a potenciar: "))
    n=0
    potem=float(0)
    while potem <=1000:
        n=n+1
        potem=num**n
        if potem <=1000:

             print("el resultado de potenciar ",num,"por ",n,"es igual a", potem)

if __name__ == "__main__":
    main()```

Al final del video… “2 elevado a un millón” … Facundo lo que quiso decir es “2 elevado a 20” …si alguien lo quiere hacer en el Cmder se asustaría del numero tan largo que dá … 😃

Así quedo mi código

def run():
    
    numero = int(input("Dame un numero: "))
    contador = 0
    potencia= numero**contador
    while raíz < 1000:
        print("El numero " + str(numero) + " eleveda a " + str(contador) + " es igual a " + str(potencia))
        contador = contador + 1
        potencia= numero**contador


if __name__ == "__main__":
    run()

CODIGO COMENTADO

def run(): # definimos funcion principal 
    # la definimos como constante 'LIMITE' con mayusculas
    LIMITE = 1000000
    # Definimos la variable contador i = 0
    contador = 0 
    # Definimos la variable de la potencia
    portencia_2 = 2**contador
    # miestras la potencia de 2 se menor que LIMITE = 1000
    while portencia_2 < LIMITE:
        # Ejecuta el siguiente codigo 
        print('2 elevado a ' + str(contador) + 
        ' es igual a: ' + str(2**contador)) 
        # Sumamos en cada iteración 1 a la variable contador 
        contador = contador + 1
        # Actualizamos la variable potencia 
        portencia_2 = 2**contador



if __name__ == '__main__': # Punto de entrada 
    run()

Distintas formas de hacer el print 😊

def run():
LIMITE = 100000

contador = 0
potencia_2 = 2**contador
while potencia_2 < LIMITE:
    print(f'2 elevado a {(str(contador))} es igual a: {str(potencia_2)}')
    contador += 1
    potencia_2 = 2**contador

if name == ‘main’:
run()

Esta explicación se me hace interesante para entender el tema

https://www.freecodecamp.org/espanol/news/explicacion-del-bucle-while-de-while/

Le hice una mejora para que el usuario escoja el número a elevar y el límite de las potencias. 😄

def main():
    numero=input("Digita el número que quieres elevar a potencias: ")
    numero = float(numero)
    limite = input("Digita el límite al que llegarán las potencias: ")
    limite = float(limite)
    contador = 0
    resultado = numero**contador

    while resultado < limite :
        print(str(round(numero,1))+"^"+str(contador)+ " = " +str(resultado))
        contador=contador+1
        resultado=numero**contador

if __name__ == "__main__":
    main()

Mi codigo con menu y el mensaje de output

def validar_input():
    input_usuario = (input(menu))
    try:
    # Validar si es un número entero
        limite = int(input_usuario)
        powers_of_two(limite)
    except ValueError:
        try:
        # Validar si es un número decimal
            limite = float(input_usuario)
            print('Ingresa un número entero por favor')
        except ValueError:
            print('Ingresa un número entero por favor')


def powers_of_two(limite):
    i = 0  #contador
    numbers = 2**(i)
    while numbers <= limite:
        print(f'2 elevado a la {i} es igual a {numbers}')
        i = i + 1
        numbers = 2**(i)


menu = '''
Bienvenido (a)

Vamos a calcular potencias de 2

Escribe el resultado límite: '''


if __name__ == '__main__':
    validar_input()

Información resumida de esta clase
#EstudiantesDePlatzi

• While es conocido como el ciclo fundamental

• Para definir una constante escribo su nombre en MAYÚSCULA

• Importante saber inglés

• Si queremos imprimir algo, debemos convertirlo en texto con str

compañ[email protected] les comparto el script que logre hacer para que nosotros elijamos que numero queremos elevar y cuantas veces lo elevaremos

contador = 1 
numero = int(input("¿Que numero quieres elevar? "))
cantidad = int(input("¿Cuantas veces quieres elevar el {}? ".format(numero)))

while contador <= cantidad: 
    print(str(numero) + " a la " + str(contador) + " es igual a " + str(numero ** contador)) 
    contador+=1 

Por fin logré hacer una.

a = 0

while a < 9:
    potencia = 2**a
    print( "2 elevado a la " + str(a) + " es igual a "  + str(potencia) )

    a = a+1

Me aburri intentando probar el limite :v

El contador especificando el limite

def run():
     limite = int(input("Vamos a desglosar la potencia de 2 ¿Hasta que numero quieres llegar? establece el limite: "))
     contador = 0
     potencia_2 = 2**contador
     while potencia_2 <= limite:
         print("2 elevado a " + str(contador) + " es igual a: " + str(potencia_2))
         contador = contador + 1
         potencia_2 = 2**contador


if __name__ == "__main__":
    run()

Here you have my contribution.

Muy buena explicación la de Facundo.

🟢Cero elevado a la cero también es 1 o indefinido (según el contexto)
(min 3:10)

Muy buen profesor Facundo.

BUENA CLASE PROFE
SUPER DINAMICO LO DE IR LEYENDO EL CODIGO

excelente, muy bien muy buena clase

def run():
    LIMITE = 1000000

    contador = 0
    potencia_2 = 2**contador
    while potencia_2 < LIMITE: 
        print("2 elevado a " + str(contador) + 
            " es igual a: " + str(potencia_2))
        contador = contador + 1
        potencia_2 = 2**contador

if __name__ == "__main__":
    run()```

También se puede usar como contador+=1```, algo que veo que no funciona es usarlo comocontador++D: Eso es fundamental en cualquier lenguaje de programación! Esto es inédito! jaja como sea, mirando los snippets para Python de Visual Studio Code, me tope con que existe unwhile/else``, ya me imagino para qué sirve… 👀

Una explicación muy fácil de entender. Muchas gracias

def run():
    veces = int(input("""
    Bienvenido al programa de potencias 🖌

    El programa imprimirá todos los resultados de las potencias desde la potencia 1 hasta la que escribiste 😉
    Escribe la potencia por la que quieras elevar el número 2: """))

    contador = 1
    while contador < veces:
        print(2 ** contador)
        contador += 1

if __name__ == "__main__":
    run()

Muy bien explicado!!! Genio!

me estuve matando la cabeza 30 minutos por que no encontraba el error JAJAJAJAJAJAJ

do

epico el ciclo while, eras de mostrar como se hacian infinitamente las lineas jajaja

Este fue mi ejemplo:

Con este resultado:

def run():
    LIMITE = 1000

    contador = 0
    potencia_2 = 2**contador
    while potencia_2 < LIMITE:
        print("El numero 2 elevado a la " + str(contador) + " es igual a: " + str(potencia_2))
        contador = contador + 1
        potencia_2 = 2**contador


if __name__ == '__main__':
    run()

Muchísimas gracias.

def run():
    limite = input('Escribe un número entero para definir el límite: ')
    LIMITE = int(limite)

    contador = 0
    potencia_2 = 2**contador
    while potencia_2 < LIMITE:
       print ('2 elevado a ' + str(contador) + ' es igual a: ' + str(potencia_2))
       contador = contador + 1
       potencia_2 = 2**contador
    print('Fin del bucle')


if __name__=='__main__':
    run()

Lo modifiqué un poco para que solicite el Límite al usuario y nos indique el fin del bucle

El programa con dos pequeños cambios:

<code>
def run():
    LIMITE = 1000000
    contador = 0
    potencia_2 = 1
    while potencia_2 <= LIMITE:
        print('2 elevado a ' + str(contador) +
              ' es igual a: ' + str(potencia_2))
        contador = contador + 1
        potencia_2 = 2**contador


if __name__ == '__main__':
    run()

a aprender ingles entonces!

Siguiendo el estandar de colocar espacios entre las variables y un operador, lo apliqué para obtener la potencia y si lo hace:

limite = base ** contador

Aquí dejo mi código. El nombre de las variables es distinto, porque lo hice desde cero, esto es, sin copiar el código de Facundo.

def run():
print(“dentro de la funcion run”)
limite = 0
contador = 0
base = 2

while limite < 100000:
    limite = base ** contador
    print("2 elevado a la " + str(contador) + "es igual a " + str(limite))
    contador = contador + 1

if name == “main”:
run()

def run():
    LIMITE = 1000
    
    contador = 0
    potencia_2 = 2**contador
    while potencia_2 < LIMITE:
        print(f"2 levado a {contador} es igual a: {potencia_2}")
        contador = contador + 1
        potencia_2 = 2**contador


if __name__ == "__main__":
    run()```

Escribiendo el código ya me había dado cuenta del error del str antes que lo diga, hasta había probado el programa
Recien a esta altura del curso hice algo por mi cuenta :,v
Soy bastante lento ajaja

Infinite Loop en Bases de Datos lo llamamos “Burnt wallet”, por que puede llegar a hacer multiples peticiones y cada peticion cuesta dinero… Por lo que os lo podeis imaginar

Mi pequeño aporte

def main(contador, maximo, num):

	while contador<=maximo:
		print(f"{num} elevado a {contador} es = {num**contador}")
		contador+=1

if __name__=="__main__":
	contador=0
	maximo=int(input("¿Hasta que potencia desea llegar? "))
	num=int(input("Ingrese el numero a elevar: "))
	main(contador, maximo, num)

Por aquí les dejo mi código

def run():
#Los constantes a diferencia de las variables se escriben en mayúscula, por eso LIMITE
    LIMITE = 1000

    count = 0
    power_2 = 2**count
    while power_2 < LIMITE:
        print("2 elevado a " + str(count) + " es igual a " + str(power_2))
        count += 1
        power_2 = 2**count

if __name__ == "__main__":
    run()

Mi código cualquier numero poder ingresar.

def run():
    LIMITE = 1000000
    contador = 0
    numero = int(input('Ingrese un numero: '))
    potencia_2 = numero**contador
    while potencia_2 < LIMITE:
      print (str(numero) + ' elevado a ' + str(contador) + 
              ' es igual a = ' + str(potencia_2))
      contador = contador + 1
      potencia_2 = numero**contador


if __name__ == '__main__':
    run()```

El mismo programa pero con un número que nos da el usuario.

def run():
  LIMITE = 100000
  contador = 0
  n= int(input())
  potencia_n = n**contador
  while potencia_n < LIMITE:
    print("El número elevado a " + str(contador) + "es igual a: " + str(potencia_n))
    contador += 1
    potencia_n = n**contador


if __name__  == '__main__':
  run()```

necesito mas explicacion del ciclo while :c no lo entiendo en la practica

Es muy bonito cuando empiezas a ver los ciclos con While

Nice!