Explorando un bucle diferente: el ciclo for

CON TODO LO QUE HEMOS APRENDIDO SE ME OCURRIÓ ESCRIBIR UN PROGRAMA QUE TE DEVUELDA LAS TABLAS DE MULTIPLICAR.
Siento que son muchas lineas y que la parte del if, elif, else se pueden reducir. Se les ocurre algo ? Soy nuevo en esto 😃

def tabla(numero):
    print('Esta es la tabla del ' + str(numero))
    for i in range(1,11):
        print(i*numero)


def run():
    menu = """
VAMOS A VISUALIZAR LAS TABLAS DE MULTIPLICAR
    Selecciona la tabla que quieras ver:
        a. tabla del 2
        b. tabla del 3
        c. tabla del 4
        d. tabla del 5
        e. tabla del 6
        f. tabla del 7
        g. tabla del 8
        h. tabla del 9
            
¿Qué tabla quires ver? Elige una opcion: 
    """
    opcion = str(input(menu))

    if opcion == 'a':
        tabla(2)
    elif opcion == 'b':
        tabla(3)
    elif opcion == 'c':
        tabla(4)
    elif opcion == 'd':
        tabla(5)
    elif opcion == 'e':
        tabla(6)
    elif opcion == 'f':
        tabla(7)
    elif opcion == 'g':
        tabla(8)   
    elif opcion == 'h':
        tabla(9)                         
    else:
        print('esa no es una opcion')


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

Esta es mi forma de imprimir las tablas de multiplicar con solo 4 líneas de código.
__

__

Este es el output:
__

El ciclo for:
Este será usado cuando se conozcan la cantidad de veces a iterar.

Un contador es una variable la cual contiene valores que van incrementando o decrementando cada vez que se ejecuta una acción que lo contenga.

El incremento o decremento es llamado paso del contador y es siempre constante.

Ejemplo: El marcador de un partido de fútbol, cada vez que un equipo anote un gol, aumenta su marcador en una unidad.

Ej2: En las carreras de autos, cuando un vehículo pasa por la línea de meta, se incrementa en una unidad el número de vueltas dadas al circuito, o bien se decrementa el número de vueltas que faltan por relalizar.

Entonces, el incremento es siempre constante, el paso del contador no necesariamente puede ser una unidad, también puede incrementarse o decrementarse de a dos, tres, cuatro, …n. Es decir, puede ser cualquier número que conserve siempre el mismo valor durante todo el programa.

La sintaxis es:
variable = variable + constante(al incrementar)
variable = variable - constante(al decrementar)

o de manera resumida:

variable += constante
variable -= constante

Ejemplo:

gol_local = 0 #si anotan gol: gol_local = gol_local +1

Es importante inicializar en cero a la variable cuando aparezca a ambos lados del símbolo de asignación

Como cuando estas estudiando Python y tu hermano te dice quiero que me ayudes a ponerlo en codigo este mensaje para tu cumple :3 y pues yo lo he echo con python !!
Que tal me quedo 😁😁

Un extra
la variable 'contador’
muchos la escriben ‘i’ // de iterator o iterador
^_^

var += 1: Seria lo mismo que decir, var = var +1, solamente es una forma de hacerlo mas corto y limpio el codigo

IMPORTANTE Siempre trata de traducir el codigo python al español

range():

range en Python es un tipo que se utiliza para representar una secuencia inmutable de números. Uno de sus principales usos es junto a la sentencia for, para definir un bucle sobre el que se itera un número determinado de veces. La función incorporada (i.e. no necesita importarse) range() retorna una sucesión de números enteros. Cuando se le pasa un único argumento n, la sucesión empieza desde el cero y culmina en n-1.Ejemplo:

>>> contador = list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
*IMPORTANTE* La funcion range, tambien se le puede agregar un valor inicial para empezar a contar desde alli y el valor final hasta donde llegara n-1

Los for son uno de los bucles más usados, cuando sabes cuantas veces se iterará, y hay muchas maneras de manipularlos:

#Podemos recorrer Strings
for x in "Platzi":
    print(x)
>> 'P'
>> 'l'
>> 'a'
>> 't'
>> 'z'
>> 'i'

#También podremos recorrer listas
frutas = ["Pera","Banana","Coco"]
for x in frutas:
    print(x)
>> 'Pera'
>> 'Banana'
>> 'Coco'

#También darle un rango en el que se ejecutará, cuando llegue a nuestro rango, no se ejecutará, en este caso, el 3 no se mostrará
for x in range(3):
    print(x)
>> 0
>> 1
>> 2

#Al igual que los Slices, también puedes hacer con los rangos, en este caso, iniciaremos el rango en 0 y con un final en el 15, haciendo pasos de 3, y el llegar al 15, el bucle dejará de ejecutarse
for x in range(0,15,3):
    print(x)
>> 0
>> 3
>> 6
>> 9
>> 23

#También podremos usar Else en nuestro for, este se ejecutará después de que nuestro bucle acabe
for x in range(3):
    print(x)
