No tienes acceso a esta clase

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

Iteraciones

9/31
Recursos

Aportes 455

Preguntas 39

Ordenar por:

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

o inicia sesi贸n.

Lo que le pas贸 a la memoria eliminando el contador interno:

El 煤nico loop infinito que debes hacer es:

!Nunca Parar de Aprender!


Mi diagrama de flujo de un reloj

Vengo de Java, no puedo quitarme la man铆a de ponerle punto y coma a todo;

Cuando se quita el contador interno se queda en un ciclo infinito.
Me divert铆 haciendo este ensayo con estos ciclos:

Yo finalmente tras haber visto el v铆deo un par de d铆as atr谩s les comparto mi peque帽o programa que hice para practicar lo visto. De manera chistosa, todo empez贸 con una idea boba que me dio mi pap谩 y luego la comenc茅 a hacer, pero me encontr茅 con ciertos defectos y la fui corrigiendo linea por linea hasta finalmente hoy naci贸 este programa no perfecto pero funcional 馃槂

#Inicio
numero_usuarios_original = int(input('Favor de indicar el n煤mero de usuarios: '))
numero_usuarios = numero_usuarios_original
while numero_usuarios >= 1:
    if numero_usuarios == 0:
        break

#Bienvenida
    usuario = input('Bienvenido estimado usuario, favor de ingresar su nombre: ')

#Solicitando edad actual y calculando edad despu茅s del cumplea帽os.
    edad_usuario = int(input('Favor de proporcionar su edad actual: '))
    edad_usuario += 1
    print('Gracias, ahora...')

#Fecha actual y pr贸ximo cumplea帽os
    from datetime import datetime
    fecha_actual = datetime.now()

    dia_actual = datetime.strftime(fecha_actual, '%d')
    dia_actual = datetime.strptime(dia_actual, '%d')

    mes_actual = datetime.strftime(fecha_actual, '%b')
    mes_actual = datetime.strptime(mes_actual, '%b')

    print('Favor de proporcionar la fecha de su pr贸ximo cumplea帽os conforme se le vaya solicitando')
    dia_proximo = (input('D铆a: '))
    mes_proximo = (input('Mes: '))
    a帽o_proximo = (input('A帽o: '))
    print('')

    fecha_proximo = (f'{dia_proximo}/{mes_proximo}/{a帽o_proximo}')
    fecha_proximo = datetime.strptime(fecha_proximo, '%d/%m/%Y')

#C谩lculo de das restantes
    tiempo_restante = fecha_actual - fecha_proximo
    tiempo_restante = tiempo_restante.days
    tiempo_restante = tiempo_restante * -1

#Cambio de formato a la fecha del cumplea帽os
    fecha_proximo = datetime.strftime(fecha_proximo, '%d %b %Y')

#Resultado
    print('Listo!')
    print(f'Dentro de {tiempo_restante} das, el {fecha_proximo} cumplir谩s {edad_usuario} a帽os!')
    print('')

    numero_usuarios -= 1

    while numero_usuarios >= 1:
        print(f'Gracias por tu tiempo {usuario}, proseguimos con el siguiente usuario...')
        break

#Despedida del programa
if numero_usuarios_original == 1:
    print('Gracias por tu tiempo y atenci贸n, ten un lindo d铆a...')
    print('Y felicidades anticipadas por tu pr贸ximo cumplea帽os!!')
elif numero_usuarios_original == 2:
    print('Gracias a ambos por su atenci贸n, tengan un lindo d铆a...')
    print('Y felicidades anticipadas a ambos!!')
else:
    print('Gracias a todos por su atenci贸n, espero tengan un lindo d铆a...')
    print('Y felicidades anticipadas a los cumplea帽eros!!')

RESUMEN


En esta clase vimos que los iteradores son estructuras de control que me permiten llevar un flujo siempre que una condici贸n se cumpla. Si esta condici贸n se cumple eternamente, y no le decimos al programa que se detenga se generar谩 un infinit loop.

Adjunto el c贸digo de esta clase donde vemos un ciclo While anidado dentro de otro.

contador_externo=0
contador_interno=0

