Iteraciones

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:

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.

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 días 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} días, 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!!')

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.