else:
    print("Finalicé)
>> 0
>> 1
>> 2
>> 'Finalicé'

Si deseas información más detallada, he encontrado este documentación en W3schools👈

El bucle for se utiliza para recorrer los elementos de un objeto iterable (lista, tupla, conjunto, diccionario, …) y ejecutar un bloque de código. En cada paso de la iteración se tiene en cuenta a un único elemento del objeto iterable, sobre el cuál se pueden aplicar una serie de operaciones.

El ciclo For trabaja con pocas líneas, ejemplo:
.
for contador in range(1, 1001):
print(contador)
.
El comando anterior trabaja de la siguiente forma…
.

1. Se usa el comando for para empezar a crear el ciclo.
2. Se escribe el nombre de la variable.
3. Se coloca el comando in range, que significa: en el rango de…
4. Se abren paréntesis y colocamos el rango inicial y final, o simplemente el final.
   .
   Igualmente se puede recrear el comando con el ciclo while de esta forma:
   .
   contador = 1
   print(contador)
   while contador < 1000:
   contador += 1
   print(contador)
   .
   Sin embargo es más complejo y lleva más líneas de texto, lo que a largo plazo produciría mayor peso y tiempo en procesamiento, además de ser una mala práctica.

A diferencia del ciclo While, el ciclo for se ejecutará el número de veces que hemos establecido.
La estructura del ciclo for se compone de un contador que actuará de índice, y de la función range, a la cual le pasaremos por parámetro el número máximo que podrá adquirir el contador menos 1, es decir, el número máximo que asignamos no estará incluido, también puede tener otro parámetro que es opcional pero indicará el primer valor que tendrá el contador, un ejemplo de uso:
for contador in range(5, 1000):
print(contador)
En este ejemplo el contador empieza teniendo el valor de 5 y acaba en 999 porque recordemos que el último valor no está incluido.

Comparto la solución del ejercicio de las potencias de tres maneras distintas:

CICLO WHILE

# CICLO MEDIANTE WHILE
def run2(rept):
    contador = 0
    while contador < rept:
        print( "2 ^ " + str(contador) + " = " + str(2**contador) )
        contador += 1
    print("Fin!")

CICLO FOR

# CICLO MEDIANTE FOR
def run3(rept):
    for contador in range(rept):
        print( "2 ^ " + str(contador) + " = " + str(2**contador) )
    print("Fin!")

Y la mía jaja RECURSIVIDAD

# CICLO MEDIANTE RECURSIVIDAD
def run(num, rept):
    if num < rept:
        contador = num
        print( "2 ^ " + str(contador) + " = " + str(2**contador) )
        run(num+1, rept)
    else:
        print("Fin!")

RESULTADO:

Definición corta: El ciclo for es una estructura cíclica cuya finalidad es ejecutar un código una cierta cantidad de veces.

El ciclo for itera dentro de un rango.
El ciclo while itera hasta un límite.

creo por esto con el ciclo for necesito menos líneas para un contador de números por ejemplo.

Es más sencillo pensar al “FOR” como un “ITERADOR” ya que en sí no es un bucle debido a que no está repitiendo nada, mas bien, toma valores dentro de rango (itera en él).

Para imprimir una tabla específica, usé el siguiente código. Espero que sirva.

tabla = int(input("Ingresa la tabla que quieres consultar "))
for i in range(1, 11):
r = tabla * i
print(str(tabla) + " x " + str(i) + " = " + str®)

def main():
    print("""
    ========================================================
    TODAS LAS PONTENCIAS DE 2 DESDE 1 HASTA 100000 CON WHILE
    ========================================================
    """)
    i = 0
    LIMITE = 100000
    while(i >= 0):
        resultado = 2**i
        print(f"2 elevando a la {i} potencia es {resultado}")
        i += 1
        if resultado >= LIMITE:
            break

    print("""
    ========================================================
    TODAS LAS PONTENCIAS DE 2 DESDE 1 HASTA 100000000 CON FOR
    ========================================================
    """)
    for i in range(200):
        print(f"2 elevando a la {i} potencia es {2**i}")
        if 2**i >= 100000000:
            break


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

✨ For es el ciclo más usado y popular.

for i in range(10):
    print(11 * i)

def run():
for i in range(1, 11):
print(" ")
print("Esta es la tabla del "+ str(i))
for j in range(10):
total = j * i
print(str(i) + ’ * ’ + str(j) + ’ = ’ + str(total))

if name == ‘main’:
run()

Esta es la tabla del 1
1 * 0 = 0
1 * 1 = 1
1 * 2 = 2
1 * 3 = 3
1 * 4 = 4
1 * 5 = 5
1 * 6 = 6
1 * 7 = 7
1 * 8 = 8
1 * 9 = 9

Esta es la tabla del 2
2 * 0 = 0
2 * 1 = 2
2 * 2 = 4
2 * 3 = 6
2 * 4 = 8
2 * 5 = 10
2 * 6 = 12
2 * 7 = 14
2 * 8 = 16
2 * 9 = 18

Esta es la tabla del 3
3 * 0 = 0
3 * 1 = 3
3 * 2 = 6
3 * 3 = 9
3 * 4 = 12
3 * 5 = 15
3 * 6 = 18
3 * 7 = 21
3 * 8 = 24
3 * 9 = 27

Esta es la tabla del 4
4 * 0 = 0
4 * 1 = 4
4 * 2 = 8
4 * 3 = 12
4 * 4 = 16
4 * 5 = 20
4 * 6 = 24
4 * 7 = 28
4 * 8 = 32
4 * 9 = 36

Esta es la tabla del 5
5 * 0 = 0
5 * 1 = 5
5 * 2 = 10
5 * 3 = 15
5 * 4 = 20
5 * 5 = 25
5 * 6 = 30
5 * 7 = 35
5 * 8 = 40
5 * 9 = 45

Esta es la tabla del 6
6 * 0 = 0
6 * 1 = 6
6 * 2 = 12
6 * 3 = 18
6 * 4 = 24
6 * 5 = 30
6 * 6 = 36
6 * 7 = 42
6 * 8 = 48
6 * 9 = 54

Esta es la tabla del 7
7 * 0 = 0
7 * 1 = 7
7 * 2 = 14
7 * 3 = 21
7 * 4 = 28
7 * 5 = 35
7 * 6 = 42
7 * 7 = 49
7 * 8 = 56
7 * 9 = 63

Esta es la tabla del 8
8 * 0 = 0
8 * 1 = 8
8 * 2 = 16
8 * 3 = 24
8 * 4 = 32
8 * 5 = 40
8 * 6 = 48
8 * 7 = 56
8 * 8 = 64
8 * 9 = 72

Esta es la tabla del 9
9 * 0 = 0
9 * 1 = 9
9 * 2 = 18
9 * 3 = 27
9 * 4 = 36
9 * 5 = 45
9 * 6 = 54
9 * 7 = 63
9 * 8 = 72
9 * 9 = 81

Esta es la tabla del 10
10 * 0 = 0
10 * 1 = 10
10 * 2 = 20
10 * 3 = 30
10 * 4 = 40
10 * 5 = 50
10 * 6 = 60
10 * 7 = 70
10 * 8 = 80
10 * 9 = 90

Debido a que todos ponían un ejemplo de su tabla de multiplicar y yo quise hacer el mio con lo aprendido en clase

Así me salió. Soy nuevo en esto 😃

def run():

    print("Tablas de multiplicar")
    tabla = int(input("Introduce la tabla de multiplicar que quieres ver: "))
    print(" ")
    print("La tabla del "+ str(tabla) + " es: ")
    for contador in range(0, 13):
        resultado = tabla*contador
        print(str(tabla) + " X " + str(contador) + " = " + str(resultado))
        

if __name__ == "__main__":
    run()

Espero lo validen, Saludos !! 😃

Atajo para copiar linea en Mac = (Alt + Shif + ↓)

(-)/

def run():
    print("Bienvenido al visualizador de tablas")
    contador = int(input("¿Qué tabla quieres ver: "))
    for i in range(1,11):
        print(i*contador)

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

Okok esta no es la primera clase del curso verdad? Donde están los punto y coma, como agrego exenciones en Code para que interprete Phyton que quieren decir los dos puntos (😃… en fin. Gracias por sus comentarios buscaré donde se resuelven esas dudas C.U.

Excelente la forma de explicar de facundo, se entiende de una forma muy sencilla y rápida.

Ok, por lo que comprendo, el range es una especie de objeto iterable para Python, es como si fuera un array, pero sin ser array, simplemente es un objeto iterable…
.
Veo que el for tiene igual una versión for...else y también una versión asíncrona, me pregunto para qué se usará…

Tanto que sufrí en la universidad porque de plano no lograba entender la sintaxis de los ciclos y ahora viene Facundo y me lo explica tan hermosamente sencillo en tan sólo 10 minutos :'v

Código tener todas las tablas de multiplicar y establecer un límite de la tabla

Reto de las tablas de Multiplicar

def tabla(numero):
print('Esta es la tabla del: '+ str(numero))
for x in range (1,10):
print(str(numero) + ‘x’ + str(x) + ’ = ’ + str(x * numero))

#Paso 1: Funcion principal

def run():
menu = “”"

Selecciona que tabla quieres consultar

1- Tabla del 1
2- Tabla del 2
3- Tabla del 3
4- Tabla del 4
5- Tabla del 5
6- Tabla del 6
7- Tabla del 7
8- Tabla del 8
9- Tabla del 9

Eliege una Opcion: “”"

opcion = input(menu)

if opcion == '1':
    tabla(1)
elif opcion == '2':
    tabla(2)
elif opcion == '3':
    tabla(3)
elif opcion == '4':
    tabla(4)
elif opcion == '5':
    tabla(5)
elif opcion == '6':
    tabla(6) 
elif opcion == '7':
    tabla(7)
elif opcion == '8':
    tabla(8)
elif opcion == '9':
    tabla(9)
else:
    print('Escoge una opcion valida')

#Paso 2: Entry Point

if name == ‘main’:
run()

Muy interesante todo el curso. Con todo lo que hemos visto hasta este video, me puse el reto de crear un programa que muestre las tablas de multiplicar solo de 1 al 10. Pero primero usando WHILE y luego usando FOR. Les dejo el código. (No creo que sea muy útil el programa, pero me sirvió como ejercicio)

WHILE:

def run():
    menu = """¿De qué número del 1 al 10 quieres saber la tabla?
    """
    tabla = int(input(menu))
    numero = 1
    operacion = tabla * numero
    while tabla <=10:
        print(str(tabla) + " x " +  str(numero) + " es igual a " + str(operacion))
        numero = numero + 1
        operacion = tabla * numero
    else:
        print("Tabla no disponible, debes elegir un numero del 1 al 10 ")
        run()


if __name__ == "__main__":
    run()

FOR:

def run():
    menu = """¿De qué número del 1 al 10 quieres saber la tabla?
    """
    tabla = int(input(menu))
    if tabla <= 10:
        for i in range(1,11):
            print (str(i) + " x " + str(tabla) + " es igual a " + str(i*tabla))
    else:
        print("Tabla no disponible, debes elegir un numero del 1 al 10")
        run()
        
if __name__ == "__main__":
    run()

Aquí está el código a ver si le sirve a alguien, saludos compañeros

def run():

 a= """
      -------------------------
      ||  Tablas del 1 al 9  ||
      -------------------------
      -------------------------
 """

 print(a)

 for i in range(1,10):
      print() #linea en blanco
      print("-------------")
      print("Tabla del ",i)
      print("-------------")
      
      for j in range(1,10):
           print(i*j)

if name == ‘main’:
run()

Hice esta versión añadiendo una excepción si meten un valor diferente al numérico:

def saludo():
    print("""BIENVENIDO A LAS TABLAS""")

def tabla_del_numero():
    
    limite = int(input("¿Hasta que número?\n"))
    contador = 0

    while contador <= limite:
        resultado = numero * contador
        print(f"{numero} * {contador} = {resultado}")
        contador += 1

def pedirNumeroEntero():
 
    correcto=False
    num=0
    while(not correcto):
        try:
            numero = int(input("¿Que tabla deseas calcular?\n"))
            correcto=True
        except ValueError:
            print('Error, introduce un numero entero')
     
    return numero
 


if __name__ == "__main__":
    saludo()
    numero = pedirNumeroEntero()
    tabla_del_numero()

Tablas de Multiplicar
for numero in range (1,11):
print(‘Tabla de Multiplicar del ’ + str(numero))
for contador in range(1,11):
resultado = numero*contador
print(str(contador) + ‘x’ + str(numero) +’=’+ str(resultado))

El ciclo “for”. Resumen en la consola:

Qué bueno que el profesor explicó que bucles y ciclos son la misma herramienta de programación con distintos nombres. Tenía esa pequeña duda en mi mente.

Muchas gracias profesor Facundo

otra forma de contar los numeros del 1 a 1000 es definir el rango de 0 a 1000

Una pequeña corrección para que los nuevos no se confundan como yo en el ejemplo del BUCLE FOR (faltó poner el parámetro INICIO en la función para que el programa cumpla su propósito) 😉

Hice un jueguito básico para que una persona se desestrese por medio de adivinar un número generado aleatoriamente desde el 1 a el limite que es colocado por el jugador. El problema es que quiero que cuando se escriba la palabra “ya” el sistema arroje el resultado de ese número aleatorio pero me sale error; si alguién puede arreglar esto se los agradeciería mucho 😃

menu = """"
BIENVENIDO AL MAGNIFICO JUEGO PARA DESESTRESARTE EN EL TRABAJO, SE TRATA DE QUE ADIVINES UN NÚMERO GENERADO ALEATORIAMENTE DE 1 A LO QUE ESCOJAS, DIVIERTETE :3. Si te rindes solo escribe: "9999" y se te mostrara el número
"""
print(menu)


def juego():
    limite = int(input("Dame un número y deberas buscarlo de 1 a ese número: "))
    participante = int(input("¿En qué número estoy pensando? (es de 1 a " + str(limite) + "): "))
    maquina = int(random.randint(1, limite))
    while participante != maquina:
        print("Sigue intentando")
        participante = input("dame otro número, recuerda es de 1 a " + str(limite) + "): ")
        participante = int(participante)
    if participante == maquina:
        print("Me venciste, me rindo :(")

if __name__ == "__main__":
    juego()

Hola, Este es mi codigo, gracias a cada uno de sus aportes.

print("""
    --------------------------------------------
    Bienvenido al Generador de tablas de multiplicar del 1 Al 9
    ----------------------------------------------""")
    tabla = int(input("¿Que numero de tabla quieres ver? "))
    for i in range (1,11):
        resultado = (tabla * i)
        print(f"{tabla} x {i} = {tabla*i}")

Y este fue mi Resultado

  --------------------------------------------
    Bienvenido al Generador de tablas de multiplicar del 1 Al 9
    ----------------------------------------------
¿Que numero de tabla quieres ver? 4
4 x 1 = 4
4 x 2 = 8
4 x 3 = 12
4 x 4 = 16
4 x 5 = 20
4 x 6 = 24
4 x 7 = 28
4 x 8 = 32
4 x 9 = 36
4 x 10 = 40

Espero comentarios.

Recién empezando, este es mi intento a hacer las tablas de manera universal para que tenga cualquier numero y cualquier rango de multiplicación.

def tabla(number,multi):
    print('Esta es la tabla del ' + str(number))
    for i in range(1,multi+1):
        print(i*number)


def run():
    number = int(input("Ingrese el numero que quiere multiplicar."))
    multi = int(input("Ingrese el multiplicador. "))
    tabla(number,multi)

if __name__ == '__main__':
    run()

contador = contador + 1 se puede escribir como contador += 1

He utilizado el ciclo for para saber los códigos postales de Madrid centro.

<
print("estos son los códigos postales de  Madrid Centro")

for cpostal in range (28011, 28017):
    print(cpostal)
> 

Hago mi aporte usando el temario de clases anteriores con True y False, for, if y else, en donde el usuario digita algún caracter erróneo, y este le salta un print donde le indica que ha ingresado un caracter no valido.

Use otras funciones que busque por mi cuenta las cuales son las de la función "validacion", espero haber aportardo en algo 😄

Por si se preguntan, uso el IDE llamado Pycharm.

Siempre es bueno experimentar con tu código:

def run():
    for i in range(1, 11):
        print("1x" + str(i) + "=" + str(1 * i) + "\t"
              + "2x" + str(i) + "=" + str(2 * i) + "\t"
              + "3x" + str(i) + "=" + str(3 * i) + "\t"
              + "4x" + str(i) + "=" + str(4 * i) + "\t"
              + "5x" + str(i) + "=" + str(5 * i) + "\t"
              + "6x" + str(i) + "=" + str(6 * i) + "\t"
              + "7x" + str(i) + "=" + str(6 * i) + "\t"
              + "8x" + str(i) + "=" + str(8 * i) + "\t"
              + "9x" + str(i) + "=" + str(9 * i) + "\t"
              + "10x" + str(i) + "=" + str(10 * i) + "\t"
              )


if __name__ == '__main__':
    run()

Muchos hicieron un programa para mostrara las tablas y no me quise quedar atrás 😅

def run(tabla):
    for elemento in range(1,11):
        resultado = elemento*tabla
        print(f"{elemento} * {tabla} = {resultado}" )


if __name__ == '__main__':
    eleccion = int(input("¿Cuál tabla deseas mostrar?"))
    run(eleccion)```

Apuntes en código: varias formas de imprimir los números del 1 al 1000:

# def contador():
#     n = 1
#     while n < 1001:
#         print(n)
#         n += 1

# a = list(range(1001))
# print(a)

# CÓDIGO FINAL
def run():
    for contador in range(1, 1001):
        print(contador)

if __name__ == '__main__':
    run()

# INICIO, FINAL, STEP DE RANGO
for i in range(0,1001,2):
    print(i)

Insertion sort en python

def insertion_sort(array):
    size = len(array)
    for i in range(1,size):
        j = i-1
        current_element = array[i]

        while (j >= 0) and (array[j] > current_element):
            array[j+1] = array[j]
            j -= 1
        array[j+1] = current_element

def main():
    array = [3,9,11,-5,0,8]
    insertion_sort(array)
    print(array)


if __name__ == "__main__":
    main()

Un programita para practicar las tablas de multiplicar

<def calculos(multiplo, resultado_multiplicacion):
    calculo = False
    for multiplicador in range(11):# se busca el resultado en todos los resultados
        multiplicacion = multiplo * multiplicador
        if resultado_multiplicacion == multiplicacion:
            break
        calculo = True    
    return calculo

def operacion(numero_selector):
    multiplo = int(numero_selector)
    for multiplicador in range(11):#muestra la tabla de multiplicar que seleciona el usuario
        print(f'{multiplo} x {multiplicador} = ')

    resultado_multiplicacion = int(input('escribe el resultado de cualquier multiplicacion'))

    respuesta = calculos(multiplo, resultado_multiplicacion)
    if respuesta == True:
        print('respuesta correcta')
    else:
        print('respuesta incorrecta')

def run():
    decision = 'si'
    while decision == 'si':#busca que las opciones y el programa se reproduzca las veces que desee el usuario
        print('bienvenido aprende las tablas de multiplicar')
        print('''selecciona la tabla que deseas practicar
[1] para tabla del 1
[2] para tabla del 2
[3] para tabla del 3
[4] para tabla del 4
[5] para tabla del 5
[6] para tabla del 6
[7] para tabla del 7
[8] para tabla del 8
[9] para tabla del 9
[10] para tabla del 10
''')
        numero_selector = input('escribe la selección aca: ')
        ejecucion_de_operacion = operacion(numero_selector)
        decision = input('si deseas continuar escribe SI o NO para salir ')
        decision = decision.lower()# vuelve todas las respuestas a minusculas  


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

Realice el programa con bucle while para repetir sin salir de la ejecución, el ingreso de cualquier numero para conocer la tabla de multiplicar, el for para que realice el ciclo del 1 al 10, una función con el ciclo y un condicional para seguir o no la ejecución del programa:

y la respuesta:

Aquí mi aporte aplicando lo aprendido anteriormente

def tablas (escoger_tabla):
    for i in range (0,cantidad_numeros):
        tabla = escoger_tabla * i
        print(tabla)

escoger_tabla = int(input("Quiero ver la tabla del: "))
cantidad_numeros = int(input("Cuantos numeros quiero ver: "))

if escoger_tabla > 0:
    tablas(escoger_tabla)

¿Que tal compañeros?😋

De mi parte aplique while, for y el tema de funciones en este pequeño proyecto de tablas de multiplicar.

Busco ejecutar buenas practicas, agradeceria su retro. 🙏

<def main():
    seguir = 1
    while seguir == 1:
        tabla = entrada()
        generar(tabla)
        seguir = elegir()
    
def entrada():
    return int(input("¿Cual es la tabla que deseas calcular?: "))

def generar(tabla):
    for i in range(1,11):
        print(f" {tabla} x {i} = {tabla * i} ")

def elegir():
  menu = """¿Te gustaria calcular una nueva tabla
    1 - Si.
    2 - No.
    Selecciona la opcion deseada: """
    return int(input(menu))

if __name__ == "__main__":
    main()> 

Aplicando todo lo que hemos aprendido, escribi un programa que te pide la opción de la tabla de multiplicar y te la imprime espero que les sirva.

condicion = 1
while(condicion == 1):
    menu = """
Seleccione una opción:
    1) tabla de multiplicar del 1
    2) tabla de multiplicar del 2
    3) tabla de multiplicar del 3
    4) tabla de multiplicar del 4
    5) tabla de multiplicar del 5
    6) tabla de multiplicar del 6
    7) tabla de multiplicar del 7
    8) tabla de multiplicar del 8
    9) tabla de multiplicar del 9
    10) tabla de multiplicar del 10
    11) salir
    """
    print(menu)
    option = int(input("Escriba su opción: "))
    
    def tabla(numero):
        print(f"Tabla de multiplicar del {numero}")
        for i in range(1,11):
            print(f"{numero} * {i} = {numero*i}")
    if(option > 0 and option <= 10):         
        tabla(option)
        
    elif(option == 11):
        condicion = 0
    else:
        print("Escriba una condición correcta")

Así hice el programa de las tablas de multiplicar 💚

Con lo aprendido busque crear un programa que simulara una bomba, y pues bueno acá está el programa.

import time
print("¡CUIDADO CON LA BOMBA!")
for i in range(-10,0):
    print(-i)
    time.sleep(1)
time.sleep(1)
print('BUMMM!!!')

PSDT: Para que Python espere 1 seg antes de volver a imprimir use la función sleep de la librería time. Les recomiendo usarla ya que tiene otras funciones como time para obtener el tiempo local (fecha y hora) o altzone (para hallar la diferencia entre tu huso horario y el GMT 0 en verano)

Una lista se parece mucho a un array de JS

El curso es excelente, pero como sugerencia diría que cada clase debería terminar con un desafio de programación para compartir como aporte. Fijaría mucho mas los conocimientos adquiridos.

def tablas_multiplicar(opcion_menu,num_tabla):
    x = 1
    for x in range(x,num_tabla + 1):
        valor = opcion_menu * x
        print(str(opcion_menu) + ' X ' + str(x) + ' = ' + str(valor))


def run():
    opcion_menu = int(input('Numero a conocer su tabla: '))
    num_tabla = int(input('¿Hasta que numero? '))
    tablas_multiplicar(opcion_menu,num_tabla)


if  __name__ == "__main__":
    run()

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

for contador in range (1,1001):

print(contador)

for i in range(10):
print(11*i)

Alguien sabe por que en mi CMDER se imprime desde el 4 y no desde el 1? Si usé el mismo codigo que pone el profe x_x

Interesante curs introductorio de Python, motivante para continuar aprendiendo.

Esta fue otra forma en la que logré imprimir los número del 1 al 1000 con el bucle while. Sé que es mucho más largo que el que usó Facundo

def run():
    LIMITE = 1000
    
    contador = 1
    while contador <= LIMITE:
        print(f'{contador}')
        contador = contador + 1


if __name__ == '__main__':
    run()

Aquí les dejo este código que calcula la tabla de cualquier numero, una vez lo pongan les preguntara de nuevo por otro numero. Saludos.

 lista = []
 salir = False

 while not salir:
     numero = int(input("Introduzca un numero: "))

     if numero != 0:  
         lista.clear()      
         for i in range (0,11):
             resultado = i * numero
             lista.append(resultado)
         print(lista)
     else:
         print("Adios")
         salir = True```

Vi que todos ponían un ejemplo de su tabla de multiplicar y yo quise hacer la mía con lo aprendido.

Así me salió.

def tablas(numero_inicial, numero_final):
    for i in range(1, numero_final):
        print(numero_inicial * i)


def run():
    numero_inicial = int(input("Seleccione el número que quiere multiplicar: "))
    numero_final = int(input("Seleccione hasta donde quiere multiplicar su número: "))
    numero_final = numero_final + 1

    tablas(numero_inicial, numero_final)

if __name__ == '__main__':
    run()

El rango es un tipo de dato.

Los rangos son como un tipo de listas

Para mostrar la tabla de multiplicar del 5, 😉
for i in range(1,11):
print("5 * "+ str(i) + “=” + str(5*i))

Tambien podemos castear the range a list.

range( inicio, fin, pasos )

Lo mejor de todo esto es que para solucionar un problema hay distintas alternativas.

def repeticiones(inicio, fin):
for i in range(inicio, fin+1):
print(str(i))

def run():
inicio = int(input("INGRESE EL NUMERO INICIAL "))
fin = int(input("INGRESE EL NUMERO FINAL "))
repeticiones(inicio, fin)

if name == ‘main’:
run()

Otra forma de poner

contador = contador + 1

Se puede sintetizar en

contador += 1

Gracias, profesor facundo.
El el mejor profesor de programación que he tenido

Que impresionante este profesor! explica todo tan facil y fluido! ojala todos los profesores fuesen como el

Les comparto mi manera de sacar las tablas de multiplicar pidiendo un número 😃

def multiplicar(numero):
    for i in range(1,11):
        resultado = i*numero
        print(str(numero)+" multiplicado por "+str(i)+" es igual a "+str(resultado))

def run():
    opcion = int(input("Digita un número por favor: "))
    multiplicar(opcion)

if __name__ == '__main__':
    run()

Output:

Digita un número por favor: 2
2 multiplicado por 1 es igual a 2
2 multiplicado por 2 es igual a 4
2 multiplicado por 3 es igual a 6
2 multiplicado por 4 es igual a 8
2 multiplicado por 5 es igual a 10
2 multiplicado por 6 es igual a 12
2 multiplicado por 7 es igual a 14
2 multiplicado por 8 es igual a 16
2 multiplicado por 9 es igual a 18
2 multiplicado por 9 es igual a 20

Este es mi intento de las tablas de multiplicar

Fantástica explicación, cada día estoy aprendiendo más. 💪🏻💚

un pequeño programa hecho en python

def potencia(limite):
    cont = 0
    cont_2 = 2**cont
    while cont_2 < limite:
        print('2 elevado a ' + str(cont) + ' es igual a: ' + str(cont_2) )
        cont = cont + 1
        cont_2 = 2**cont


def cicloWhile(limite):
    contador = 0
    while contador < limite + 1:
        print(contador)
        contador = contador + 1

def cicloFor(limite):
    num = 0
    for num in range(limite + 1):
        print(limite - num)


if __name__ == '__main__':  # Entry point es igual que el main aqui empieza el programa
    pot = int(input('Introduce un numero: '))
    print('el valor elevado a ' + str(pot) + ' es igual a')
    potencia(pot)
    print('ciclo de while ' )
    cicloWhile(pot)
    print('ciclo de For ' )
    cicloFor(pot)

menu = """
Bienvenido a las tablas 🥼

1 - 5
2 - 7
3 - 9

Elige una opcion: """

opcion = int(input(menu))
 
if opcion == 1:
    for i in range(11):
        print(5 * i)
elif opcion == 2:
    for i in range(11):
        print(7 * i)
elif opcion == 3:
    for i in range(11):
        print(9 * i)
else:
    print('Elige una opcion correcta')

El ciclo for es popular y con razones. Es muy fácil de usar, no necesita declarar ninguna variable iterado antes porque puedes hacer en el ciclo, etc.

utilice el mismo código que antes pero reduje un par de líneas gracias a for:

def run():
    for vel in range(1, 376):
        segundos = vel / 40
        segundos = round(segundos)
        metros = vel / 3.6 * segundos
        metros = round(metros)
        print("Llegaste a " + str(vel) + " km/h en " + str(segundos) + " segundos y recorriste " + str(metros) + " metros." )
        vel = vel + 1


if __name__ == '__main__':
    run()

#forma 1
contador = contador + 1   
#forma2
contador += 1
#No existe incremento (++)  contador++

Traigo mi propia versión con todo lo que hemos aprendido:
Programa para calcular las tablas de multiplicar del número que el usuario desee y las veces que quiera.

El programa acaba hasta que el usuario ingresa un “no” o “n” en la pregunta del final “Check another one?”

def run():
    while True:
        multiplicand = int(
            input('\nEnter a number to show the multiplication table: '))

        for i in range(10):
            multiplier = i + 1
            proudct = multiplicand * multiplier

            print('{}x{} = {}'.format(multiplicand, multiplier, proudct))

        repeat = input('Check another one? (yes/no) or (y/n) ')

        if repeat == 'no' or repeat == 'n':
            break


if __name__ == '__main__':
    run()

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

# contador = 1
# for contador in range(1001):
#     print(contador)

for i in range(11):
    print(11 * i)

vi un ejercicio de una tabal de multiplicar esta es mi version:

TABLA = 10

def main():
    opcion = 1
    while opcion != 0:
        menu()
        opcion = int(input())
        if opcion < (TABLA+1) and opcion > 0:
            tabla(opcion)
        else:
            print('opcion no valida')


def menu():    
    i = 1
    print('que tabla quieres ver?')
    while i <= TABLA:
        print(str(i) + '.- Tabla del '+ str(i)) 
        i = i + 1
    print('0 para salir')


def tabla(numero):
    print('la tabla del '+ str(numero)+ ' 0es :')
    for i in range(1, TABLA+1):
        print(str(numero)+' x ' +str(i) +' = ' + str(i*numero))

if __name__ == '__main__':
    main()

<code> 

Usando los ciclos y las funciones, hice un script que te devuelve la series de Fibonacci en función a la longitud que definas:

def fibonacci(long):
    f1 = [0, 1]
    if long == 1:
        print ('Tu serie es: \n' + f1[0])
    elif long == 2:
        print('Tu serie es: \n' + f1[1])
    else:
        serie = f1
        for i in range (long - 2):
            new_number = sum(serie[-2::])
            serie.append(new_number)
        print('\n Tu serie es: \n' + str(serie))
            
def run():
    print ('''BIENVENIDO!
           ESTE PROGRAMA TE PERMITIRÁ CREAR LA SERIE DE FIBONACCI
           TÚ SOLO INGRESA LA LONGITUD QUE DESEAS QUE ESTA TENGA! \n''')
    
    long = int (input('Ingresa la longitud que tenadra tu serie de Fibonacci: \n')) 
    fibonacci(long)
    
if __name__ == '__main__':
    run()

Mi código pidiéndole al usuario qué tabla de multiplicar desea ver.

def run():
    tabla = int(input("Qué tabla de multiplicar quieres ver?: "))
    print (f"Pediste ver la tabla del {tabla}:")
    for multiplicador in range (1,11):
        print(f"{tabla}X{multiplicador} = {tabla*multiplicador}")

if __name__ == "__main__":
    run()

Una observación por si no lo notaron. Si imprimimos una LISTA en la consola aparecerá en corchetes. Saludos a todos muy buena clase!

Hola amigos, es mi primera vez que pongo la vista en Python y he hecho la tabla de multiplicar en unas pocas líneas. Creo que me brillan los ojos de alegría

menu = """Tablas de Multiplicar

Escribe la tabla de multiplicar del 1 al 10 que deseas ver: """

numero = int(input(menu))

for i in range(11):
    print(str(numero) + " por " + str(i) + " es igual a " + str(numero*i))

Un ciclo for dentro de otro ciclo for para imprimir las tablas del 0 a la del 10 con 3 líneas de código:

for i in range(10):
for multuplicando in range(11):
print(multuplicando * i)

bueno también valía hacer

print(contador+1)

Si alguien como yo tiene problemas para comentar y descomentar el código: use respectivamente la combinación de teclas: Ctrl-k-c, y Ctrl-k.u

Mi resumen de la clase:

# Problema: Escribir los números del 1 al 1000


# Opción rústica: Escribir línea por línea:
    # print(1)
    # print(2)
    # print(3)
    # print(4)
    # print(n)...


# Opción 2: Con bucle while
    # contador = 1
    # print(contador)
    # while contador < 1000:
        # contador += 1
        # print(contador)
    
    # a = list(range(1000))  # list: Escribe los resultados en forma de lista.
    # print(a)


# Opción 3: Utilizando bucle for:

    # range: equivale a un rango numérico que termina un número antes del escrito para range(1000)=999. range(X, Y)= elegimos el rango del número X al número Y-1.

# Respuesta para el problema presentado utilizando el bucle for:

for contador in range(1, 1000):
    print(contador)

    # El bucle se leería de la siguiente manera: Para la variable "contador" en el rango de 1 a 999:
    # imprimir los números que aparezcan en el rango para contador.```

Hice un ejercicio sencillo con división, también utilicé int para transformar el resultado a un número entero:

for i in range(1, 10):
    print(int(100 / i))

Haciendo uso de los bucles o ciclos que hemos visto logre un programa donde el usuario puede pedir las tablas de multiplicar de cualquier uno y parar el programa cuando desee:

<code> 
def mult(num):
    n = str(num)
    print("Esta es la tabla del N°" + n + ":")
    print("")
    for i in range (0,11):
        c = str(i)
        mult = str(num * i)
        end = n + " * " + c + " es igual a = " + mult + "."
        print(end)

def main():
    resp = 1
    terminal = 'Te puedo dar la tabla de multiplicar del número que quieras!'
    print(terminal)
    while resp == 1:
        print('')
        terminal1 = 'Digita el número deseado: '
        print('')
        num = int(input(terminal1))
        print('')
        mult(num)
        print('')
        print("¿Quieres mirar las tablas de otro número?")
        print("1.SI")
        print("2.NO")
        resp = int(input(""))
    print("ENTENDIDO! HASTA LUEGO.")


if __name__ == '__main__':
    main()

Resultado:

Muy buena explicación, hice un ejemplo con otra fórmula. Pero me interesa hacer los mismo con más de una variable.

for a in range(1, 20):
    print(a + a**2 + 1)

def run():
    menu = """
    VAMOS A VISUALIZAR LAS TABLAS DE MULTIPLICAR
    Selecciona la tabla que quieras ver:
        1. tabla del 1
        2. tabla del 2
        3. tabla del 3
        4. tabla del 4
        5. tabla del 5
        6. tabla del 6
        7. tabla del 7
        8. tabla del 8
        9. tabla del 9
        10. tabla del 10
            
¿Qué tabla quires ver? Elige una opcion: 
    """
    opcion = int(input(menu))
    if opcion <= 10:
        print(f'Elegiste la tabla del {opcion}:')
        while 0 < opcion < 11:
            for i in range(1, 11):
                print(i*opcion)
            break
    else:
        print('Esa no esta dentro de nuestras opciones')
        print('Vuelve a intentarlo por favor')


if __name__ == '__main__':
    run()

tablas= int(input("ingrese la cantidad de tablas: "))
multiplicador = int(input("Ingrese limite del multiplicador"))

for i in range(tablas):
    print("Tabla del "+str(i))
    for n in range (multiplicador):
        operacion = i*n
        print(str(i)+"x"+str(n)+"="+str(operacion))
 

Esto dice en la documentacion de python:
The “for” statement in Python always iterating over an arithmetic progression.
no dice ciclo ni bucle.

En el ciclo for podemos usar la función range(), lo que hace range() como el nombre lo dice es darnos un rango de números, como argumento le pasamos el límite del rango que queremos. range() genera una secuencia de números que va desde el cero hasta el número que se pasa como argumento menos 1. De hecho se pueden pasar tres argumentos, uno donde inicia la secuencia, el límite de la secuencia y el número de salto que queremos que de.

range(inicio, fin, salto)

En el ciclo for cuando usamos range() estamos indicando el límite para nuestro ciclo, y la variable que vamos iterando va tomando el valor que tiene la secuencia números en cada iteración, es decir, la variable va a ir tomando los valores que tiene range().

for i in range(10):
	print(i)

#OUTPUT
# 0
# 1
# 2
# 3
# 4
# 5
# 6
# 7
# 8
# 9