while contador_externo <5:
    while contador_interno <6:
        print(contador_externo,contador_interno)
        contador_interno+=1
        # contador_interno += 1 --> Si eliminamos esto, habr谩 un bucle infinito de ceros porque el contador nunca avanza,
        # y es el contador interno el que define el externo.

        if contador_interno >=3:
            break # Esto es un break statement qu eme dice que cuando mi contador interno sea 3, pare.
            # Solo debe parar el contador interno, pues el externo tiene un contador por si mismo y seguir谩 la ejecuci贸n

    contador_externo+=1
    # contador_externo += 1 --> Si elimino esto, al ser el contador externo siempre 0, le estoy diciendo que vaya hasta infinito, y el c贸digo interno
    # se seguir谩 ejecutando de 0 a 5 indefinidamente
    contador_interno=0
    # contador_interno=0  --->Eliminar este implica que contador_interno solo tendr谩 la oportunidad de ejecutarse de 0 a 5.

# El c贸digo en general tiene dos mecanismos uno interior que hace ciclos cortos, y uno exterior que envuelve los ciclos.
# Son estructuras de control anidadas.

Al eliminar el contador interno, ambos contadores entraron en un infinite loop de ceros.
Como el contador interno nunca pudo aumentar de uno en uno, jam谩s lleg贸 a 6, por lo que el contador externo tampoco pudo empezar a aumentar de uno en uno. Dos filas de ceros hasta el infinito.

from datetime import datetime
import time
import sys

now = datetime.now()
hrs = now.hour
min = now.minute
sec = now.second

while hrs<24:
    while min<60:
        while sec<60:
            current = str(hrs).zfill(2) + " : " + str(min).zfill(2) + " : " + str(sec).zfill(2) + "\r"
            sys.stdout.write(current)
            sec += 1
            time.sleep(1)
        min += 1
        sec = 0
    hrs += 1
    min = 0

reloj.py

horas = 0
minutos = 0

while horas<24:
  while minutos<60:
    print(horas,':',minutos)
    minutos += 1

  horas += 1
  minutos = 0

cls
comando para borrar la terminal

Mientras la secuencia de acciones o instrucciones no genere un valor falso, el ciclo va seguir indefinidamente.

while True:
	print("cree en ti")

Ac谩 esta el c贸digo de la creaci贸n de un relog de 24 horas.

hora, minu, seg = 0, 0, 0

while hora < 24:
    while minu < 60:
        while seg < 60:
            print(hora, minu, seg)
            seg += 1
        
        minu += 1
        seg = 0
    
    hora += 1
    minu = 0

Si quieren ver el algoritmo de como hacerlo paso a paso en cualquier lenguaje de programaci贸n pueden encontrarlo ac谩:
https://github.com/EdinsonRequena/articicial-inteligence-and-data-science/blob/master/introduccion-al-computo-con-python/modulo_I/iteraciones02.py

Un reloj es una muy buena manera de explicar las iteraciones 馃榾馃憤馃徎

Si eliminas el incremento del contador interno, creas un ciclo infinito porque nunca pasar铆a de 0, por esta raz贸n nunca saldr铆a del while interno ya que 0 siempre ser铆a menor que 6.

un caso similar a usar += y bastante 煤til es /= que se usa para decir
a = a/numero es a/=num

  • Si eliminamos: contador_interno += 1 se genera un infinite loop, ya que siempre ser铆a verdad (al inicio dicho contador se le asign贸 cero)

  • Si eliminamos: contador_externo += 1 tambi茅n se genera un infinite loop, como al inicio se asigno el valor de cero, siempre ser谩 verdad.

  • Si eliminamos: contador_interno = 0 ocurre solo una iteracion, pues como queda asigando el valor de 6 al contador_interno el segundo while va ser falso siempre. (no hay un infinite loop)

horas = 0
minutos = 0
segundos = 0

while horas < 24:
    while minutos < 60:
        while segundos < 60:
            print(f'{horas}:{minutos}:{segundos}') 
            segundos += 1
        minutos += 1
        segundos = 0
    horas += 1
    minutos = 0

Un reloj 鉂わ笍

