List Comprehension

Ejemplo de los días con letra ‘a’

for :

days = ["lunes", "martes", "miercoles", "jueves", "viernes", "sabado", "domingo"]
newlist = []

for i in days:
  if "a" in i:
    newlist.append(i)

print(newlist) #["martes", "sabado"]

List Comprehension

days = ["lunes", "martes", "miercoles", "jueves", "viernes", "sabado", "domingo"]

newlist = [i for i in days if "a" in i]

print(newlist) # ["martes", "sabado"]

¿Encerio crees que ya comprendiste el tema?

Te tengo un reto para comprobarlo

Entra a este reto de hackerRank y pon a prueba lo aprendido 😎

Pista:

>>> print([[x, y] for x in [1, 2, 3] for y in [4, 5, 6]])
[[1, 4], [1, 5], [1, 6], [2, 4], [2, 5], [2, 6], [3, 4], [3, 5], [3, 6]]

Si requieres un empujoncito para pasar el reto, te recomiendo que veas la pestaña de tutorial de HackerRank (En la parte inferior izquierda o superior derecha).

List Comprehension

Si quieren cambiarle el nombre a una variable que esta en varias partes del código

.
Basta con poner el cursos al comienzo de esa variable, presionar Ctrl + F2 y luego F2. Te saldra un cuadrito de texto pidiendo el nuevo nombre:
.

.
el cambio se aplicara en todas las variables con el mismo nombre.
.

Comprensión de lista:

• Es una lista que tiene por contenido una operación en vez de una lista de conjuntos, y estas operaciones se realizan con un for para poder iterar y sacar los datos de la lista, y esta lista tiene la siguiente forma:

También podemos buscar si hay ciertos elementos dentro la lista con el comando “in” de la siguiente manera, “Elemento a buscar - in - nombre de la lista”.

Wow, sí que facilita la legibilidad del código.

Así tomé mis apuntes en Word:
Yo cómo entiendo esto? Como si tuviese una cantidad de gallinas, y quisiera ver una gallina una a una detalladamente y hacerle algo una a cada a una. Para hacer esto, sé cuántas gallinas tengo, se lo digo en el RANGE(1,11) pues estamos diciendo que tiene diez gallinas, por lo que le estoy diciendo que tendrá que tomar gallina una a una diez veces distintas. La escritura del código sería “Gallina a Gallina”, que en inglés es igual a “Gallina for Gallina”, o “Element for Element”. Asi que el código le dice que tome gallina a gallina en un rango del 1 al 10 a través de: element for element in range [1,11].
Ya la manera de lenguaje se torna más literal y me gusta.

Qué chulada la de Python

Otra clase que es una maravilla:

list_v1 = []

for i in range(1,11):
  list_v1.append(i * 2)

print(list_v1)

list_v2 = [i * 2 for i in range(1,11)]
print(list_v2)


list_v3 =[i * 2 for i in range(1,101) if i % 3 == 0]
print(list_v3)

A lo que vine a este curso, a empaparme de list comprehensions

Esta clase me frustró un poco porque no entendia toda esta rama de los Comprehensions, le pregunté a chatGPT que me diera una definicion y me dio esto
Las comprehensions de Python son una forma concisa y legible de crear listas, conjuntos y diccionarios en una sola línea de código. La sintaxis básica de las comprehensions es la siguiente:

Lista comprehension: [expresión for elemento in iterable]
Conjunto comprehension: {expresión for elemento in iterable}
Diccionario comprehension: {clave: valor for elemento in iterable}

Espero les sirva 😃

Hice un ejemplo usando nombres de participantes de una carrera y filtre a aquellos que tengan la letra n (ya sea minúscula o mayúscula).

#Hagamos un ejemplo diferente: Supongamos que queremos hacer una lista de los nombres de todos los participantes de una carrera pero sólo de aquellos que tengan la letra N
race_participants = ["Juan", "Maricela", "Pedro", "Erick", "Betzabet", "Carlos", "Nicolas", "Ramon", "Mabel", "Stan", "Diana"]

#Veamoslo de una forma intuitiva primero
n_names = []

for name in race_participants:
  if "n" in name.lower():
    n_names.append(name)

print(n_names)

#Ahora, hagamoslo con list comprehension
n_names_2 = [name for name in race_participants if "n" in name.lower()]

print(n_names_2)

Algunos ejemplos de más, espero les guste:

