Aprendiendo bucles

Se que la clase es de ciclos y se qué es un ciclo jajaja pero lo hice con recursividad JAJAJA y funciono:

def run(num, rept):
    if num <= rept:
        cont = num
        print(str(2 ** cont) )
        run(num+1, rept)
    else:
        print("Fin!")

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

El usuario ingresa la cantidad de potencias que quiere y calcula de manera recursiva cada potencia.

chicos si quieren tomar capturas de su código que se vean bien. Pueden usar CODESNAP una extensión de VSCODE

Cordial saludo comunidad

A continuación les dejo unas notas para mayor definición correspondiente a los bucles:

Espero sea de ayuda y cualquier comentario o sugerencia estaré muy atento.

Fuente: https://www.py4e.com/

Slds.

Hola les dejo mis notas en formato markdown en mi repo de github

https://github.com/rb-one/Curso_basico_python/blob/master/Notes/notes.md

Espero les sean de utilidad

Mi reto realizado:

def potencia(numero):
    
    potencia = 1

    while (potencia <= 10):
        
        result = numero ** potencia
        print('Potencia de {} elevado a la {} es {}'.format(numero, potencia, result))
        potencia += 1
        

def run():
    numero = int(input('Escribe el numero al cual quieres averiguarle la potencia: '))
    potencia(numero)


if __name__ == "__main__":
    run()

loops o bucles: Son estructuras de control que nos ayudan a repetir una o varias veces un bloque de comandos. Al igual que los condicionales, los loops usan una condición para establecer si debemos acabar la repetición o para especificar el número de veces que vamos a ejecutar nuestro código (tambien puede repetirse indefinidamente).

Tipos de loops:

* WHILE: Nos permite repetir un bloque de código siempre y cuando su condición sea verdadera.
* DO WHILE: A diferencia del ciclo while, este ejecuta el bloque de comandos antes de comprobar la condición para ejecutar la repetición.
* FOR: Tiene 3 partes: la inicialización (donde escribimos un poco código ““obligatorio””), la condición (si es verdadera ejecuta el bloque de código) y la actualización del contador (donde actualizamos nuestro código para comprobar si la condición se sigue cumpliendo o si ya podemos acabar la repetición).

No logré hacer el ejercicio inicial para calcular las potencias de 2… 😦 Esto definitivamente es de práctica hasta entender la lógica del código.

Todavía me falta aprender para poder hacer lo que ustedes aportan c:

reto completado!

el código está aquí: https://github.com/santigo171/learning-python/blob/main/potency1.py

def run():
    exp=0
    n=1
    while n<1000:
        print(n)
        exp+=1
        n=2**exp


if __name__ == "__main__":
    run()

La clase 22 “aprendiendo bucles” debe ir antes de la 21 “El ciclo While”, según el contenido y ejercicios que se venian desarrollando.

Lo que hace el juego de palabras, inicialmente había entendido "elevar un número hasta cierto limite"

y resultó ser "elevar un número X cantidad de veces"

🤦🏽‍♂️

BUCLES: la manera en que repetimos pasos sin usae exesivas linea de código.

Eso de pedir las potencias antes de llegar a mil es medio maldad 😕

Bucles condicionales (while)
while condición:
    bloque código

Repite la ejecución del bloque de código mientras la expresión lógica condición sea cierta.

Se puede interrumpir en cualquier momento la ejecución del bloque de código con la instrucción break.

El bloque de código debe estar indentado por 4 espacios.

<h1>Pregunta al usuario por un número hasta que introduce 0.</h1>

num = None
while num != 0:
… num = int(input('Introduce un número: '))
…
Introduce un número: 2
Introduce un número: 1
Introduce un número: 0

Alternativa:

<h1>Pregunta al usuario por un número hasta que introduce 0.</h1>

while True:
… num = int(input('Introduce un número: '))
… if num == 0:
… break
…
Introduce un número: 2
Introduce un número: 1
Introduce un número: 0

Bucles iterativos (for)
for i in secuencia:
    bloque código