al eliminar el contado interno se hace un bucle infnito /////
Se puede parar ese bucle con ctrl + z y nos evitamos cerrar la terminal.

Iteraciones (loops)
Nos permiten realizar la misma tarea en varias ocaciones
Sintaxis:
while <condicion>:
<expresion>
repite la expresion mientras la condicion sea verdadera

Loop anidado
while <condicion>:
while <condicion>:
<expresion2>
<expresion1>
Ejecutamos la expresion2 un numero determinado de veces cada vez que se ejecuta la expresion1. Podemos usar un reloj como analogia a este codigo la expresion 2 como segundos y la expresion1 como minutos


Infinite loop: sucede cuando la condicion siempre es verdadera, el programa nunca termina

seg = 0
min = 0
hour = 0
while hour < 2:
    while min < 60:
        while seg < 60:
            print(f'{hour} h : {min} m : {seg} s')
            seg += 1
        min += 1
        seg = 0
    hour += 1
    min = 0


Aun me cuesta un poco la l贸gica pero poco a poco se mejora.

Ac谩 practicando y con ayuda de la comunidad logr茅 entender mejor el concepto de iteraciones. Les comparto la tabla del 9 que constru铆 馃槂

ITERACIONES

  • La mayor铆a de las tareas computacionales no se pueden lograr con ramificaciones.
  • Cuando queremos que un programa haga lo mismo varias veces, utilizamos iteraciones.
  • Se pueden escribir iteraciones dentro de iteraciones.
  • Podemos utilizar break para salir anticipadamente de una iteraci贸n.
  • Tener cuidado de iteraciones infinitas (infinite loop).

Quite el contador_interno de la segunda evaluaci贸n y experimente un bucle infinito. Mi VsCode exploto jajaja.

Un loop infinito que solo puede pararse con Ctrl + C

Si se elimina el contador interno haria un loop infinito por lo que el contador externo no aumentaria y quedaria de igual forma en un loop infinito.

Si se borrase

contador_interno +=1

se entrar铆a en un infinite loop

Intent茅 experimentar con lo visto en las clases anteriores y 茅sto me acord贸 mucho cuando estaba aprendiendo las tablas de multiplicar.

number = int(input('Ingresa el primer n煤mero '))
max_number = int(input('Ingresa el n煤mero m谩ximo '))
max_mult = int(input('Ingresa el m谩ximo multiplicador '))

print(f'{number} x {max_number}')

print(f'Las tablas del {number} - {max_number}')

while number <= max_number:
    print(f'La tabla del {number}')
    #Aqu铆 se pondr谩 la l贸gica
    mult = 1
    while mult <= max_mult:
        resul = number * mult
        print(f'{number} x {mult} = {resul}')
        mult += 1
    number += 1

loop al infinito y m谩s all谩

elimite el contador interno y se creo un loop infinito. Pero me lo corto poniendo un Traceback y no me rompio la computadora

Traceback (鈥)
(infinit loop)
KeyboardInterrupt
close failed in file object destructor:
sys.excepthook is missing
lost sys.stderr

Si eliminas el contador interno se queda en un Loop infinito de 00

Pregunta:
驴Hay alguna raz贸n por la cual el profesor en visual code escribe en la terminal python3.7 iteraciones.py para correr el script y no usar la tecla F5 o ctrl+F5?

Si se elimina el contador interno el programa cae en un ciclo infinito.

Reloj con while

Reloj con datetime

''' 
Al eliminar el contrador_interno del bucle interno, 
el bucle interno nunca obtiene la condici贸n de termino por lo que se crea un bucle infinito.
Adem谩s, el bucle externo tampoco se incrementa quedando en cero
'''
contador_interno = 0
contador_externo = 0

while contador_externo < 5:
    while contador_interno < 6:
        print(contador_interno, contador_externo, "Presiona CTRL + C para terminar")
    contador_externo += 1

Aqui esta mi tarea profe 馃槃

Al final le puse el 24:00:00 para que se viera bonito y no termine en 23:59:59

Segundos = 0
Minutos  = 0
Horas    = 0

