No tienes acceso a esta clase

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

Aprende todo un fin de semana sin pagar una suscripci贸n 馃敟

Aprende todo un fin de semana sin pagar una suscripci贸n 馃敟

Reg铆strate

Comienza en:

2D
3H
24M
16S
Curso B谩sico de Python

Curso B谩sico de Python

Facundo Garc铆a Martoni

Facundo Garc铆a Martoni

Aprendiendo bucles

21/32
Recursos

Un bucle es un ciclo continuo en todos los lenguajes de programaci贸n que nos permite iterar sobre nuestros pasos: magina un contador c铆clico (1,2,3,4,5,6鈥) donde puedes agregar un paso m谩s sobre tu programa principal.

Ejemplo de bucle en Python

Para este ejemplo, utilizaremos las potencias hasta llegar a un n煤mero determinado:

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

Ejemplo de bucle en la vida real

  • Despertar
  • Estudiar en Platzi
  • Comer
  • Dormir

Cuando repetimos estas acciones en ese orden, durante un tiempo determinado o infinito estamos hablando de un bucle.

Aporte creado por: Sandra Rojas, Rusbel Berm煤dez

Aportes 445

Preguntas 35

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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 鈥溾渙bligatorio鈥濃), 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 鈥渁prendiendo bucles鈥 debe ir antes de la 21 鈥淓l 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:
鈥傗傗傗俠loque 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:
鈥傗傗傗俠loque 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贸nredundancia 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(鈥楥iclo terminado鈥)

def ciclo2(num):
if num <= 1000:
print(num)
num= num*2
ciclo(num)
else:
print(鈥楥iclo terminado鈥)

def run():
num = 2
if num <= 1000:
ciclo(num)
else:
print(鈥楥iclo 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 鈥渆mul茅鈥 el bucle en una funci贸n y calcula las 鈥渘鈥 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 (鈥榠nput鈥) 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

el while true: sirve para hacer menus de selecci贸n que sean infinitos

.

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(""鈥渋ngrese 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 鈥渓indo鈥, 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