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

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

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

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)

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 😃

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

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]

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

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)

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

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.

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.

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

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 😢

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=" ")

Excelente explicación 👏👏👏

nueva_lista = [expresion for elemento in iterable if condicion]

expresion: Es la expresión que se evalúa y se agrega a la nueva lista.
elemento: Variable que toma cada elemento del iterable.
iterable: La secuencia de elementos sobre la cual iteramos (por ejemplo, una lista, tupla, cadena, etc.).
condicion: Una condición opcional que filtra los elementos antes de agregarlos a la nueva lista.

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

numbers = []
numbers = [i for i in range(1, 11)]
print(numbers)

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

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

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

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

Me puse a hacer ejercicios de practica sobre list comprehension, y hay algo muy interesante respecto al metodo range(), es su sintaxis, ya que podemos definir su inicio, final y en las partes que uno quiere que se vaya sumando, es decir, podemos crear un rango que vaya del 2 al 10, haciendo pasos de 2:

lista = [i for i in range(2, 10, 2)]
print(lista)

Beneficios de utilizar listas vacias como en el ejemplo numbers = []:

1. Inicialización de estructuras de datos: Puedes usar listas vacías como contenedores para almacenar elementos más tarde. Por ejemplo, al comenzar un programa, puedes declarar una lista vacía y luego agregar elementos dinámicamente a medida que se necesiten.

   mi_lista = []
   # Realizar operaciones y agregar elementos según sea necesario
   mi_lista.append(10)
   mi_lista.append("Hola")
   

2. Iteración segura: Cuando trabajas con bucles, puedes usar listas vacías para acumular resultados. Esto es útil cuando no conoces de antemano la cantidad de elementos que se agregarán.

   resultados = []
   for elemento in iterable:
       resultado = procesar(elemento)
       resultados.append(resultado)
   

3. Manejo de excepciones: Puedes utilizar listas vacías para evitar errores cuando esperas recibir una lista pero no estás seguro de si estará vacía o no. Luego, puedes verificar la longitud de la lista antes de realizar operaciones específicas.

   mi_lista = obtener_lista_posiblemente_vacia()
   if len(mi_lista) > 0:
       # Realizar operaciones solo si la lista no está vacía
       procesar_lista(mi_lista)
   

4. Interpolación dinámica de datos: Puedes construir dinámicamente listas basadas en condiciones o datos variables.

   datos = obtener_datos()
   if condicion:
       mi_lista = datos
   else:
       mi_lista = []
   

Estos son solo algunos ejemplos, pero en general, el uso de listas vacías proporciona flexibilidad y modularidad al escribir código en Python. Permiten adaptarse dinámicamente a diferentes situaciones y construir estructuras de datos según sea necesario.

List Comprehension en Python: Una Explicación Detallada

La List Comprehension en Python es una forma concisa y expresiva de crear listas. Es una construcción sintáctica que te permite crear listas de manera más compacta, legible y eficiente que usando bucles tradicionales.

Sintaxis Básica:

La estructura general de la List Comprehension es:

[nueva_expresion for elemento in iterable if condicion]

• nueva_expresion: La expresión que define cómo se va a transformar cada elemento del iterable.
• elemento: La variable que toma el valor de cada elemento en el iterable.
• iterable: La secuencia de elementos (por ejemplo, una lista, tupla o rango) a través de la cual iteramos.
• condicion (opcional): Una condición que filtra los elementos del iterable, solo se incluyen en la nueva lista si la condición es True.

Ejemplos para ilustrar:

# Usando bucle tradicional
cuadrados = []
for i in range(1, 6):
    cuadrados.append(i**2)

# Usando List Comprehension
cuadrados_comp = [i**2 for i in range(1, 6)]

print(cuadrados)      # Output: [1, 4, 9, 16, 25]
print(cuadrados_comp)  # Output: [1, 4, 9, 16, 25]

# Usando bucle tradicional
pares = []
for i in range(1, 11):
    if i % 2 == 0:
        pares.append(i)

# Usando List Comprehension
pares_comp = [i for i in range(1, 11) if i % 2 == 0]

print(pares)      # Output: [2, 4, 6, 8, 10]
print(pares_comp)  # Output: [2, 4, 6, 8, 10]

Características Clave:

1. Concisión y Legibilidad:

   • La List Comprehension puede hacer que el código sea más breve y fácil de entender, especialmente para operaciones simples.

2. Eficiencia:

   • En general, la List Comprehension puede ser más eficiente en términos de velocidad de ejecución que los bucles tradicionales.

3. Versatilidad:

   • Puedes utilizar List Comprehension no solo para crear listas, sino también para conjuntos y diccionarios.

4. Anidamiento:

   • Es posible anidar List Comprehensions, permitiéndote realizar operaciones más complejas.

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened = [num for row in matrix for num in row]
print(flattened)  # Output: [1, 2, 3, 4, 5, 6, 7, 8, 9]

En resumen, la List Comprehension es una característica poderosa y expresiva de Python que puede mejorar la claridad y eficiencia de tu código al crear y transformar listas de manera concisa.

Me gusto este ejecicio con respecto al aprendizaje de usar comprehensions. No sabia que su trabajo simplificado hace esto mas sencillo.

List comprehensions

💡 Nota:

• El if es completamente opcional
• Se lee “Para cada elemento en el iterable, guardo el elemento en la lista, si se cumple la condición”

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

✅

Encontré un pequeño reto en esta newsletter []https://www.linkedin.com/pulse/abre-tu-mente-y-tus-corchetes-descubre-la-magia-de-en-jesus-daniel/?trackingId=ny0LsYMAT8S9oKiFFfNYTw%3D%3D

1. Crea una lista de los números impares del 1 al 20 utilizando “List Comprehension”.
2. Dada una lista de nombres, crea una nueva lista con los nombres que comiencen por la letra “A”.
3. Crea una lista de los primeros 10 números de la sucesión de Fibonacci utilizando “List Comprehension”.

# 1 Respuesta
odd = [i for i in range(1, 21) if not i % 2 == 0]
print(odd)
# 2 Respuesta
names = ["Angela", "Martha", "Antonia"]
nameA = [i for i in names if i.startswith("A")]
print(nameA)
# 3 Respuesta
fibo = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
print(len(fibo))
first10 = [x for x in fibo[:10]]
print(first10)

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)