while Horas < 24:
    while Minutos < 60:
        while Segundos < 60:
            print(Horas, Minutos, Segundos)
            Segundos += 1
        Segundos = 0
        Minutos += 1
    Minutos = 0
    Horas += 1

print('24 00 00')

Aqu铆 esta el codigo, por si alguien desea utilizarlo (Esta libre de derechos de autos 馃槇)

9-Iteraciones

  • La mayor铆a de las tareas computacionales no se pueden lograr con ramificaciones. As铆 que cuando queremos que un programa haga lo mismo varias veces, utilizamos iteraciones.
  • Se puede escribir iteraciones dentro de iteraciones
  • Podemos utilizar break para salir anticipadamente de una iteraci贸n
  • Tener mucho cuidado con iteraciones infinitas

While: es un bucle, se lee como 鈫 mientras la condicion si cumpla, repetir esto

Break: break statement finaliza la ejecuci贸n de la instrucci贸n do , for , switch o while

contador = 0
while contador < 10:
    print(contador)
    contador += 1   # equivale a: contador = contador +1
contador_externo = 0
contador_interno = 0

# mientras el contador_externo sea menor que 5
while contador_externo < 5:     # manejar cuando la condicion es false
    while contador_interno < 6:
        # mientras el contador_interno sea menor que 6 -> imprimir
        print(contador_externo, contador_interno)
        contador_interno += 1

        if contador_interno >= 3: # si contador_interno es mayor o igual a 3 -> nos salimos del loop interno
            break   # break statement finaliza la ejecuci贸n de la instrucci贸n do , for , switch o while

    contador_externo += 1
    contador_interno = 0

# esto funciona como un reloj, que tienen dias, horas, minutos etc..

para salir de un while infinito
Ctrl c
espero que les sirba

Tengo una Duda, en el minuto 6:59 con ese programa si ponemos el print de la linea 7 despu茅s del declarar la suma en la linea 8, es decir solo invertir la linea 7 y 8 de posici贸n, al correrlo el contador interno si llega hasta el 6 cuando le dijimos que solo menor que 6, a que se debe eso?

WOW!!! A mi por mucho tiempo me dio dificultad entender como se ejecutan los ciclos anidados y luego llega David y lo explica con un ejemplo tan simple pero contundente como el de un reloj y sus manecillas. Si tan s贸lo me hubieran explicado eso as铆 en su momento no habr铆a tenido tantos problemas para comprender ese concepto.

La idea de profe del reloj.
Realice un reloj con 3 while:

import time
from datetime import datetime
now = datetime.now()

hora = now.hour
minutos = now.minute
segundos = now.second

while hora < 24:
    while minutos < 60:
        while segundos < 60:
            print(f'{hora}:{minutos}:{segundos}')
            time.sleep(1)
            segundos += 1
        segundos = 0
        minutos += 1
    minutos = 0
    hora += 1

Aqui tiene un uso de loops.

Un saludo

excelente analogia del reloj

print ('contador de una semana, d铆as, horas, minutos y segundos')
cont_dias = 0
cont_horas = 0
cont_min = 0
cont_seg = 0

while cont_dias < 8:
    while cont_horas < 24:
        while cont_min < 59:
            while cont_seg < 59:
                print (cont_dias, cont_horas, cont_min, cont_seg)
                cont_seg += 1
            cont_min += 1
            cont_seg = 0
        cont_horas += 1
        cont_min = 0
    cont_dias += 1
    cont_horas = 0

Los loops son importantes, con lo que hicimos en esta clase podemos recorrer arreglos bidimensionales 馃憖 En el curso b谩sico de Python hice un loop infinito pero controlado xD

while True:
        tecla = input("Presiona 0 para salir: ")

        if(tecla == "0"):
            break

Iteraciones (loops)


Estas nos van a permitir realizar la misma tarea varias veces, con las menores l铆neas de c贸digo. Adem谩s, puedes escribir iteraciones dentro de iteraciones. Tambi茅n podemos salir de las iteraciones con palabras reservadas como break o continue.

馃挜 Y debemos tener cuidado con las iteraciones infinitas.

# contador = 0