Repite la ejecución del bloque de código para cada elemento de la secuencia secuencia, asignado dicho elemento a i en cada repetición.

Se puede interrumpir en cualquier momento la ejecución del bloque de código con la instrucción break o saltar la ejecución para un determinado elemento de la secuencia con la instrucción continue.

El bloque de código debe estar indentado por 4 espacios.

Se utiliza fundamentalmente para recorrer colecciones de objetos como cadenas, listas, tuplas o diccionarios.

A menudo se usan con la instrucción range:

range(fin) : Genera una secuencia de números enteros desde 0 hasta fin-1.
range(inicio, fin, salto) : Genera una secuencia de números enteros desde inicio hasta fin-1 con un incremento de salto.

palabra = 'Python’
for letra in palabra:
… print(letra)
…
P
y
t
h
o
n

for i in range(1, 10, 2):
… print(i, end=", ")
…
1, 3, 5, 7, 9, >>>

Compañeros del road code challenge, aquí les comparto mi solución, al fin estoy entendiendo los bucles.
Saludos

def run():
    numbers = list(range(0, 11))
    for n in numbers:
      print("2 elevado a la " + str(n) + " es igual a " + str(2**n))

if __name__ == '__main__':
  run()

El reto antes de aprender sobre bucles

def calcular(numero, potencia):
    calculo = numero ** potencia
    if calculo < 1000 :
        print("El nummero " + str(numero) + " elevado a la pontencia de " + str(potencia) + " es igual a " + str(calculo))
        return calculo
    else :
        print("Se impimieron todas las potencias posibles menores a 1000")
        quit()


def run():
    numero = int(input("Por favor marque el numero que se calcule su potencia: "))
    potencia = 2
    caculo_potencia = calcular(numero, potencia)
    potencia = potencia+1
    caculo_potencia = calcular(numero, potencia)
    potencia = potencia+1
    caculo_potencia = calcular(numero, potencia)
    potencia = potencia+1
    caculo_potencia = calcular(numero, potencia)
    potencia = potencia+1
    caculo_potencia = calcular(numero, potencia)
    potencia = potencia+1
    caculo_potencia = calcular(numero, potencia)
    potencia = potencia+1
    caculo_potencia = calcular(numero, potencia)
    potencia = potencia+1
    caculo_potencia = calcular(numero, potencia)
    potencia = potencia+1
    caculo_potencia = calcular(numero, potencia)
    potencia = potencia+1
    caculo_potencia = calcular(numero, potencia)
    potencia = potencia+1
    caculo_potencia = calcular(numero, potencia)
    potencia = potencia+1
    caculo_potencia = calcular(numero, potencia)
    potencia = potencia+1
    caculo_potencia = calcular(numero, potencia)
    potencia = potencia+1
    caculo_potencia = calcular(numero, potencia)
    potencia = potencia+1
    caculo_potencia = calcular(numero, potencia)
    potencia = potencia+1
    caculo_potencia = calcular(numero, potencia)
    potencia = potencia+1
    caculo_potencia = calcular(numero, potencia)
    potencia = potencia+1


if __name__ == "__main__":
    run()

Quise añadir la opción de elegir que base usar y además que se imprimieran los resultados de todos las potencias menores al limite escogido… Me salio algo asi (pdt: se que no usé bucles propiamente solo lo hice por diversión e.e)

#Función que corre la operación de potenciar y me permite trabajar con una base escogída al inicio de la ejecución del código
def result(base_tx, inicio):
    base_n = int(base_tx)
    potencia = base_n ** inicio
    return potencia

#Función principal que trabaja con parámetros de inicio y limite, imprime el resultado de cada potencia y suma 1 al inicio si el resultado es menor que el limite para repetir la funcion con valor de "inicio+1"
def run(inicio, limite):
    limite_n = int(limite)

    if result(base_tx, inicio) <= limite_n:
        inicio_tx = str(inicio)
        potencia_tx = str (result(base_tx, inicio))
        print( base_tx + " elevado a la " + inicio_tx + " es igual a " + potencia_tx )
        run(inicio+1, limite)

    else:
        inicio_tx = str(inicio)
        print( base_tx + " elevado a la " + inicio_tx + " supera el límite establecido " + "(" + limite + ").")