**El código **

    one = [ x**2 for x in [1,2,3] ]
    #[1,4,9]

    two = [ x/2 for x in [4,5,6,7,2,7,3,8,2] if x > 5 ]
    #[3.0, 3.5, 3.5, 4.0]

    three = [ f'{x}_{x}' for x in 'Tu nombre aquí']
    #['T_T', 'u_u', ' _ ', 'n_n', 'o_o', 'm_m', 'b_b', 'r_r', 'e_e', ' _ ', 'a_a', 'q_q', 'u_u', 'í_í']

    four = [ f'{x}_{x}' for x in 'Quitamos los espacios' if x!= ' ']
    #['Q_Q', 'u_u', 'i_i', 't_t', 'a_a', 'm_m', 'o_o', 's_s', 'l_l', 'o_o', 's_s', 'e_e', 's_s', 'p_p', 'a_a', 'c_c', 'i_i', 'o_o', 's_s']

    text = 'The powerful of python'
    five = [ord(x) for x in text]
    #[84, 104, 101, 32, 112, 111, 119, 101, 114, 102, 117, 108, 32, 111, 102, 32, 112, 121, 116, 104, 111, 110]

    sixe = [(x + 5 if x > 4 else x -10) for x in range(1,11)]
    #[-9, -8, -7, -6, 10, 11, 12, 13, 14, 15]

    seven = ["Python3"[i::-1] for i in range(7)]
    #['P', 'yP', 'tyP', 'htyP', 'ohtyP', 'nohtyP', '3nohtyP']
    ma = [1,2,3,4,5]
    mb = [6,7,8,9,0]
    eight = [x*y for x in ma for y in mb]
    #[6, 7, 8, 9, 0, 12, 14, 16, 18, 0, 18, 21, 24, 27, 0, 24, 28, 32, 36, 0, 30, 35, 40, 45, 0]
    
    nine = [[x for x in range(y+2)] for y in range(4)]
    #[[0, 1], [0, 1, 2], [0, 1, 2, 3], [0, 1, 2, 3, 4]]

En el 2021, a fines, estudié con otro profesor y me hizo entenderlo de este forma:

element for element in range(1, 11)

Para cada element dentro del rango del 1 al 11, voy a agregarle un element

i * 2 for i in range(1, 11) if i % 2 == 0

Para cada i en el rango del 1 al 11, voy a agregarle una i multiplicada por 2, solo y cuando i % 2 sea igual a 0

Love you

List Comprehension permite a través de una sintaxis corta crear una nueva lista basada en los valores de una lista existente.

Agradezco mucho la simplicidad con la que explicas el uso de
"for" para mi fue una función muy difícil de entender y contigo queda demasiado claro.

Hola les comparto un pequeño código que hice para solucionar un code chalenge.

básicamente el reto era ingresar 3 números, el cuarto lo guardamos en n, había que guardar en una lista de listas las combinaciones de los 3 números que su suma fuera diferente a n, con este ejercicio me quedo mucho más claro el tema de lists comprehensions.

x = int(input())
y = int(input())
z = int(input())
n = int(input())
    
permutations = [[i,j,k] for i in range(0,x+1) for j in range(0,y+1) for k in range(0,z+1) if i+j+k != n]
    
print(permutations)

Hola. aqui aprendiste el concepto de List Comprehension y como se crea mas no para que se usa y porque deberias usarlo.
CONCEPTO: el concepto de List comprehension es que es una nueva estructura de datos en Python mas avanzada que te permite agrupar una linea de codigo en algo mas legible y compacta en tu programa.
COMO SE CREA: variable = [i for i in iterable] #ejemplo

tu podrias crear la linea de codigo asi:

lista = []

for num in range(1,20):
    lista.append(num*2)
print(lista)    

se lee: Creamos una lista vacia que va a contener los valores recorridos por el ciclo for en el rango de 1 a 20 que seran llamados num, la lista vacia va a agregar a cada uno de esos numeros devueltos como multiplicacion en 2
y finalmente se emprime la lista.

todo eso lo puedes hacer (sin tener necesidad de escribir append).

lista = [num*2 for num in range(1,20)]
print(lista)

y es exacatamente lo mismo.

Pero digamos en caso tal que tenga varias condiciones, 7 por ejemplo, creo que al final tendríamos una línea de código muy larga, y para leer la línea sería complejo no?. Para usar la list comprehension depende del contexto, porque también puede ser mejor la forma tradicional

hace algún tiempito aprendí List Comprehension.
La verdad es que es una buena manera de hacer el código legible.
Procuro usarlo seguido.

hola:

#estructura con condicion: [element for element in iterable if condition]
#Forma tradicional:
print('Forma Tradicional:')
numbers = [] 
for i in range(1,11):
  if i % 2 == 0:
    numbers.append(i *2)

print(numbers)
print('-'*10)
#Forma de list comprehension
print('Forma con list comprehension:')
numbers_v2 = [i *2 for i in range(1,11) if i % 2 == 0]
print(numbers_v2)
print('-'*10)

List Comprehension

[element for element in iterable]

• Element: variable que se va a agregar a la lista
• For: ciclo for que va a recorrer el iterable
• Iterable: objeto que se va a recorrer, puede ser una lista, tupla, diccionario, etc

# List Comprehension
numbers = [element for element in range(0, 101)]
print(numbers)

Un aporte extra

'''
numbers = []
for element in range(1, 11):
  numbers.append(element * 2)

print(numbers)


numbers_v2 = [element * 2 for element in range(1, 11)] # iterar un rango con menos lineas de codigo y legibles
print(numbers_v2)
'''
numbers = []
for i in range(1, 11):
  if i % 2 == 0:
    numbers.append(i * 2)

print(numbers)

numbers_v2 = [i * 2 for  i in range(1, 11) if i % 2 == 0]
print(numbers_v2)

Para obtener los números que son múltiplos de 5 menores a 50

numbers_m5 = []
for i in range(1, 50):
  if i % 5 == 0:
    numbers_m5.append(i)
print(numbers_m5)

List Comprehension

numbers_m5 = [i for i in range(1, 50) if i % 5 == 0]
print(numbers_m5) 

Ya lo había visto en la documentación gracias Profe Nico, mucho mas claro.