# while contador <= 10:
#     print(contador)
#     contador += 1

contador_ex = 0
contador_in = 0

while contador_ex <= 5:
    while contador_in < 6:
        print(f'Contador externo {contador_ex} y contador interno {contador_in}')
        contador_in +=1
    
    contador_ex += 1
    contador_in = 0

Si est谩n en cmder Pueden detener un loop infinito con crtl +d

驴Qu茅 pasa si eliminamos el contador interno del while interno?

Corre ininterrumpidamente el proceso con el contado interno y externo en 0, es decir no avanzo ni el contador externo ni el interno debido a que evalu贸 que el contador interno segu铆a siendo menor a 5.

Realize una modificacion muy sencila, para que aplique como si fuera el reloj que comenta.

contador_externo = 1
contador_interno = 0

while contador_externo < 3:
    while contador_interno < 60:
        print(contador_externo, contador_interno)
        contador_interno +=1
    
    contador_externo +=1
    contador_interno = 0```

Muchas gracias, en el Tecnol贸gico jamas entend铆 bien las ciclos, los profes son flojos y solo dejan ejercicios y resuelvelos como puedas.

si eliminamos ese contador quedaremos dentro de un loop infinito

Bajo que ejemplos aparte de los que nombra el teacher se podr铆an aplicar las iteraciones?

Si eliminamos el contador interno nos quedamos en un loop infinito imprimiendo 0 0 hasta el final de nuestros d铆as鈥 pueden usar el comando ctrl + c para interrumpir el loop infinito y volver a la vida鈥

Dentro de las palabras reservadas de python que son 煤tiles dentro de bucles tenemos continue que devuelve el orden de ejecucion del c贸digo a la l铆nea donde se evalua si se entra en el bucle
.
por ejemplo:

contador_externo = 1
contador_interno = 0

while contador_externo < 6:
    while contador_interno < 6:
        print(contador_externo, contador_interno)
        contador_interno += 1

        if contador_interno == 3:
            contador_interno += 1
            continue

    contador_externo += 1
    contador_interno = 0```

**aqui obtenemos como output una secuencia donde el numero 3 del segundo contador se salta**

Si quitamos el incremento del contador interno queda como un loop infinito.
Saludos!

Al eliminar el contador interno, el loop se hace infinito.

Hasta esta clase me di cuenta de la importancia del espaciado

Se genera un contador infinito de 0鈥

""" contador = 0
while contador <= 10:
    print(contador)
    contador += 1 """

minuto = 0
horas = 0
segundo = 0

while horas < 12:
    while minuto < 60:
        while segundo < 60:
            segundo +=1
            print(horas, minuto, segundo)
        minuto += 1
        segundo = 0
    horas += 1
    minuto = 0```

Se crea un contador_interno infinito ya que su valor siempre sera 0, con el ejemplo original el contador interno sumaba 1 hasta llegar al maximo del while entonces el contador externo sumaba 1 y reinicia el interno, para una nueva iteracion del primer while

gg

Si se elimina el contador interno crearemos un loop infinito :3

Si quitamos la variable que indicas David Aroesti tendr铆amos un loop infinito,

Super necesario este curso para cuando quieres empezar a programar con python!

Esta complicado el tema, 驴algun otro recurso para profundizar o estudiarlo mas a fondo?

Hice un reloj con esta clase:

Se vuelve un loop infinito.

hora, minuto, segundo= 0,0,0
while hora < 24:
    while minuto < 60:
        while segundo < 60:
            print("******************************************")
            print("* Hora *\t Minuto *\t segundo *")
            print("******************************************")
            print("*\t", hora +1, "\t: ",minuto+1,"\t\t: ",segundo+1,"   *")
            print("******************************************")
            os.system('CLS')
            segundo +=1
        minuto +=1
        segundo = 0
    hora +=1
    minuto = 0```

contador_externo = 0
contador_interno = 0

while contador_externo < 60:
print(f"La hora es {contador_externo}:{contador_interno}")
while contador_interno < 60:
print(f"La hora es {contador_externo}:{contador_interno}")
contador_interno += 1

contador_externo += 1
contador_interno = 0

