No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Curso B谩sico de Python

Curso B谩sico de Python

Facundo Garc铆a Martoni

Facundo Garc铆a Martoni

El ciclo while

22/32
Recursos

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.

Ejemplo de while en Python

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()

Consejo: se puede cancelar un ciclo infinito si presionas Ctrl + c.

Aporte creado por: Karla Agraz, Rusbel Berm煤dez

Aportes 451

Preguntas 104

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Reg铆strate o inicia sesi贸n para participar.

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.

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.

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

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.

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()

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

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()

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**

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()

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?

Una forma m谩s 鈥渆legante鈥 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 == 鈥榤ain鈥:
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.

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.

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

Mi versi贸n simplona.

base = 2
i = 0
limit = 1000000

while base ** i < limit:
    print(base ** i)
    i += 1
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

鈥淚n 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鈥

Excelente c:

El ciclo Platzi con la expresi贸n 鈥楴unca pares de aprender鈥 es un ciclo inf铆nito c:

As铆 qued贸 mi c贸digo:

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

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:

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()```

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

En el 鈥淐urso 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

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()

def run():
LIMITE =1000
contador = 0
potencia_2 = 2 ** contador
while potencia_2 < LIMITE:
print(鈥2 elevado a鈥+ str(contador)+鈥榚s igual a :鈥+ str(potencia_2))
contador = contador + 1
potencia_2 = 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()

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

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鈥 鈥i 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 raz < 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 iteracin 1 a la variable contador 
        contador = contador + 1
        # Actualizamos la variable potencia 
        portencia_2 = 2**contador



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

As铆 qued贸 mi c贸digo 馃挌

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()

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()

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")

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()

las plantas de los programas o las apps y el mismo escritorio es un bucle infinito 馃憣馃憣馃憣

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(鈥渄entro 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 鈥淏urnt 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()```

Tambien pueden usar 鈥渇ormat鈥 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()```

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!

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()

Algo fundamental es determinar la condici贸n y al comienzo es bastante com煤n colocar la condici贸n mal y que el programa no pare (bucle infinito), cuando esto suceda presionen Ctrl+c y listo terminar谩 ah铆.

馃槑

def pow(elevar, limite):
    count = 0
    potential = elevar**count
    while potential < limite:
        print(str(elevar) + ' elevado a ' +
              str(count) + ' = ' + str(potential))
        count = count + 1
        potential = elevar**count


def run():
    print("Elevar un numero a un l铆mite  馃ぁ")
    elevar = int(input("Cual es el n煤mero a elevar: "))
    limite = int(input("Cual es el n煤mero l铆mite: "))
    pow(elevar, limite)


if __name__ == '__main__':
    run()

#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()