Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Curso Básico de Python

Curso Básico de Python

Facundo García Martoni

Facundo García Martoni

Explorando un bucle diferente: el ciclo for

23/32
Recursos

El ciclo for es un tipo de bucle usado cuando se conozcan la cantidad de veces a iterar.

Un contador es una variable que se encarga de contener valores que irán 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.

Ejemplo 2: 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 realizar.

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, hasta n. Es decir, puede ser cualquier número que conserve siempre el mismo valor durante todo el programa.

Su 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

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

Ejemplo del bucle for en Python

def imprimir_numero(inicio, fin):
    for inicio in range(fin+1):
        print(f'Numero: {inicio}')


def imprimir_numero_while(inicio, fin):
    while inicio <= fin:
        print(f'Numero: {inicio}')
        inicio += 1

def run():


    while True:
        print('')
        print('*********************************************************')
        print('*******************N U M E R O S**********************')
        print('')
        inicio = int(input('Digite el número inicial para la secuencial:  '))
        print('')
        fin = int(input('Digite el número final para la secuencial: '))
        print('')

        if inicio < fin:
            imprimir_numero(inicio,fin)
        else:
            print(f'El numero inicial {inicio} debe ser ser menor al numero final {fin}.')



if __name__ == "__main__":
    run()

Aporte creado por: Rusbel Bermúdez, Martin Borges.

Aportes 428

Preguntas 63

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

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

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.

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

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.```

Mi versión para las tablas de multiplicar 😃

#!/usr/bin/python3
# create by: jakepy

def tablas():
    # pedimos datos al usuario
    base = int(input("[*] Dame el numero de la tabla: "))
    limite = int(input("[*] Dame el numero hasta cuanto se le multiplica: "))


    for i in range(1, limite + 1):
        resultado = base * i

        print(f"{base} X {i} = {resultado}")


if __name__=="__main__":
    tablas()

Información resumida de esta clase
#EstudiantesDePlatzi

  • (contador = contador + 1) podriamos escribir (contador += 1) funciona igual

  • Sabemos que un contador es una variable que se va a incrementar progresivamente

  • Bucle o ciclo son lo mismo

  • Puedo crear un bucle con for utilizando range y se más eficiente

El for nos ayuda a disminuir la cantidad de líneas y optimiar el funcionamiento de nuestro código.

numeros del 1 a 1000 con ciclo while
def run():

HASTA = 1001
contador = 0

while contador < HASTA:
    
    print("la lista es asi: "+str(contador))
    contador = contador + 1

if name == “main”:
run()

Hice el ciclo while por mi cuenta antes que empezara aqui se los dejo:

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

Tambien se puede hacer de esta forma del 1 al 1000:

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

el codigo basicamente es para imprimir todas las tablas del 0 al 9, pero tambien se puede crear un codigo donde solo imprimas la tabla que seleciones

Tan sinónimos o similares lo serán en alguans ocaciones. Sí resovemos el ejemplo anterior con ‘for’ no nos será tan corto el programa, y hasta sería más complejo de entender.

Termine preparando una tabla de multiplicar, pero mas reducida, donde se elije cual mostrar.

a = int(input('¿Que tabla de multiplicación hasta 10 quieres ver? '))
print(f'La tabla de multiplicar del {a}')
for b in range(11):
    print (f'{a} x {b} = {a*b}')

Buenas tardes Compañeros me parecio interesante jugar un poco con lo que llevamos del curso y me puse a jugar a realizar las tablas de multiplicar comparto mi codigo por si alguno tiene dudas o quiere solo probarlo .

def run():
pass

creamos la funcion de la tabla de multiplicar

def tabla(a):
# imprimirmos en patntalla el la tabla a mostrar
print('Tabla del ’ + str(a))
# ejecutamos el ciclo for para realizar la operacion segun la tabla seleccionada
for num in range(1,11):
# realizamos la oreparacion de multiplicación
resultado = a * num
# imprimimos el resultado de la operación
print(str(a) + ’ X ’ + str(num) + ’ = ’ + str(resultado))

menu de opciones de la tabla a mostrar

menu = “”"
TABLAS DE MULTIPLICAR

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

Elige una opción:
"""

pedimos al usuario seleccionar una tabla

opcion = int(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)
elif(opcion == 10):
tabla(10)
else:
print(‘Ingrese una opción correcta por favor’)

if name == ‘main’:
run()

  • si alguien está interesado en aprender más,
    aqui les dejo esto.

https://docs.hektorprofe.net/python/controlando-el-flujo/iteraciones/

  • Hice una tabla de multiplicar con menos código, está expuesta a errores lógicos.
def run():
    tabla = int( input('Inserta la tabla que quieres: ') )
    for m in range(0,11):
        print('{} x {} = {}'.format(tabla,m,tabla*m))

if __name__ == '__main__':
    run()