#Inicio de programa, se solicita limite y base con la que se desean trabajar
if __name__ == "__main__":
    limite = input("Ingrese un límite")
    base_tx = input("Ingrese un numero base")
    run(0, limite)

📌 Los bucles nos permitirán ejecutar varias veces nuestras líneas de código, eliminando la repetición ó redundancia de las mismas.

Ahí ta

Hola🖖, compañeros.

Aquí dejo mi código del reto de la clase, cualquier duda o comentario escríbanla, estaré al pendiente de su feedback👍.

Gracias😃, saludos.

def potencias(numero):
    for n_potencia in range(0, 21):
        numero_a_texto = str(numero)
        print(numero_a_texto + " elevado a la " + str(n_potencia) + " es igual a " + str(numero ** n_potencia))

def run():
    numero = int(input("Introduce un numero: "))
    potencias_del_numero = potencias(numero)


if __name__ == "__main__":
     run()

<code>receptor = int(input("¿Hasta donde quieres que pare? "))

numero = 1
while numero <= receptor:
    print(numero)
    numero = numero * 2
print(numero)
if numero >=  receptor:
    print("fin!")

![](

Uno de mis intentos fallidos… jaja

def main():
    exp = 0
    potencia = int(2 ** exp)
    if potencia <= 999:
        print('2^' + str(exp) + ' = ' + str(potencia))
        exp = exp + 1
        main()
    else:
        print('Finished')

if __name__ == '__main__':
    main()

objetive = int(input('Write a number: '))
canon = int(input('Write a canon: '))

for i in range(canon):
    result = objetive**i
    print(f'{objetive} elevado a la {i} es {result}')```

#we need to print al the 2 pow numbers from 1 to 10
number = 2
for i in range(10):
    print(number**2)
    number+=2

Mi código

def counter(maxCount):
    for i in range(maxCount+1):
        print(2**i)


def run():
    maxCount = int(input('Enter the max value of the counter:'))
    counter(maxCount)


if __name__ == '__main__':
    run()

El código está muy bueno Juan, pero no responde a la consigna que es elevar a 2 a una potencia tal que resulte menor que 1.000…

Con un bucle while:

## Imprimir potencias de 2, hasta el 1'000.000

def run():
    potencia = 0
    numero = 1

    while (numero <= 1000000):
        print('2 a la ',potencia, ' es igual a ',numero)
        potencia = potencia + 1
        numero = 2 ** potencia

if __name__ == "__main__":
    run()

Siempre pensé que el bucle fundamental era el for vaya qué cosas, aunque si que el bucle while es muy útil, en general los bucles nos sirven para resolver problemas muy repetitivos

def run():
    potencia = 0
    resultado = 0
    objetivo = 1000
    while resultado <= objetivo:
        resultado = 2**potencia
        if (resultado <= objetivo):
            print(f'2 elevado a {potencia} es igual a {resultado}')
        potencia += 1


if __name__ == '__main__':
    run()

Mejoro otro poquito el Código 🦾

#!/Library/Frameworks/Python.framework/Versions/3.9/bin/python3

def run(potencia_inicial, resultado):
    if resultado <=1000000:
        resultado = (2**potencia_inicial)
        # print(resultado)
        print('2 Elevado a ' + str(potencia_inicial) + ' es igual a: ' + str(resultado))
        potencia_inicial = potencia_inicial+1
        run(potencia_inicial, resultado)
    else:
        print('Fin!')

if __name__ == '__main__':
    potencia_inicial = 0
    resultado = 0
    run(potencia_inicial, resultado)

Este fue mi resultado:

/Library/Frameworks/Python.framework/Versions/3.9/bin/python3 /Users/jlquintero/Desktop/codigopython/bucles.py
2 Elevado a 0 es igual a: 1
2 Elevado a 1 es igual a: 2
2 Elevado a 2 es igual a: 4
2 Elevado a 3 es igual a: 8
2 Elevado a 4 es igual a: 16
2 Elevado a 5 es igual a: 32
2 Elevado a 6 es igual a: 64
2 Elevado a 7 es igual a: 128
2 Elevado a 8 es igual a: 256
2 Elevado a 9 es igual a: 512
2 Elevado a 10 es igual a: 1024
2 Elevado a 11 es igual a: 2048
2 Elevado a 12 es igual a: 4096
2 Elevado a 13 es igual a: 8192
2 Elevado a 14 es igual a: 16384
2 Elevado a 15 es igual a: 32768
2 Elevado a 16 es igual a: 65536
2 Elevado a 17 es igual a: 131072
2 Elevado a 18 es igual a: 262144
2 Elevado a 19 es igual a: 524288
2 Elevado a 20 es igual a: 1048576
Fin!
 codigopython % 

Así se me ocurrió a mí

def run(exponente,resultado_limite):
    resultado = 2**exponente
    if resultado < resultado_limite:
        print(str(resultado))
        run(exponente+1,resultado_limite)
    else:
        print("Se acabó el juego")

run(0,1000)```

Los bucles se utilizan cuando vamos a realizar la misma operación repetidas veces.
Su estructura consiste en: realizar una acción hasta que se cumpla una cierta condición que previamente hemos declarado.

Código de la aplicación que propuso Facundo pero usando el ciclo while:

def run():
    contador_repeticiones = 0
    while contador_repeticiones <= repeticiones:
        operacion = numero_base**contador_repeticiones
        print(operacion)
        contador_repeticiones = contador_repeticiones+1


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

Alguien sabe cómo sacar estas dos lineas en otro método?
    **numero_base = int(input("Introduce el numero base"))
    repeticiones = int(input("Introduce el numero de repeticiones"))**
Y poder usarlas luego las dos juntas.
Gracias de antemano

Así queda el ejercicio que pidieron ❤️

i=2
while i <= 10:
    resultado = 2**i
    print(resultado)
    i = i + 2

__no hice funciones porque no lo vi necesario para el ejercicio __

Realicé un bucle While buscando la forma correcta de hacer la sintaxis en Python y me funcionó, esto fue lo que escribí:

contador = 0
valor_deseado = 10000

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

Y el resultado obtenido fue:

El numero 2 elevado a la 0 es igual a: 1
El numero 2 elevado a la 1 es igual a: 2 
El numero 2 elevado a la 2 es igual a: 4 
El numero 2 elevado a la 3 es igual a: 8
El numero 2 elevado a la 4 es igual a: 16
El numero 2 elevado a la 5 es igual a: 32
El numero 2 elevado a la 6 es igual a: 64
El numero 2 elevado a la 7 es igual a: 128
El numero 2 elevado a la 8 es igual a: 256
El numero 2 elevado a la 9 es igual a: 512
El numero 2 elevado a la 10 es igual a: 1024
El numero 2 elevado a la 11 es igual a: 2048
El numero 2 elevado a la 12 es igual a: 4096
El numero 2 elevado a la 13 es igual a: 8192

Yo hace unos 2 años tome alguna clase de programación con php, pero había olvidado todo ya con todo este curso he ido refrescando memoria de todo aquello que aprendí hace un tiempo.

contador = 0
print("2 elevado a " + str(contador) + " es igual a: " + str(2**contador))

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

contador = 2
print("2 elevado a " + str(contador) + " es igual a: " + str(2**contador))

contador = 3
print("2 elevado a " + str(contador) + " es igual a: " + str(2**contador))

contador = 4
print("2 elevado a " + str(contador) + " es igual a: " + str(2**contador))

contador = 5
print("2 elevado a " + str(contador) + " es igual a: " + str(2**contador))```

def potencia(parm):
    exponente = 0
    while exponente <= parm:
        print('2 ** ' + str(exponente) + ' = ', 2**exponente)
        exponente = exponente+1


if __name__ == "__main__":
    potencia(int(input("Por favor ingrese la máxima potencia: ")))

def run():
    contador = 0
    while contador < 10:
        contador = contador + 1
        print("2 elevado " + str(contador) + " es igual a: " + str(2**contador))

if __name__ == "__main__":
    run()

numero = -1
while numero <= 19:
    numero = numero + 1
    potencia = 2**numero
    print("2 elevado a " + str(numero) + " es igual a " + str(potencia))

Buenas a todos, lo que hice yo fue crear dos funciones de ciclo que se autoinvoquen la una a la otra hasta que se cumpliera la condición, en un esfuerzo de hacer el ciclo artificial. Espero les sirva de inspiración!

def ciclo(num):
if num <= 1000:
print(num)
num= num*2
ciclo2(num)
else:
print(‘Ciclo terminado’)

def ciclo2(num):
if num <= 1000:
print(num)
num= num*2
ciclo(num)
else:
print(‘Ciclo terminado’)

def run():
num = 2
if num <= 1000:
ciclo(num)
else:
print(‘Ciclo terminado’)

if name == ‘main’:
run()

😅

print(2)
print(2*2)
print(2*2*2)
print(2*2*2*2)
print(2*2*2*2*2)
print(2*2*2*2*2*2)
print(2*2*2*2*2*2*2)
print(2*2*2*2*2*2*2*2)
print(2*2*2*2*2*2*2*2*2)
print(2*2*2*2*2*2*2*2*2*2)

Dejo el reto propuesto a mitad del video, realizado solamente con lo que hasta ahora dimos en el curso. Me llevó unas horas, pero salió! 😄

def recursion(base, result, power, end):
    result = base ** power
    if result <= end:
        print(str(base) + '^' + str(power) + ' = ' + str(result))
        recursion(base, result, power+1, end)


def run():
    menu = """
***** BIENVENIDO A LA CALCULADORA DE POTENCIAS *****

Ingresa una base, para conocer la potencia de
todos sus exponentes en orden ascendente, hasta el
posible mayor resultado a obtener que tu elijas.
    """

    print(menu)

    baseUser = int(input('Ingresa la base de la potencia: '))
    endUser = int(input('Ingresa el posible mayor resultado: '))

    recursion(baseUser, baseUser, 0, endUser)


if __name__ == '__main__':
    run()

que ansioso estoy por aprender mas.

Hice 3 versiones del reto.

Usando el ciclo for:

Usando el ciclo while:

Usando recursividad para generar el bucle:

Mi aporte c:

def potencias2 ():
    numero = 0
    while 2**numero < 1000000:
        ans = 2**numero
        numero = numero + 1
        print(ans)

potencias2()
 

I used the VSCODE extension called CodeSnap to capture this pretty picture.

Me encantan los retos de las clases, explicando y dejando ejercicios es la mejor forma de aprender.

def calculaPotencia(potencia):
    conteo = 0
    while conteo <= potencia:
        print("La potencia de 2 a la " + str(conteo) + " es: " + str(2**conteo))
        conteo = conteo + 1
    print("Esas fueron las " + str(potencia) + " potencias de 2")


def start():
    potencia = int(input("Ingresa hasta que potencia quieres calcular: \n"))
    calculaPotencia(potencia)


if __name__ == "__main__":
    start()

Al profe le quedo mas prolijo, pero bueno, es trabajo honesto.

Primer comentario y primer aporte:

Asi me quedo

def potencianding(p):
    valor = 2
    resultado = valor**p 
    print(resultado)
        
potencianding(0)
potencianding(1)
potencianding(2)
potencianding(3)
potencianding(4)
potencianding(5)
potencianding(6)
potencianding(7)
potencianding(8)
potencianding(9)
potencianding(10)

Yo no lo hice de esa forma, en el modulo donde tuvimos la tarea de buscar los operadores de raiz yo encontre la función pow que es power osea potencia en español.

Lo hice de la siguiente forma:

potencia = pow(2,20)

print(potencia)

Aproxime la potencia a la que elevendo el 2 mediera el millon y lo eleve.

Al final “emulé” el bucle en una función y calcula las “n” potencias que le pidas 😛

def potencia(i, entrada):
    if i <= entrada:
        print("2 ** " + str(i) + " es igual a " + str(2**i))
        i = i + 1
        potencia(i, entrada)
def run():
    print("******************************************************************************")
    print("* Bienvenido                                                                 *")
    print("* Este programa te pondra las potencias de 2                                 *")
    print("******************************************************************************")
    entrada = int(input("Indica cuantas potencias quieres : "))
    i = 0
    i = potencia(i,entrada)
if __name__ == '__main__':  
    run()

El bucle while es normalmente utilizado cuando no sabemos exactamente las veces en las que vamos a tener que repetir un proceso. Desde mi punto de vista, para este caso es mejor usar el ciclo for

Yo me olvide del operador ** para elevar a la potencia y lo hice un poco mas rebuscado [

def potencia(valor, exponente):
    if exponente > 0:
        total = valor ** exponente
        print("La potencia de {} a la {} es: {}".format(valor, exponente, total))
        potencia(valor, exponente - 1)
    else:
        print("Muchas gracias")


def run():
    valor = int(input("Escriba la base de la potencia a calcular: "))
    exponente = int(input("Escriba el exponente máximo a calcuar: "))
    potencia (valor, exponente)


if __name__ == "__main__":
    run()

def pow_two():
  num = int(input('Write a number: '))
  i=1
  while(i<=num):
    print(f'2 raised to {i}: {2**i}')
    i+=1

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

`i = 2
contador=1
while i < 1000:
  print("2 elevado a la " +str(contador) + " es " +str(i))
  i = 2**contador
  contador += 1 ````

def run():
    num = 2
    num2 = 1000
    i = 1  
    while i <= num2:
        potencia = num ** i 
        print(f'2 elevado a {i} es {potencia}')
        i = i + 1 

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

Mi aporte. Use solo un contador

numero = int(input('Dame un numero: '))
potencia = int(input('Dame una potencia maxima a calcular: '))

while potencia > 1:
    potencia -= 1
    print(numero**potencia)

def potencia(numero):
    for i in range(100):
        potencia = pow(numero, i)
        print(potencia)



if __name__ == "__main__":
    potencia(2)

Solución previa al desarrollo en clase, incluso se puede cambiar el valor del límite por una variable con entrada (‘input’) para poder cambiar de 1,000 a 1,000,000.

<code> 
def run(num,n):
    potencia = (num ** n)
    if potencia < 1000:
        n +=1 
        print(potencia)
        run(num,n)
    else:
        print('Este es el límite viejo.')

num = 2
n = 0

if __name__ == '__main__':
    run(num,n)

Código con el cambio a una variable de entrada:

def run(num,n,limite):
    potencia = (num ** n)
    if potencia < limite:
        n +=1 
        print(potencia)
        run(num,n,limite)
    else:
        print('Este es el límite viejo.')

num = 2
n = 0

if __name__ == '__main__':
    limite = int(input('Ingresa el número límite: '))
    run(num,n,limite)

Mis apuntes:
Los ciclos son fragmentos de código que se ejecutan hasta que una expresión lógica ocurra o se cumpla.

yo hice el programa pensando que era el exponente el que tenía que ser menor a 1000, ya se imaginarán el resultador en la consola
jajajaa

for numero in range (0,33,1):
print (numero **2)

Genial

like

.

No sabía que el ciclo While se era conocido como el bucle fundamenta.

perfecto, vamos con el bucle while

excelente ome u.u

Aqui podemos contrastar como es que los bucles nos ahorran tiempo y codigo

Intenté el código pero no me corrió el pequeño programa. Hay que practicar mucho más

Excelente Curso

Muy buena clase

print('Bucle FOR')

numero_veces = int(input('Ingresa el número de respusta que quieres: '))

for i in range(numero_veces):
  print('2 elevado a la ',i,' ',2**i)

print('\n Bucle While:')

contador = 0
while 2**contador < 1000:
  print('2 elevado a la ',contador,' ',2**contador)
  contador += 1```

Mi solución al reto:

Bucles. indispensables en la programacion

utilizando cualquier numero

def potencia(num,num2,pot):
    if(num <= pot):
        cont = num
        print(str(num2 ** cont))
        potencia(num+1,num2, pot)
    else:
        print('End')

if __name__ == '__main__':
    num2 = int(input('ingresa numero que le quieres sacar la potencia: '))
    pot = int(input('cantidad de potencias: '))
    potencia(0, num2, pot)```

for i in range(1000):
    print(2**i)

Reto hecho, cuidado al ejecutarlo son muchos números jeje…

def run(limite):
    resultado = 2 ** limite
    if limite <= 1000:
        print(f"2 ^ {limite} = {resultado}")
        run(limite + 1)


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

Hablamos de recursividad cuando una función se llama así misma.

colocandole un inicio con run me quedaria asi:

def potencia(incre,num):
incre = incre*2
print("potencia de 2 a la “,num,” = ",incre)
return incre

def run(rango):
incr=1
for num in range(1,rango):
incr = potencia(incr,num)

if name == ‘main’:
cantidad = int(input(""“ingrese la cantidad de veces
para realizar la potencia de 2 “””))
run(cantidad+1)

Esta es mi solución al reto.
No se si es lo que se solicitaba…
Pero aplique el bucle while que ya había trabajado en Java.

def potencia(base, potencia):
    resultado = 0
    while resultado < 1000:
        resultado = pow(base, potencia)
        print(resultado)
        potencia+=1


def run():
    base = int(input("Ingresa el número base: "))
    potencia(base, 0)


if __name__ == "__main__":
    run()

Practicando ingles

def get_power(power):
    accumulator=0
    while(accumulator<=power):
        print(f'power 2^{accumulator}={pow(2,accumulator)}')
        accumulator+=1

        
def run():
    power= int(input("Provide until which power of 2 you want to see: "))
    get_power(power)


if __name__ == '__main__':
    run()

Asi es como lo hice, mas o menos me di una idea de como se hace un while basandome en otros lenguajes y estuve probando hasta que funciono.

numero = 2
potencia = 1


while potencia != 1000:
    potencia = potencia + 1
    resultado = numero ** potencia
    print(str(numero) + " ** " + str(potencia) + " = " + str(resultado))

# BUCLES
# EXPLICACION FUNCIONAMIENTO DE BUCLES

# ELEVAR UN NUMERO HASTA LA POTENCIA INIDICADA

def potencias(num, limite):
    for i in range(0,limite):
        print(f'{num} elevado a {i} = {num**i}')


if __name__ == '__main__':
    num = int(input('Escoge un numero: '))
    limite = int(input('Hasta que numero lo quieres exponenciar?: '))
    potencias(num, limite)

Creo que me adelante cuando el profe me reto JAJA

flag = 1000
exponent = 1
value = 2**exponent
while value <= 1000000:
    print(value)
    exponent += 1
    value = 2**exponent

Hola, yo hice un programa para realizar potencias encadenadas, así se puede observar lo rápido que incrementan las cifras al hacer esta operación, les invito a probarlo en vuestro pc.

def run():
    print("--CONCATENACIÓN DE POTENCIAS--")
    numero = int(input("Qué número quieres elevar: "))
    exponente = int(input("A qué exponente lo quieres elevar: "))
    frecuencia = int(input("Cuántas veces quieres hacer la potencia: "))
    calcular(numero, exponente, frecuencia)
    

def calcular(num, exp, freq):
    # la variable "n" contiene el número que va a ser elevado, empezando por el que elige el usuario; en el bucle se va actualizando con cada potencia, 2^2 = 4, 4^2 = 8...
    n = num
    print("0.", num)
    for i in range (freq):
        result = n ** exp
        n = result
        print(str(i + 1) + ".", result)


if __name__ == "__main__":
    run()

Sin duda alguna, no es el codigo mejor optimizado y mas “lindo”, pero me siento bien porque es el primero usando solamente mis apuntes y los otros codigos de base

i = 1
n = 1000
while i < n:
    print(2**i)
    i = i+1