Me pareci贸 interesante la analog铆a que hacia David acerca de ciclo while y el reloj por lo que modifique el c贸digo para simular el comportamiento del un reloj en un rango de 12 horas:

horas = 1
minutos = 1


while horas <= 12:
    while minutos <= 60:
      print(horas, minutos)
      minutos += 1
  
horas += 1
minutos = 0

1 1
1 2
1 3
1 4
1 5
1 6
1 7
1 8
1 9
1 10
1 11
1 12
1 13
1 14
1 15
1 16
1 17
1 18
1 19
1 20
1 21
1 22
1 23
1 24
1 25
1 26
1 27
1 28
1 29
1 30
1 31
1 32
1 33
1 34
1 35
1 36
1 37
1 38
1 39
1 40
1 41
1 42
1 43
1 44
1 45
1 46
1 47
1 48
1 49
1 50
1 51
1 52
1 53
1 54
1 55
1 56
1 57
1 58
1 59
1 60 鈥

APUNTES

  • Cuando necesitamos que se realice una tarea varias veces, se utilizan los ciclos (while). Se pueden escribir iteraciones dentro de otras iteraciones.

  • Para salir anticipadamente de una iteraci贸n se utiliza break.

CODIGO

horas = 0
minutos = 0
segundos = 0
while horas <= 23:
    while minutos <= 59:
        while segundos <= 59:
            print(horas,minutos,segundos)
            segundos += 1
        minutos += 1
        segundos = 0
    horas += 1
    minutos = 0
    segundos = 0

Al eliminar el contador_interno +=1 o contador++ se entrar铆a en un loop infinito dentro del segundo while debido a que la condici贸n segunda siempre ser铆a verdadero y el resultado del print ser铆a 0 0 hasta el infinito.

Consegu铆 hacer una iteraci贸n de 3 ciclos

<contador_macro = 0
contador_base = 0
contador_micro = 0

while contador_macro < 5:
    while contador_base < 5:
        while contador_micro < 5:
            print(contador_macro, contador_base, contador_micro)
            contador_base += 1
            contador_micro += 1

    contador_macro += 1
    contador_base = 0
    contador_micro = 0

    >

Un contador de d铆as , horas y minutos en una semana.

print('Contador de Una semana en dias horas y minutos')
contador_dias = 1
contador_horas = 00
contador_minutos = 00

while contador_dias < 8:
    while contador_horas < 24:
        while contador_minutos <= 59:
            print(contador_dias, contador_horas, contador_minutos)
            contador_minutos += 1
        contador_horas +=1
        contador_minutos =0
    contador_dias += 1
    contador_horas = 0```

si se elimina el contador interno, en la primera iteraci贸n del contador externo, el ciclo interno se va al infinito dado que nunca se cumple la condici贸n de salida.

Version de cronometro 1

Hice un peque帽o men煤 donde se le pregunta al usuario un nombre de empleado, para devolver el departamento al cual pertenece el empleado ingresado. Esto lo inclu铆 en un bucle while que termina su ejecuci贸n si el nombre ingresado no existe en la lista.

Genera un Infinity Loop! 馃槂

una buena practica:
saber como detener estos loops, cntrl + c es en Spyder

contador_minuto = 0
contador_segundos = 0

while contador_minuto < 10: # Voy a correr los segundos hasta llegar a 10 min (9:59)
    while contador_segundos < 60:
        print(contador_minuto, contador_segundos)
        contador_segundos += 1
    contador_minuto += 1
    contador_segundos = 0 # Reseteo mi contador de segundos para que pueda pasar al siguiente minuto
junio = 30
julio = 31
agosto = 31

dia_inicio = 15
mes_inicio = 'junio'
dia_cumple = 10
mes_cumple = 'agosto'

total_dias = (junio+julio)-(dia_inicio-1)+dia_cumple

segundos = 0
minutos = 0
horas = 0
dias = 0

while dias <57:
    while horas <24:
        while minutos <60:
            minutos +=1
            while segundos <60:
                segundos +=1
        horas +=1
    dias +=1
        
    print(segundos)
    print(minutos)
    print(horas)
    print(dias)

    print(f'Faltan {total_dias-dias} dias para mi cumplea帽os')```
