No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

List comprehensions

8/21
Recursos

Aportes 1205

Preguntas 36

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

solo uso el 36 por que es el numero multiplo de 4, 6 y 9 al mismo tiempo.

squares = [ i for i in range(1, 100000) if i % 36 == 0]
print(squares)

Esta entrada es útil para seguir profundizando e interiorizando.

all-about-python-list-comprehension

Mi solución al reto de la clase:

challenge = [i for i in range(1, 100000) if i % 4 == 0 and i % 6 == 0 and i % 9 == 0]
    print(challenge)
def run():
   
    number = [i for i in range(1, 100000) if i % 36 == 0]
   # number = [i for i in range(1,100000) if (i % 4 == 0 and i % 6 == 0 and i % 9 == 0)]
    print(number)



if __name__ == '__main__':
    run()

🤡 = Mi cara cuando Facundo hace en 1 línea lo que me maté haciendo en 6 con list comprehensions.

Saludos! … mi aporte

def run():

    squares = [i for i in range(1,1000000) if i%36==0 and len(str(i))<6]

    print(squares)

if __name__=='__main__':
    run()


mi codigo:

lista3 = [i for i in range(1, 100000) if i % 4 == 0 and i % 6 == 0 and i % 9 == 0]

print (lista3)

Solución al reto:

>>> solution = [ i for i in range(1,10000) if i % 4 == 0 and i % 6 == 0 and i % 9 == 0 ]
>>> solution
[36, 72, 108, 144, 180, 216, 252, 288, 324, 360, 396, 432, 468, 504, 540, 576, 612, 648, 684, 720, 756, 792, 828, 864, 900, 936, 972, 1008, 1044, 1080, 1116, 1152, 1188, 1224, 1260, 1296, 1332, 1368, 1404, 1440, 1476, 1512, 
1548, 1584, 1620, 1656, 1692, 1728, 1764, 1800, 1836, 1872, 1908, 1944, 1980, 2016, 2052, 2088, 2124, 2160, 2196, 2232, 2268, 2304, 2340, 2376, 2412, 2448, 2484, 2520, 2556, 2592, 2628, 2664, 2700, 2736, 2772, 2808, 2844, 2880, 2916, 2952, 2988, 3024, 3060, 3096, 3132, 3168, 3204, 3240, 3276, 3312, 3348, 3384, 3420, 3456, 3492, 3528, 3564, 3600, 3636, 3672, 3708, 3744, 3780, 3816, 3852, 3888, 3924, 3960, 3996, 4032, 4068, 4104, 4140, 4176, 4212, 4248, 4284, 4320, 4356, 4392, 4428, 4464, 4500, 4536, 4572, 4608, 4644, 4680, 4716, 4752, 4788, 4824, 4860, 4896, 4932, 4968, 5004, 5040, 5076, 5112, 5148, 5184, 5220, 5256, 5292, 5328, 5364, 5400, 5436, 5472, 5508, 5544, 
5580, 5616, 5652, 5688, 5724, 5760, 5796, 5832, 5868, 5904, 5940, 5976, 6012, 6048, 6084, 6120, 6156, 6192, 6228, 6264, 6300, 6336, 6372, 6408, 6444, 6480, 6516, 6552, 6588, 6624, 6660, 6696, 6732, 6768, 6804, 6840, 6876, 6912, 6948, 6984, 7020, 7056, 7092, 7128, 7164, 7200, 7236, 7272, 7308, 7344, 7380, 7416, 7452, 7488, 7524, 7560, 7596, 7632, 7668, 7704, 7740, 7776, 7812, 7848, 7884, 7920, 7956, 7992, 8028, 8064, 8100, 8136, 8172, 8208, 8244, 8280, 8316, 8352, 8388, 8424, 8460, 8496, 8532, 8568, 8604, 8640, 8676, 8712, 8748, 8784, 8820, 8856, 8892, 8928, 8964, 9000, 9036, 9072, 9108, 9144, 9180, 9216, 9252, 9288, 9324, 9360, 9396, 9432, 9468, 9504, 9540, 9576, 
9612, 9648, 9684, 9720, 9756, 9792, 9828, 9864, 9900, 9936, 9972]```

Puede ser mi impresión inicial, pero percibo que esta técnica hace que el código sea menos legible, hasta la forma de nombrarlo no sigue el estándar de izquierda a derecha. Claro que ahorra espacio y el código se puede ver “más elegante”, pero uno de los principios del Zen que vimos al principio dice que “es mejor más largo pero más legible”. Seguro me acostumbraré.

El código de forma extendida, se escribiría así:

def challenge():
    list_multiples = [number for number in range(1, 100000) if (number % 4  == 0 and number % 6 == 0 and number % 9 == 0)]
    print(list_multiples)

Esto se puede reducir a lo siguiente:

def challenge():
    list_multiples = [number for number in range(1, 100000) if (number % 4 + number % 6 + number % 9) == 0]
    print(list_multiples)

Finalmente, la forma más simplificada sería así:

def challenge():
    list_multiples = [number for number in range(1, 100000) if number % 36 == 0]
    print(list_multiples)

Simplificando (mínimo común múltiplo ) y usando el parámetro step de la función range, podemos resumir el reto en una sola linea de código.

print ([x for x in range(36,36,1000000)])

Para los que han visto teoría de conjuntos, podemos hacer una analogía al concepto de List Comprenhensions con la definición de Conjunto por comprensión, que es donde se tiene que especificar que condiciones cumplen los elementos de un conjunto y no es necesario mencionar uno por uno.

👾 Generando los primeros 100 números impares usando List comprehensions.

def run():
    list_numbers = [i for i in range(100 * 2) if i % 2 != 0]
    print(list_numbers)


if __name__ == '__main__':
    run()

Mi solución:

print([i for i in range(1, 10000) if i % 4 == 0 and i % 6 == 0 and i % 9 == 0])

Yo creé una función para la condición

def run():
    multiple_four = [num for num in range(1, 100000) if condition(num)]
    print(multiple_four)


def condition(num):
    return num % 4 == 0 and num % 6 == 0 and num % 9 == 0
    

if __name__ == '__main__':
    run()
list = [i for i in range(1, 100000) if i % 4 ==0 and i % 6 ==0 and i %9 ==0]
print(list)

def run():

    multiplos = [i for i in range (1, 100000) if i % 4 == 0 and i % 6 == 0 and i % 9 == 0]

    print (multiplos)

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

Yo lo hice así

reto = [i for i in range(1,100000) if (i%4 + i%6 + i%9) == 0]

Utiicé la suma en lugar de "and"s porque me pareció que se ee mejor.

Después de que le agarras practica, es mucho mas sencillo y fluido…
Reto cumplido 👍🏻😜

def run():
   squares = [i for i in range(1, 99999) if i % 36 == 0]
    print(squares)
    
if __name__=="__main__":
    run()

Cómo lo resolví

def run():
    lista =[i for i in range(1,1001) if i%4==0 and i%6==0 and i%9==0]
    print(lista) 

yo decidí modificar el reto para que de acuerdo a 2 números escogidos por el usuario, y el limite del rango, muestre solo sus múltiplos:

# hayar el Maximo común divisor

def mcd(a, b):
    temporal = 0
    while b != 0:
        temporal = b
        b = a % b
        a = temporal
    return a

# hayar el minimo comun multiplo.
def mcm(a, b):
    return (a * b) / mcd(a, b)

# crear una list comprehension de todos los multiplos elegidos por el usuario.
def run(top,a,b):
    nums=[i for i in range(1,top) if i%mcm(a,b) == 0]
    print(nums)
    

if __name__=="__main__":
    top=int(input("ingrese hasta que numero quiere validar los multiplos: "))
    a=int(input("escoja el primer factor: "))
    b=int(input("escoja el segundo factor: "))
    print("Los multiplos de ", a, " y ", b, " en el rango de 1 a ", top, "son: " )
    run(top, a, b)

Primero sacamos el m.c.m de 4, 6 y 9, nos da 36.

def run():
    array = [i for i in range(1, 10000) if i % 36 == 0]
    print(array)

if __name__ == '__main__':
    run()
def run():
    challenge = [x for x in range(1, 100000) if x % 36 != 0]
    print(challenge)

if __name__ == '__main__':
    run()

Esta es mi respuesta al reto, debo resaltar que el mínimo común múltiplo que implementaron otros compañeros en sus respuestas es un punto que tendré en consideración para futuras situaciones similares a las de este reto:

def run():
    multiples = [i for i in range(1, 100000) if i % 4 == 0 and i % 6 == 0 and i % 9 == 0]
    print(multiples)


if __name__ == '__main__':
    run()

Solution:

squares=[i for i in range(1,99999) if i% 36==0]

print( [i for i in range(1, 99999) if i % 4 == 0 and i % 6 == 0 and i % 9 == 0])

Mi aporte del challenge inicial

#lista de los 100 primeros numeros naturales al cuadrado
def run():
    natural_num_double = []
    for number in range(1,10):
        natural_num_double.append(number**2)

    print(natural_num_double)
if __name__ == '__main__':
    run()
print("\n List comprehensions de todos los multiplos de 4 que a su vez son multiplos de y 9 hasta de 5 digitos")
    new_numbers=[i for i in range (1, 100000) if i%4 == 0 and i%6 == 0 and i%9 == 0]
    print("Resultado:", new_numbers)
listaDivisores = [x for x in range(1,100000) if x%36 == 0]
print(listaDivisores)
my_list = [i for i in range(1,100000) if i % 4 == 0 and i%6 == 0 and i%9 == 0 and i <= 99999]
    print(my_list)

Simplifican mucho el código!

Mi aporte al desafío de la clase

def run():
 # squeres = []
 #  for i in range(1,101):
 #    if i % 3 != 0:
 #      squeres.append(i**2)
 # squeres = [i**2 for i in range(1,101) if i % 3 != 0]
 # print(squeres)

  challenge = [i for i in range(1,100000)if i % 9 == 0 and i % 6 == 0 and i % 4 == 0]
  print(challenge)

if __name__=='__main__':
    run()
mult469 = [i for i in range(1,100000) if (i%4==0)and(i%6==0)and(i%9==0)]
print(mult469)
# crear un list conprehension, una lista de todos
# los multiplos de 4 a la vez 6 y 9 multiplos
# hasta 5 digitos
def run():
    squares = [i for i in range(0, 100000) if  i % 4  == 0 and i % 6 == 0  and i % 9 == 0]
    print(squares)    


if __name__ == '__main__':
    run()

task=[element for element in range(1,10000)
if element%36!=0]
print(task)

Una forma obvia del ejercicio pedido

def run():

    multiples = [i for i in range(1, 9999) if i % 4 == 0 and  i % 6 == 0 and i % 9 == 0]
    print(multiples)


if __name__ == '__main__':
    run()

Yo lo resolví así:

squares=[i for i in range(1, 10000) if (i%4==0 and i%6==0 and i%9==0)]
    
    print(squares)

Después de ver sus comentarios y ver en consola que en vez de imprimir los números me imprimía booleanos, lo logré. Gracias a ustedes, comunidad, me di cuenta que el error estaba en poner igualdad en el módulo y no diferencia. Muchas gracias.

multiples = [i for i in range (1, 100000) if i % 36 ==0] 

Va como lo hice:

    squares = [i for i in range(1, 100000) if (i % 4 == 0) and (i % 6 == 0) and (i % 9 == 0)]  
    print(squares)

Pero debo hacer notar que no son necesarios los paréntesis en el if, debido a la precedencia de operadores (se ejecutan primero los %, luego los ==, luego los and). Los paréntesis los puse para ayudar a mi cerebro en la comprensión, nada más.

def run():
    # squares = []
    # for i in range (1, 101):
    #     if i % 3 != 0:
    #         squares.append(i**2)

    squares = [i for i in range(1, 100000) if (i % 4 == 0 and i % 6 == 0 and i % 9 == 0)]

    print(squares)



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


    list = [x for x in range(1,100000) if x%4 == 0 and x%6 ==0 and x%9 ==0]
    print(len(list))


if __name__ == '__main__':
    run()
def run():
    list_comprehensions = [i for i in range(1, 99999) if i % 4 == 0 and i % 6 == 0 and i % 9 == 0 ]
    print(list_comprehensions)

if __name__ == "__main__":
    run()

La respuesta al reto:

# List of multiples of 4 6 9
# Least common multiple of 4 6 9 = 36
multiples = [i for i in range(1, 100000) if i % 36 == 0]
print(multiples)

Mi solución para el primer reto de la clase:

def run():
    my_list = []
    counter = 1
    
    while len(my_list) <= 9:
      my_list.append(counter**2)
      counter += 1

    print(my_list)

if __name__ == '__main__':
    run()

.
Mi solución para el segundo reto de la clase:

def run():
    my_list = []
    
    for i in range(1, 11):
      if i % 3 == 0:
        continue
      else:
        my_list.append(i**2)

    print(my_list)

if __name__ == '__main__':
    run()

Mi solución al tercer reto 😄

def run():
    my_list = [element for element in range(1, 100000) if element % 36 == 0]

    print(my_list)


if __name__ == '__main__':
    run()

Mi solucion para los comprenhension es la siguiente:

def divisible_by_3(num):
    return num%3 == 0;

def divisible_by_9(num):
    return num%9 == 0;

def divisible_by_6(num):
    return num%6 == 0;

def divisible_by_4(num):
    return num%4 == 0;

def run():
    squares_divisibles_by_3_until_100 = [i**2 for i in range(1, 101) if not divisible_by_3(i)]
    print(squares_divisibles_by_3_until_100)

    print("\n<===================================================================>\n")
    
    numbers_divisible_by_9_and_6_and_4_until_99999 = [i for i in range(1, 100000) if divisible_by_9(i) and divisible_by_6(i) and divisible_by_4(i)]
    print(numbers_divisible_by_9_and_6_and_4_until_99999)

if __name__ == '__main__':
    run()

trate de seguir el zen de python, y hacer que el codigo sea mas legible creando funciones que me digan si el numero evaluado es divisible para X.

El print con varios signos ‘=’ solo es para separar el resultado en consola.

Aunque una version abreviada matematicamente seria esta como ya la compartieron varios compañeros

squares = [i for i in range(0,100000) if i % 36 == 0]
    print(squares) 

El reto de el 4, 6 y 9.

def run():
    squares = [i for i in range(1, 9999) if i % 4 == 0 and i % 6 == 0 and i % 9 == 0]

    print(squares)
#pista comienza por 36, 72, 108, 144, 180, 216...

if __name__ == '__main__':
    run() 

Se utilizo el o el and para poder hacer que se cumplieran las condiciones solicitadas

Ésta fue mi forma de solucionar el reto de añadir los números que sean múltiplos de 4,6 y 9 al mismo tiempo a una lista.

   #Reto - List Comprehensions.
    multiples = [i for i in range(1,100000) if i % 4 == 0 and 
                    i % 6 == 0 and i % 9 == 0]
    print(multiples)

Creo que llegué a la misma conclusión que la mayoría. Aunque lo de usar el 36 es bastante bueno 😛


    lista = [
        i for i in range(1,10000) 
        if i % 4 == 0 and i % 6 == 0 and i % 9 == 0
        ]
    print(lista)

Mi respuesta:

newList = [i for i in range (0,100000) if i%4 == 0 and i%6 ==0 and i%9 == 0]

💻 [i for i in range(1, 100000) if i % 4 == 0 and i % 6 == 0 and i % 9 == 0] ✔

<
 list = [i for i in range(1, 10000) if i % 4 == 0 and i % 6 == 0 and i % 9 == 0]

    print(list)
> 
def mult4595D ():
     multiplos = [i for i in range (0,100000) if i%4==0 and i%6==0 and i%9==0 ]
     print (multiplos)

if __name__ == '__main__':
    # cuadrados()
    #  squaresNotDiv3()
    # squareNot3lc()
    mult4595D ()

Espectacular

squares_new = [i for i in range(1, 99999) if i % 4 == 0 and i % 6 == 0 and i % 9 == 0]

[0, 36, 72, 108, 144, 180, 216, 252, 288, 324, 360, 396, 432, 468, 504, 540, 576, 612, 648, 684, 720, 756, 792, 828, 864, 900, 936, 972, 1008, 1044, 1080, 1116, 1152, 1188, 1224, 1260, 1296, 1332, 1368, 1404, 1440, 1476, 1512, 1548, 1584, 1620, 1656, 1692, 1728, 1764, 1800, 1836, 1872, 1908, 1944, 1980, 2016, 2052, 2088, 2124, 2160, 2196, 2232, 2268, 2304, 2340, 2376, 2412, 2448, 2484, 2520, 2556, 2592, 2628, 2664, 2700, 2736, 2772, 2808, 2844, 2880, 2916, 2952, 2988, 3024, 3060, 3096, 3132, 3168, 3204, 3240, 3276, 3312, 3348, 3384, 3420, 3456, 3492, 3528, 3564, 3600, 3636, 3672, 3708, 3744, 3780, 3816, 3852, 3888, 3924, 3960, 3996, 4032, 4068, 4104, 4140, 4176, 4212, 4248, 4284, 4320, 4356, 4392, 4428, 4464, 4500, 4536, 4572, 4608, 4644, 4680, 4716, 4752, 4788, 4824, 4860, 4896, 4932, 4968, 5004, 5040, 5076, 5112, 5148, 5184, 5220, 5256, 5292, 5328, 5364, 5400, 5436, 5472, 5508, 5544, 5580, 5616, 5652, 5688, 5724, 5760, 5796, 5832, 5868, 5904, 5940, 5976, 6012, 6048, 6084, 6120, 6156, 6192, 6228, 6264, 6300, 6336, 6372, 6408, 6444, 6480, 6516, 6552, 6588, 6624, 6660, 6696, 6732, 6768, 6804, 6840, 6876, 6912, 6948, 6984, 7020, 7056, 7092, 7128, 7164, 7200, 7236, 7272, 7308, 7344, 7380, 7416, 7452, 7488, 7524, 7560, 7596, 7632, 7668, 7704, 7740, 7776, 7812, 7848, 7884, 7920, 7956, 7992, 8028, 8064, 8100, 8136, 8172, 8208, 8244, 8280, 8316, 8352, 8388, 8424, 8460, 8496, 8532, 8568, 8604, 8640, 8676, 8712, 8748, 8784, 8820, 8856, 8892, 8928, 8964, 9000, 9036, 9072, 9108, 9144, 9180, 9216, 9252, 9288, 9324, 9360, 9396, 9432, 9468, 9504, 9540, 9576, 9612, 9648, 9684, 9720, 9756, 9792, 9828, 9864, 9900, 9936, 9972]

Ejercicio y Reto

def run():
    squares= []
    #metodo tradicional
    print("-"*20+" TRADICIONAL "+"-"*20)
    for i in range(1,101):
        if i % 3 != 0:
            squares.append(i**2)    
    print(squares)
    print("-"*20+" COMPREHENSIONS "+"-"*20)
    #con list comprehensions
    squares = [i**2 for i in range(1,101) if i % 3 != 0]
    print(squares)
    
    #Reto
    #crear un list comprehensions, una lista de todos los multiplos de 4 que a la vez tambien son multiplos de 6 y de 9 hasta 5 digitos
    print("-"*20+" RETO "+"-"*20)
    reto = [i for i in range(99999) if i % 4 == 0 and i % 6 == 0 and i % 9 == 0]
    print(reto)
    

if __name__ == '__main__':
    run()

Antes de la clase:

def run():
    my_list = []
    for i in range(1,101):
        my_list.append(i**2)
    print(my_list)
    

if __name__ == '__main__':
    run()
def run():
    my_list = []
    for i in range(1,101):
        if i**2 % 3 == 0:
            continue
        my_list.append(i**2)
    print(my_list)
    

if __name__ == '__main__':
    run()

def run():
numberscase = [i for i in range (1, 99999) if i % 4 == 0 and i % 6 == 0 and i % 9 == 0]
print(numberscase)

if name == ‘main’:
run()

multiples = [i for i in range(1, 1000) if i % 4 == 0 and i % 6 == 0 and i % 9 == 0]
print (multiples)
[36, 72, 108, 144, 180, 216, 252, 288, 324, 360, 396, 432, 468, 504, 540, 576, 612, 648, 684, 720, 756, 792, 828, 864, 900, 936, 972]

multiples = [i for i in range(1, 1000) if i % 4 == 0 and i % 6 == 0 and i % 9 == 0]

Mi código del reto

def run():
    list_num =[i for i in range(1, 100000) if i % 4 == 0 and i % 6 == 0 and i % 9 == 0]
    print(list_num)

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

Encontré que uno puede incluir un if y un else en la tecnica de list comprehensions aplicado al siguiente código

def letra_kcif_cesar(alfabeto_inicial, k, indice):
    """
    retorna la letra cuya posicion es 'indice' en el alfabeto cifrado usando la tecnica de cifrado cesar

    Args:
        alfabeto_inicial (Lista de caracteres): alfabeto base
        k (int): Numero de posicones con corrimiento a la derecha del alfabeto base
        indice(int): Posicion del alfabeto base al que se desea retorna el equivalente al alfabeto cifrado

    Returns:
        string: Letra cifrada mediante tecnica de cifrado cesar 

    Ejemplo:
        alfabeto = ['A','B','C','D','E','F','G','H','I','J','K','L', ...]
        k = 3
        indice  = 2
        alfabeto[2] = 'C'
        
        alfabeto cifrado = ['X', 'Y', 'Z', 'A','B','C','D','E','F','G','H', ...]
        letra_kcif_cesar[alfabeto, 3, 2] ='Z'

    """
    n = len(alfabeto_inicial)
    k = k%n
    indice = indice%n
    alfabeto_kcif = [alfabeto_inicial[i-(n-k)] if i >= k-n else alfabeto_inicial[i+k] for i in range(n)]

    return alfabeto_kcif[indice]
def run():
    squers = []
    
    for i in range(1,101):
        if i%3 == 0:
            
            continue
        squers.append(i**2)

    print ( squers)
if __name__ == '__main__':
    run()

pero hey… apliqué continue jaja

comparto todo mi codigo. espero que a alguien le sirva como a mi.

def run ():
#    squares = []
#    for i in range(1, 101):
#        if i % 3 !=0:
#            squares.append(i**2)

#    squares = [i**2 for i in range(1,101) if i % 3 !=0]

    reto = [i for i in range(1, 100000) if i % 4 == 0 and i % 6 == 0 and i % 9 == 0]

    print(reto)


if __name__ == "__main__":
    run()

Me asusté un poco con el resultado, pensé que había hecho algo mal. 😢

list1 = [ i for i in range (1,99999) if i % 4 ==0 if i % 6 ==0 if i % 9 ==0 ]
print (list1)

def run():
    squares = [i for i in range(1, 100000) if (i % 4 == 0 and i % 6 == 0 and i % 9 == 0)]
print(squares )


if name == “main”:
run()

list =[ i * 36 for i in range (1 , 99999)]
print(list)

def run():

    list_of_numbers = [i for i in range(1, 100000) if i % 4 ==0 if i % 6 ==0 if i % 9 ==0]
    print(list_of_numbers)

if __name__ == '__main__':
    run()

squares = [i for i in range(1, 300) if i % 4 == 0 and i % 6 == 0 and i % 9 == 0]

print(f"Numero = {squares} ")

Este es mi codigo con el recorrido para una super lista:
for nombre in super_list:
print(f"Super List = {nombre} ")

squares2 = [ i for i in range(1, 99999) if i % 4 == 0 if i % 6 == 0 if i % 9 == 0 ]
print(squares2)

Reto 😁

def run():
#Desafío
    lista = [i for i in range(1,100001) if i%4 ==0 and i%6==0 and i%9==0]
    print(lista)

if __name__ == '__main__':
    run()

Aquí mi propuesta de solución al reto con una función:

 def my_list_comp (limit):
    """
    Create a list using list comprehension with a for loop and if statement.
    limit --> The maximum range wanted, not the size of the list.
    return result --> List with the products of 4, 6 and 9.
    """
    result = [i*4 for i in range(0, limit) 
              if not (i*4 % 6) and not (i*4 % 9)]
    return result

😅 💪

Reto

<code> 
def cuadrados(n):
    #Guarda los cuadrados que son divisibles por 4, 6 y 9

    lista = [i*4 for i in range(n) if i*4 % 6 == 0 and i*4 % 9 == 0] 
    return lista

def run():

    n = int(input("Ingresa la cantidad de numeros a los que quieres ver si es un multiplo de 4 y también de 6 y 9: "))
    cuadrado = cuadrados(n+1)
    for i in cuadrado:
        print(i)

if __name__ == "__main__":
    run()   

[i for i in range(1,1000000) if i % 4 == 0 and i % 6 == 0 and i % 9 == 0]

Sería así el reto

result = [i for i in range(1,100000) if i % 4 == 0 and i % 6 == 0 and i % 9 == 0 ]

Comparto la solución:

multiplos_cuatro = [i*4 for i in range(1, 100000) if ((i*4 % 36 == 0) and (i*4) < 99999)]
    print(multiplos_cuatro)
def run():
    # squares = []
    # for i in range(1, 101):
    #     if i % 3 != 0:  # guardando los cuadrados si el número no es divisible por 3
    #         squares.append(i**2)

    # squares = [i**2 for i in range(1,101) if i % 3 != 0]

    squares = [i for i in range(1,10001) if i % 36 == 0] #Para determinar si el número es divisible por 4,6 y 9 es de utilidad pensar en el minimo común multiplo, y jaaa si se usa despues de la escuela xd

    print(squares)


if __name__ == '__main__':
    run()

Así me quedó el código:

#!env/bin/python3

def run():
    '''
    Crear con un list comprehension, 
    una lista de todos los múltiplos 
    de 4 que a su vez también son múltiplos 
    de 6 y de 9, hasta cinco dígitos
    '''
    multiplos =[
        x for x in range(1,200)
        if x % 4 == 0 and x % 6 == 0 and x % 9 == 0
    ]
    print(multiplos[:5])
if __name__ == '__main__':
    run()

El reto lo hice algo diferente y creo que me compliqué bastante 😦, igual ahí va:

def main():
    numeros = []
    numeros_cuadrados = []
    for i in range(1,101):
        numeros.append(i)
        numeros = numeros_cuadrados
    for j in range(1, len(numeros)):
        numeros_cuadrados[j] = numeros_cuadrados[j]**2 
        
    print(numeros_cuadrados)
    
    
if __name__ == '__main__':
    main()

def run():
multiplos = [x for x in range(1, 10000)
if x % 4 == 0 and x % 6 == 0 and x % 9 == 0]
print(multiplos)

if name == ‘main’:
run()

buenas noches compañeros, aquí dejo mi aporte:

lista = [n*4 for n in range (1,99999) if n*4 % 9 == 0 and n*4 % 6 == 0 ]
filter = [i for i in range(0,99999) if i%36 == 0]
# lista de cuadrados no divisles por 3

def funcion_cuadrado():
    lista = []

    for i in range (1,101):
        lista.append(i*i)
    for i in range (0,99):
        if lista[i] % 3 == 0:
            lista[i]=0
    for i in range (1,34):
        lista.remove(0)        
    print(lista)


def run():
    print ('Los 100 primeros números cuadros son: ')
    funcion_cuadrado()


if __name__=='__main__':
    run()

Puede ser de esta manera usando operadores logicos.

nums_exp=[i for i in range(1,1000) if i%4==0 and i%6==0 and i%9==0]
    print(nums_exp)

if __name__=='__main__': 
    run()

def run():
lista=[i for i in range(1,10000) if i%9 0 and i%30 and i%4 ==0]

print(lista)

if name==‘main’:
run()

def run():
    list = [i for i in range(1, 100000) if (i % 4 == 0 and i % 6 == 0 and i % 9 == 0)]

    print(list)



if __name__ == '__main__':
    run()

publico mi código por las sutilezas que empiezo a notar en los puntos de vista.

def run():
# Square = []
# for i in range(1, 101):
# if (i2)%3 == 0:
# continue
# Square.append(i
2)

# print(Square)

squares = [i for i in range(1, 100) if (i**2)%3 = 0]

print(squares)

if name == ‘main’:
run()

Este es mi código

#!/usr/bin/env python3

def main():
    lista = [i  for i in range(1, 9999) if i % 4 == 0 and i % 6 == 0 and i % 9 == 0 ]
    print(lista)

if __name__ == '__main__':
    main()

def run():
challenge = [i for i in range(1, 100000) if i % 4 == 0 and i % 6 == 0 and i % 9 == 0]

print(challenge)

if name == “main”:
run()

    squares = [i for i in range(1, 10000) if i % 36 == 0 and len(str(i)) < 6]
    print(squares)
list_comprehensions = 
	[i for i in range(1, 500) if i % 4 == 0 and i % 6 == 0 and i % 9 == 0 ]
	print(list_comprehensions)

print [36, 72, 108, 144, 180, 216, 252, 288, 324, 360, 396, 432, 468]