Notas de clase

numbers = []
for element in range(1, 11):
  numbers.append(element*2)
print(numbers)

#Utilizando List Comprehension
numbers_v2 = [element*2 for element in range(1,11)]
print(numbers_v2)

#con condicional
numbers = []
for i in range(1, 11):
  if i % 2 == 0:
    numbers.append(i)
print(numbers)

#Utilizando List Comprehension
numbers_v2 = [i for i in range(1,11) if i % 2 == 0]
print(numbers_v2)

# Se crea una lista con una list comprehension; en donde, se recorre un rango de 10 números.
# Se comprueba que estos numeros sean divisibles por tres.
# Se eleva al cuadrado el numero final y se guarda en la lista
my_list: list = [i ** 2 for i in range(1,11) if i % 3 == 0]
print(my_list)

countries = {“MX”, “COL”, “ARG”, “USA”}
northAm = {“USA”, “CANADA”}
centralAm = {“MX”, “GT”, “BZ”}
southAm = {“COL”, “BZ”, “ARG”}

new_set = set(countries | northAm | centralAm | southAm)

print(new_set)

#Saludos Nicolas Molina

mi ejercicio de prueba:

pares = []
for par in range(1, 101):
  if par % 2 == 0:
    pares.append(par)
print(pares)

#list comprehention
imparess = [impares for impares in range(1, 101) if impares % 2 != 0]
print(imparess)

Use un metodo para crear un nuevo array con nombres que no empezaran con la letra “d”.

arr = ["daniel", "daria","jose","ernesto"]

 newArr = [element for element in arr if not element.startswith("d")]

OUTPUT:
["jose", "ernesto"]

Realmente se me hace dificil entenderlo por el momento 😢

tuve que ver varias veces esta clase. definitivamente leer la sintaxis es un poco complejo para nosotros lo principiantes, pero una vez que logras comprender da una gran satisfacción.

Les comparto este pequeño reto para practicar list comprehensions:

Crear un set con los números del 1 al 1000, y mostrar los números que son divisibles entre 7 pero no entre 5.:

– Posible respuesta:

def div():
  list = [x for x in range(1,1001)]
  list2 = [x for x in list if x % 7 == 0 and x % 5 != 0]
  set1 = set(list2)
  return set1

print(div(), end=" ")

List Comprehension

En Python, las comprensiones (comprehensions) son una forma concisa y elegante de construir una nueva lista, conjunto o diccionario a partir de otra colección de datos utilizando una sintaxis compacta.

Existen tres tipos de comprensiones en Python:

Comprehensions de lista

La comprensión de lista (list comprehension) es una forma de construir una nueva lista a partir de otra lista o cualquier otra colección de datos iterable. Su sintaxis es la siguiente:

nueva_lista = [expresion for elemento in iterable if condicion]

• expresion: es una expresión que define cómo se deben transformar los elementos originales.
• elemento: es una variable que toma los valores de cada elemento de la colección original.
• iterable: es una colección de datos iterable, como una lista, tupla o conjunto.
• condicion (opcional): es una condición que filtra los elementos de la colección original.

Por ejemplo, para crear una nueva lista que contenga el cuadrado de los números pares de una lista original, podemos usar una comprensión de lista de la siguiente manera:

numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
cuadrados_pares = [x**2 for x in numeros if x%2 == 0]
print(cuadrados_pares)  # Salida: [4, 16, 36, 64, 100]

Se siente muy satisfactorio cuando luego un tiempo atras ver esa chorrera de cosas impactaba no poder saber que era y que ahora haces esa chorrera y la puedes leer:
Disfruten el aprendizaje ya que ese es el valor de la clave : exito 😂 (like si captaste el sublime):

Excelente explicación 👏👏👏

Los hice con colores

#Primero
colors = ['green', 'blue', 'yellow', 'red', 'orange', 'pink', 'purple', 'gray']
colors_v2 = []
for element in colors:
    if 'e' in element:
        colors_v2.append(element)
print(colors_v2)

#Segundo
colors = ['green', 'blue', 'yellow', 'red', 'orange', 'pink', 'purple', 'gray']
colors_v2 = [element for element in colors if 'e' in element]
print(colors_v2)

Python 🔥

Las List Comprehensions (Comprensiones de Listas) son una característica poderosa y compacta en Python que te permite crear listas de manera concisa utilizando una sola línea de código. Son especialmente útiles cuando deseas aplicar una operación o una transformación a cada elemento de una secuencia (como una lista) y crear una nueva lista basada en esos elementos transformados. Las List Comprehensions se componen de tres partes clave:
[expresión for elemento in iterable if condición]

1. Expresión: La expresión que se evalúa para cada elemento de la secuencia y se utiliza para crear los elementos de la nueva lista.
2. Secuencia de Origen: La secuencia de la cual se toman los elementos para aplicar la expresión. Puede ser una lista, una cadena, una tupla o cualquier otro iterable.
3. Filtros (opcional): Puedes agregar filtros condicionales para seleccionar solo los elementos que cumplan ciertas condiciones.

A continuación, te mostraré algunos ejemplos de List Comprehensions para que puedas comprender mejor cómo funcionan:

Ejemplo 1: Crear una lista de cuadrados de números del 0 al 9:

pythonCopy code
cuadrados = [x ** 2 for x in range(10)]
# cuadrados contendrá [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Ejemplo 2:` Filtrar números pares de una lista:

pythonCopy code
numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
pares = [x for x in numeros if x % 2 == 0]
# pares contendrá [2, 4, 6, 8, 10]

Ejemplo 3: Crear una lista de palabras con más de 3 letras:

pythonCopy code
palabras = ["hola", "Python", "es", "genial"]
mas_de_tres_letras = [palabra for palabra in palabras if len(palabra) > 3]
# mas_de_tres_letras contendrá ["hola", "Python", "genial"]

Ejemplo 4: Convertir una lista de temperaturas de grados Celsius a Fahrenheit:

pythonCopy code
celsius = [0, 10, 20, 30, 40]
fahrenheit = [(c * 9/5) + 32 for c in celsius]
# fahrenheit contendrá [32.0, 50.0, 68.0, 86.0, 104.0]

Las List Comprehensions son una forma elegante y legible de crear listas y aplicar transformaciones a los elementos de una secuencia. Son ampliamente utilizadas en Python y te ayudan a escribir código más conciso y eficiente.

numbers2 = [i for i in range(1,11) if i % 2 == 0]
print(numbers2)

😊🍏
Comparto mi código donde utilizo List Comprehension
para ubicar a los alumnos destacados y notas destacadas del diccionario.

alumnos_notas = {
    "carlos" : 20,
    "Diego" : 17,
    "Erick" : 17,
    "Angelo" : 19,
    "Gabriela" : 18,
    "Ana" : 15
}

#De forma clasica
alumnos_destacados_1 = []

for alumno, notas in alumnos_notas.items():
    if notas > 17:
        alumnos_destacados_1.append(alumno)

print(alumnos_destacados_1) #['carlos', 'Angelo', 'Gabriela']

#Utilizando List Comprehension, alumnos destacados
alumnos_destacados_2 = [alumno for alumno, nota in alumnos_notas.items() if nota > 17]

print(alumnos_destacados_2) #['carlos', 'Angelo', 'Gabriela']

#Utilizando List Comprehension, notas destacadas
tercio_superior = [notas for notas in alumnos_notas.values() if notas > 17] 
print(tercio_superior) # [20, 19, 18]

numbers_v2 = list(range(21, 31))
print(numbers_v2)
Esta operacion me sale el mismo resultado les comparto

Resoviendo un ejercicio con List Comprehensions

Estoy practicando y busque en internet ejercicios de algoritmos para yo resolverlos con lo que estoy aprendiendo en Python. Al terminar esta clase me di cuenta que pude resolver más fácil un algoritmo que ya había hecho, así que regrese e hice una segunda versión.
El ejercicio es:

🚨 Desarrolle un algoritmo que lea los primeros 300 números enteros y determine cuántos de ellos son impares; al final deberá indicar su sumatoria.

Mi versión Inicial era:

sum = 0
for i in range(1, 301):
    if (i / 2) - float(i // 2) == 0.5:
        print(i)
        sum = sum + i

print('La sumatoria de los números inpares del 1 al', i, 'es 👉', sum)

Mi versión con List Comprehension es:

suma = 0
impares = [i for i in range(1, 301) if i % 2 != 0]
for n in impares:
    suma = suma + n

print(impares, 'La sumatoria de los números inpares del 1 al', i, 'es 👉', suma)

Conclusiones: al parecer son casi las misma lineas de código pero… en list comprehensions es más sencillo de leer, además al desplegar los resultados en pantalla, se logra de una forma más ordenada.

Pueden revisar en mi GitGub los ejercicios que voy realizando

https://github.com/josealpantoja/ejercicios_algoritmos_python/

Si quieren practicar, aqui les dejo los ejercicios de algoritmos Aquí 🤓

List comprehension - Chat Gpt

La comprensión de listas (list comprehension en inglés) es una característica poderosa de Python que te permite crear listas de manera concisa y elegante utilizando una sintaxis compacta. Es especialmente útil cuando deseas aplicar una operación o filtrar elementos en una lista existente para crear una nueva lista.

La sintaxis básica de una comprensión de listas es la siguiente:

nueva_lista = [expresion for elemento in lista_original if condicion]

Donde:

• expresion es el resultado que se agrega a la nueva lista para cada elemento que cumple con la condicion.
• elemento es cada elemento de la lista_original que se está procesando.
• condicion es una expresión opcional que filtra los elementos de la lista_original antes de aplicar la expresion.

Aquí hay algunos ejemplos para ilustrar cómo funcionan las comprensiones de listas:

1. Creación de una lista de cuadrados:

numeros = [1, 2, 3, 4, 5] 
cuadrados = [x ** 2 for x in numeros] 
# Resultado: [1, 4, 9, 16, 25]

1. Filtrado de elementos pares:

numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 
pares = [x for x in numeros if x % 2 == 0] 
# Resultado: [2, 4, 6, 8, 10]

1. Creación de una lista de pares (x, y):

x_vals = [1, 2, 3] 
y_vals = [10, 20, 30] 
pares = [(x, y) for x in x_vals for y in y_vals] 
# Resultado: [(1, 10), (1, 20), (1, 30), (2, 10), (2, 20), (2, 30), (3, 10), (3, 20), (3, 30)]

1. Uso de expresiones condicionales:

numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 
resultado = [x if x % 2 == 0 else "impar" for x in numeros] 
# Resultado: ['impar', 2, 'impar', 4, 'impar', 6, 'impar', 8, 'impar', 10]

Las comprensiones de listas son una forma compacta y legible de crear listas y realizar transformaciones en los elementos. Sin embargo, debes tener cuidado de no exagerar en la complejidad de la expresión para mantener la legibilidad. Si la comprensión se vuelve demasiado complicada, podría ser más adecuado utilizar un enfoque más tradicional con bucles y condiciones separados.

EJEMPLO DE APLICACIÓN
https://github.com/JuanCode29/fundamentosPython2/blob/main/List_Comprehension.py

Dejo mi aporte:

numbers_v1,1 = []
for element in range(1,11):
  numbers.append(element)

print(numbers_v1,1) R// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Estas cansado de hacer esto y que tu código sea enorme
# Pues mira esto...

numbers_v1,2 = [element for element in range(1, 11)]
print(numbers_v1,2) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Presentando los List Comprehension. Una sintaxis que permite escribir ciclos iterables
# EN UNA SOLA LINEA DE CÓDIGO

# Y tambien tiene un plus...

numbers_v2,1 = []
for i in range(1,11):
  if i % 2 == 0:
    numbers.append(i * 2)

print(numbers_v2,1) # Estamos multiplicando un número solo si su módulo por 2 es igual a 0
# Esta es la manera tradicional...

numbers_v2,2 = [i*2 for i in range(1, 11) if i % 2 == 0] # Y esta es nuestra versión
#                |   _________|_________   ______|______  
#                |            |            Y este es el plus...
#                |            |            la condición
#Este es        _|            |           
# el elemento  |  Este es el ciclo de donde
# a iterar     |  sacamos el elemento

numeros = []
for elementos in range(1,11):
numeros.append(elementos)
print(elementos * 2)

numeros_V2 = [elementos for elementos in range(1,11)]
print(numeros_V2)

numeros2 = []
for i in range(1,11):
if i % 2 == 0:
numeros2.append(i*2)
print(numeros2)

numeros_v = [i*2 for i in range (1,11) if i%2 ==0]
print(numeros_v)

En esta estructura, expresión es el valor que se agrega a la nueva lista y elemento representa cada elemento de la secuencia (como una lista, una cadena de texto, una tupla, etc.).

• En cada iteración, la expresión se evalúa usando el valor actual del elemento y se agrega a la nueva lista.
• Después de completar todas las iteraciones, la lista resultante se asigna a una variable.

Interesante el concepto de list comprehensions.

Acota mucho el codigo, sin embargo, cuando aplicamos el zen de python en algunas ocaciones siguiendo el criterio de que espaciado es mejor que denso, podriamos optar por el camino largo para que sea mas compresnsible para quien interpreta el codigo.

Aquí un ejemplo de la compresión de listas:

Esta función toma una lista de cosas y devuelve otra lista donde todo esta en mayúsculas.

Aqui les dejo dos ejemplos que encontré sobre este tema: se trata de listas de varios niveles, o mejor dicho, listas que contienen listas:

• Dos dimensiones

list_of_lists = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened_list = [num for row in list_of_lists for num in row ]
print(flattened_list)# [1, 2, 3, 4, 5, 6, 7, 8, 9]

• Tres dimensiones

# Una lista con listas, que a su vez tiene más listas.
# Lista de 3 niveles
list_of_lists = [ 
                    [ [1,2,3], [4,5,6], [7,8,9] ],
                    [ [2,4,6], [8,10,12], [14,16,18] ] 
                ]

new_list = [element for first_level in list_of_lists
            for second_level in first_level
            for element in second_level]

print(new_list)# [1, 2, 3, 4, 5, 6, 7, 8, 9, 2, 4, 6, 8, 10, 12, 14, 16, 18]

Ejemplo

number_v3 = [i for i in range(1, 500) if i % 3 == 0 and i % 5 == 0]

Resultado

[15, 30, 45, 60, 75, 90, 105, 120, 135, 150, 165, 180, 195, 210, 225, 240, 255, 270, 285, 300, 315, 330, 345, 360, 375, 390, 405, 420, 435, 450, 465, 480, 495]

Les recomiendo que practiquen !! no es tan dificil yo lo hice con pokemones lo pueden hacer con frutas o lo que sea solo es cogerle el tiro con ejemplos faciles

#mi forma de hacerlo con pokemones , por ejemplo necesito una lista de pokemones que comiencen por la letra A

computadora = ["Ratata", "pikachu","squirtle","charmander","bulbasor","gengar","onix",
              "jinx"]

pokemones = []

for name in computadora:
  if "a" in name.lower():
    pokemones.append(name)

print(pokemones)

#con list comprehension

pokemones2 =[name for name in computadora if "a" in name. lower()]
print(pokemones2)

Tambien se puede aplicar a strings:

fruits = ["apple", "banana", "cherry", "kiwi", "mango"]

newlist = [x for x in fruits if 'a' in x]

print(newlist)

newlist = [expression for item in iterable if condition == True]

numbers =[]
for element in range(1,11):
if element %2 == 0:
numbers.append(element*2)
print(numbers)

numbers_v2 = [element*2 for element in range(1, 11) if element%2 == 0]
print(numbers_v2)

Les comparto la comparación que hice entre la sintaxis tradicional y la sintaxis comprimida, porque yo quería asimilar muy bien la explicación de la estructura de esta última (espero que no les de un mareo 😃):

Cada vez que se utilice range(a,b) el valor b no se imprime, en cambio se imprime b-1, ejemplo: usando range(1,16) entonces el ultimo valor que se imprime será 15.

Ejercicios para practicar:
1: list comprehensión de 20 números random
2: list comprehensión de 20 números random pares

Solución
aleatorio = [random.randint(1, 100) for _ in range(21)]
print(aleatorio)

num_par_random = [
num for num in [random.randint(1, 100) for _ in range(1, 20)] if num % 2 == 0
]
print(num_par_random)

Hola! aqui les dejo mi codigo espero ayude

'''
List comprehensions
list = [element in element for iterable]
'''
jumpline = '='*25

numbers = []
for i in range(1,11):
  numbers.append(i)
print(numbers) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(jumpline)

#Todo el ciclo y la lista lo podemos hacer en una linea con list comprehension
numbers_list = [i for i in range(1,11)]
print(numbers_list) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(jumpline)

# Quiero que el elemento sea * 2
numbers = []
for i in range(1,11):
  numbers.append(i * 2)
print(numbers) # [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
print(jumpline)

#Tambien puedo hacerlo con list comprehension
numbers_list = [i * 2 for i in range(1,11)]
print(numbers_list) # [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
print(jumpline)

# Ejemplo con condicional de list comrprehension, quiero numeros pares del 1 al 100
numbers = [i for i in range(1,101) if i % 2 == 0]
print(numbers)
print(jumpline)

# Ejemplo sin list comprehension
numbers = []
for i in range(1,101):
  if i % 2 == 0:
    numbers.append(i)
print(numbers)
print(jumpline)

Otro apunte que posiblemente sea fácil de entender sobre leer la línea con If:

Acá básicamente le estoy pidiendo una lista de 100 items. Cada item, empezando con el uno, será multiplicado por dos. Luego se multiplicará el dos y este se ubicará en la posición 1 de mi lista (el 0 lo ocupó el 1*2). Luego multiplicará el tres y este será la nueva posición dos. Pero esto sucederá siempre y cuando el residuo de la división de ese número entre dos, es cero, es decir, que sea número par. En conclusión me incluirá solo los números pares que surjan de la multiplicación de su posición multiplicada por dos.

Una ventaja clara de List Comprehension: Lograr soluciones en el menor número de líneas de código posibles con una correcta legibilidad 💚

Excelente explicación,. me gusta

# Podemos usar listas por comprensión para mapeos y filtros agradables
#add_10 es una funcion que les suma 10 a cada numero
[add_10(i) for i in [1, 2, 3]]  #=> [11, 12, 13]
[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7]
# también hay diccionarios
{k:k**2 for k in range(3)} #=> {0: 0, 1: 1, 2: 4}
# y conjuntos por comprensión
{c for c in "la cadena"} #=> {'d', 'l', 'a', 'n', ' ', 'c', 'e'}

Como se leen las list comprehension

Sintaxis de una lista por compresión

#Listas por comprension 

'''
Vamos a definir una lista, pero
de manera mas sencilla

Sintaxis:

[element for element in iterable]
Elemento    Ciclo donde se extraen elementos
            de cualquier iterable
'''

numeros=[]
for element in range(1,11): 
    numeros.append(element)
print(numeros)

numers_v2=[element for element in range(1,11)]
print(numers_v2)

# [element for element in iterafle if contiditon]
numeros_v3=[]
for i in range (1,11):
    if i%2==0:
        numeros_v3.append(i*2)
print(numeros_v3)

numeros_v4=[i*2 for i in range(1,11) if i%2==0]
print(numeros_v4)

Muy clara la explicación de comprehensions

Me quedó muy claro, que buena explicación

Para quienes nos acostumbramos a las explicaciones con Facundo Garcia, les dejo el enlace, en lo personal me parecio mas entendible con él
https://platzi.com/clases/2255-python-intermedio/36463-list-comprehensions/

q cvr

Saludos, el ejercicio dea clase, los deberes los paso ya mismo.

numbers = []
for i in range(1, 9):
if i % 2 == 0:
numbers.append(i / 2)

print(numbers)

num2 = [i * 2 for i in range (1, 21) if i % 2 == 0]
print(num2)

Aquí hay algunos ejercicios para reforzar este concepto => https://www.w3schools.com/python/python_lists_comprehension.asp

[expression for item in iterable]

Donde:

• expression es la operación que se realiza con cada elemento de la lista.

• item es una variable que toma cada valor del iterable (por ejemplo, una lista) durante cada iteración.

• iterable es el objeto que se itera (por ejemplo, una lista).

Ejemplo

numeros = [1, 2, 3, 4, 5]
cuadrados = [x**2 for x in numbers]
print(cuadrados)  # Imprime [1, 4, 9, 16, 25]

Potente y código muy compacto, aunque al principio puede perderse legibilidad en el código. Hasta que nos acostumbramos a esta sintaxis. 🚀💪

Aqui les comparto un ejemplo de List comprehension.

Un ejemplo de practica

mayores = [i for i in range(1,100) if i - 50 > 10]
print(mayores)

Lista de comprensión

• La comprensión de listas ofrece una sintaxis más corta cuando desea crear una nueva lista basada en los valores de una lista existente.

Ejemplo:

• Basado en una lista de frutas, desea una nueva lista que contenga solo las frutas con la letra “a” en el nombre.

• Sin comprensión de lista, tendrá que escribir una fordeclaración con una prueba condicional dentro:

Ejemplo

``
fruits = ["apple", "banana", "cherry", "kiwi", "mango"]
newlist = []

for x in fruits:
  if "a" in x:
    newlist.append(x)

print(newli
```st)
```

Operadoes ternarios en list comprehension

Hola, quiero dejar mi aporte diciendo que también puedes usar operadores ternarios en un list comprehension.

• Por qué usarlo?
  Es una forma de simplificar al igual que un list comprehension, pero en este caso usas las sentencias if y else.

Sintaxis:

[element if conditional else element for element in iterable]

Ejemplo:

• Supongamos que quieres crear una lista con los números del 1 al 10 y escribir si es par o impar.

par_impar = ['par' if i % 2 == 0 else 'impar' for i in range(1, 11)]

La salida sera

['impar', 'par', 'impar', 'par', 'impar', 'par', 'impar', 'par', 'impar', 'par']

Otro ejemplo:

lista = [5, 7, 11, 12, 15, 20, 24]
lista_nueva = [ elemento * 2 if elemento < 15 else elemento / 2 for elemento in lista ]

# Output

[10, 14, 22, 24, 7.5, 10.0, 12.0]

'''
numbers = []
for element in range(1, 11):
  numbers.append(element*2)

print(numbers)

numbers_v2 = [element *2 for element in range(1,11)]
print(numbers_v2)
'''
numbers = []
for i in range(1, 11):
  if i % 2 == 0:
    numbers.append(i*2)

print(numbers)

numbers_v2 = [i * 2 for i in range(1, 11) if i % 2 == 0]
print(numbers_v2)

numbers = []

def definir_multiplicando():
    a = int(input("Escriba un numero donde quiera que inicie"))
    b = int(input("Escriba un numero donde quiera que termine"))
    c = int(input("escriba un numero con el cual quiere multiplicar"))
    numbers = [element for element in range(a,b)]
    numbers2 = [element * c for element in range(a, b)]
    print("los numeros seleccionados fueron ("+str(a)+str(b)+") y el resultado es:")
    print(numbers)
    print("El numero para multiplicar fue : "+str(c)+" y su resultado es :")
    print(numbers2)

def condicion():
    d = int(input("Escriba 1 si quiere ver impares o 0 para pares "))
    numbers = [element for element in range(1, 15) if element%2==d]
    print(numbers)

if __name__ == "__main__":
    repetir=0
    while repetir==0:
        menu ="""
        1.definir rango
        2.poniendo condicion"""
        print(menu)
        opc= int(input("seleccione una opcion"))
        if opc==1:
            definir_multiplicando();
        if opc==2:
            condicion();
        else:
            print("opcion no valida")
            repetir=int(input("oprima 0 para volver al menu"))

Hay una gran profundidad en el tema de list comprehensions, de hecho se pueden hacer nested if o más de un ciclo for.
aquí un ejemplo de un nested if donde primero se valida la condicion i > 4 y luego que sea par.

numbers = [1,2,3,4,5,6,7,8,9,10]

iterate_numbers = [i for i in numbers if i > 4 if i % 2 == 0]

print(iterate_numbers)
 
#output [6, 8, 10]

Aquí pueden revisar un artículo detallado en freecodecamp

""" list comprehension """

# clasic
numbers = []
for i in range(1,10):
  numbers.append(i)
print(numbers)

# list comprenhension
numbers_v2 = [i for i in range(1, 10)]
print(numbers_v2)

# examples
nombres = ["Dolores", "Elisabeth", "Giovanna", "Kukri", "Kyo", "Joseph", "Testament", "Mui Mui", "David", "Jake", "Pablo", "Lucy", "Juri", "Cammy", "Jun", "Asuka", "Gon", "Meruem", "Netero", "Yami", "Asta", "Neji", "Light", "Luong", "Mary", "Black", "Tsubaki", "Maka", "Gai", "Shingo"]

names_with_a = [i for i in nombres if "a" in i]
print(names_with_a)

names_with_e = [i for i in nombres if "e" in i]
print(names_with_e)

names_with_i = [i for i in nombres if "i" in i]
print(names_with_i)

names_with_o = [i for i in nombres if "o" in i]
print(names_with_o)

names_with_u = [i for i in nombres if "u" in i]
print(names_with_u)

#list comprehension

#manera larga
numbers = []
for i in range(1,11):
  numbers.append(i)

print(numbers)

#version corta y facil de leer
numbers_v2 = [i for i in range(1,11)]
print (numbers_v2)


#version con condicional
numbers_v3 = [i*2 for i in range(1,11) if i % 2 ==0]
print (numbers_v3)

que buena clase!

###List
numbers = []
for i in range(1, 11):
if i % 2 == 0:
numbers.append(i * 2)

print(numbers)

###List comprehension
c=[element for element in range(1,11)]
print©
###Paso 1
###primero debe ir lo que esta adentro de nuestro append, luego el for “Nombre o letra para que sea nuestro elemento”
##Paso 2
##gregarle el in range que sera el rango o cantidad de numeros que queremos ver
##Paso 3
###Todo esto debe estar dentro de nuestro parentesis rectangulares

##Ejemplo

Esto es un list

numbers = []
for element in range(1, 11):
if element * 2 >= 4:
numbers.append(element * 2)

print(numbers)

##Esto es un list comprehension con condicional
numeros=[element*2 for element in range(1,11) if element *2 >=4]
print(numeros)

###Paso 1
###primero debe ir lo que esta adentro de nuestro append, luego el for “Nombre o letra para que sea nuestro elemento”
##Paso 2
##gregarle el in range que sera el rango o cantidad de numeros que queremos ver
##Paso 3
###Agregar la condicional if "nombre o letra de nuestro elemento "+ "cualquier operador +,-,*,/ o >=,<= " y cualquier numero

Todo esto debe estar dentro de nuestro parentesis rectangulares

Ejemplo con colores.

colores = ["amarillo", "azul", "rojo", "verde", "purpura", "naranja", "cafe"]
print(colores)

colores_u = []
for x in colores:
  if "u" in x:
    colores_u.append(x)

print(colores_u)

colores_u = [x for x in colores if "u" in x]
print(colores_u)

Resultado:
~/Python-202$ python lists_comprehensions.py
[‘amarillo’, ‘azul’, ‘rojo’, ‘verde’, ‘purpura’, ‘naranja’, ‘cafe’]
[‘azul’, ‘purpura’]
[‘azul’, ‘purpura’]

Recomiendo leer el libro Robust Python (que aun no termino) que permite escribir código mas robusto y con buenas practicas, una de ellas es utilizar un ciclo for cuando necesitamos recorrer un iterable sin modificar su valor, mientras que recomienda los comprenhensions cuando vamos a realizar transformaciones sobre el iterable. Algo interesante sin embargo es que son mas rapidos para recorrer ese iterable que un ciclo for convencional.

Ejercicio

Obtener la lista de vocales presentes en una frase:

sentence_str = "This is a new Python course"
vowels_list = [i for i in sentence_str if i in 'aeiou']
print(vowels_list)

List Comprehension

#------------- List Comprehension-------------------

numbers = []

# iteracion normal sobre una lista
for element in range(1,11):
  numbers.append(element)

print(numbers)
--> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# reducimos las lineas de codigo utilizadas con list comprehension
numbers_2 = [element for element in range(1, 11)]
print(numbers_2)
--> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# multiplicar por 2 los elementos que forman la lista
numbers_2 = [element * 2 for element in range(1,11)]
print(numbers_2)
--> [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

# Ejemplo con condicional en una Iteracion normal
numbers_par = []

for i in range(1,11):
  if i % 2 == 0:
    numbers_par.append(i*2)

print(numbers_par)
--> [4, 8, 12, 16, 20]

# Ejemplo con condicional en una List comprehension
numbers_par = [i * 2 for i in range(1,11) if i % 2 == 0]
print(numbers_par)
--> [4, 8, 12, 16, 20]

Ejemplo de List Comprehension

Lectura del Ejemplo: Multiplicamos por 2 un elemento que obtenemos de un iterable, que en este caso es un rango que va de 1 a 101, y se agrega a la lista solo si su reciduo de la division por 2 es igual a 0, es decir, que sea un numero par

I miss you Facundo!

Estan muy geniales los List Comprenhensions!

'''
num = []
for element in range(1,11):
  num.append(element * 2)

print(num)

num_2 = [element *2 for element in range(1,11)]
print(num_2)
'''
num = []
for i in range(1,11):
  if i % 2 == 0:
    num.append(i * 2)

print(num)

num_2 = [i*2 for i in range(1,11) if i % 2 == 0]
print(num_2)

List comprehension

Mis notas de la clase:

numbers = []
for element in range(1,11):
  numbers.append(element)
print(numbers)

# List comprehension
numbers_v2 = [element for element in range(1,11)]
print(numbers_v2)

numbers_v3 = [element * 2 for element in range(1,11)]
print(numbers_v3) #Lista de los numeros multiplicado por 2


### Solo agregar los pares y multiplicar por dos

# Version for
numbers = []
for i in range(1,11):
  if i % 2 == 0:
    numbers.append(i * 2)
    
print(numbers)

# Version list comprehension
numbers_v2 = [i *2 for i in range(1,11) if i % 2 == 0]
print(numbers_v2)

Comparto mi aporte con los meses del año:

meses = ["enero", "febrero", "marzo", "abril", "mayo", "junio", "julio", "agosto", "septiembre", "octubre", "noviembre", "diciembre"]
print(meses)

mes_o = [element for element in meses if "o" in element]
print(mes_o)

Obtenemos:

['enero', 'febrero', 'marzo', 'abril', 'mayo', 'junio', 'julio', 'agosto', 'septiembre', 'octubre', 'noviembre', 'diciembre']

['enero', 'febrero', 'marzo', 'abril', 'mayo', 'junio', 'julio', 'agosto', 'septiembre', 'octubre', 'noviembre', 'diciembre']
['enero', 'febrero', 'marzo', 'mayo', 'junio', 'julio', 'agosto', 'octubre', 'noviembre']