Hice un while teniendo en cuenta mi fecha de cumplea帽os y los d铆as que faltan

Para practicar, hice un c贸digo que simula el calculo del aire de una botella durante una inmersi贸n de buceo:

<carga = int(input('Introduce la carga en PSI de tu botella de aire: '))
reserva = 500
paradaseguridad = 300
alerta = 100

while carga > reserva + paradaseguridad :
    carga -=1
    if carga > (reserva + paradaseguridad + alerta ) :
        print(f'Aun tienes aire suficiente para seguir buceando: {carga} psi')
    elif carga == (reserva + paradaseguridad + alerta ):
        print(f'Debes empezar a estar alerta de tu oxigeno: {carga} psi ')
    else: 
        print(f'Poco tiempo para empezar ascenso con calma : {carga} psi')
     

if carga == (reserva + paradaseguridad):
    carga -=1
    print(f'Empezar ascenso con calma : {carga} psi')

while carga < (reserva + paradaseguridad):
    carga -=1
    print(f'Ascenso : {carga} psi')
    if carga == 0:
        break
>

intente dibujar algo:

Una cuenta regresiva con misisipis

<contador = 10
misisipis=1
while contador > 0:
    print("despegue en",contador)
    while misisipis<=3:
        print("con ",misisipis,"misisipis")
        misisipis +=1;
    contador-=1
    misisipis=1

if contador == 0:
    print("Explocion")
>

Tipos de iteraciones infinitas: El yo te aviso de mi crush ;V

Reloj 鈱

segundos = 0
minutos = 0
horas = 0

while horas < 24:
    
    while minutos < 60:

        while segundos < 60:
            print(horas, minutos, segundos)
            segundos += 1

        minutos += 1
        segundos = 0

    horas += 1
    minutos = 0```

Tabla de Multiplicar:

print("Tabla de Multiplicar")

numero=int(input("Ingresar un numero:  "))
contador=0

while contador <=10:
    resultado=numero * contador
    print(contador, " * ", numero, " = ",  resultado)
    contador += 1```

Resultado en consola.
Tabla de Multiplicar
Ingresar un numero:  5
0  *  5  =  0
1  *  5  =  5
2  *  5  =  10
3  *  5  =  15
4  *  5  =  20
5  *  5  =  25
6  *  5  =  30
7  *  5  =  35
8  *  5  =  40
9  *  5  =  45
10  *  5  =  50

En el programa con los dos contadores (interno y externo), si eliminamos la instrucci贸n del contador_interno +=1, la salida del programa queda en un loop.

Muchas gracias Crack

definitivamente si no le pongo break me da infinito !!! jajajaj auxilo!!!

contador_externo = 0
contador_interno = 0

while contador_externo < 5:
while contador_interno < 6:
print(contador_externo, contador_interno)
contador_interno += 1

    if contador_interno >= 10:
        break
  
    contador_externo += 1
    contador_interno = 0

mi ejemplo con ciclos while

Me gusta como el profe explica la l贸gica. Aunque bueno debe ser porque ya me he familiarizado con el lenguaje, pero vamos fluyendo 馃惂馃悕

9. Iteraciones

Iteraciones (loops)

  • La mayor铆a de las tareas computacionales no se pueden lograr con ramificaciones.
  • Cuando queremos que un programa haga lo mismo varias veces, utilizamos iteraciones.
  • Se pueden escribir iteraciones dentro de iteraciones.
  • Podemos utilizar break para salir anticipadamente de una iteraci贸n.
  • Tener cuidado de iteraciones infinitas.
  • Si se elimina el contador interno, no se reiniciar谩 y continuar谩 ejecut谩ndose indefinidamente.
contador = 0

while contador < 10:
    print(contador)
    contador += 1

contador_externo = 0
contador_interno = 0

while contador_externo < 5:
    while contador_interno < 6:
        print(contador_externo, contador_interno)
        contador_interno += 1

        if contador_interno >= 3:
            break
        
    contador_externo += 1
    contador_interno = 0