Python comprehensions

No recuerdo si ya se había mencionado la función zip() en el curso, pero por si no se ha hecho, la función zip lo que hace es regresar un iterador de tuplas.

>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> zipped = zip(x, y)
>>> list(zipped)
[(1, 4), (2, 5), (3, 6)]

Les dejo un par de ejercicios para practicar las comprehensions de Python 👇🏼
–> https://www.practicepython.org/exercise/2014/03/19/07-list-comprehensions.html
–> https://www.practicepython.org/exercise/2014/04/10/10-list-overlap-comprehensions.html

Esto me ayudo a comprender mejor como se formula la sentencia:

Fuente:
https://python-3-patterns-idioms-test.readthedocs.io/en/latest/Comprehensions.html

Querida comunidad, ¿alguno recomienda un libro para aprender las mejores reglas de sintaxis y legibilidad para programadores en Python?

Las ** list comprehension** : son maneras de escribir listas, diccionarios y conjuntos de manera compacta y legible,
Listas—> [element for element in element_list if element_meets_condition]
Diccionarios–> {key: element for element in element_list if element_meets_condition}
Conjuntos–> {element for element in element_list if elements_meets_condition}

EJEMPLOS:

- Generar lista de números de 1 al 100 y obtener los números pares(divisibles por dos):
lista_de_numeros= list(range(100))
**pares =[numero for numero in lista_de_numeros if numero % 2 == 0 ] —> list comprehension **

-Generar diccionario a partir de dos listas:
student_uid=[1,2,3]
students=[‘Natalia’,‘Luis’,‘Juan’]
students_and_uid={uid: student for uid, student in zip(student_uid,students)} --> {1: ‘Natalia’, 2: ‘Luis’, 3: ‘Juan’}

-Crear un conjunto (set) de números que no estén repetidos a partir de una lista con números repetidos:
random_numbers= [3, 3, 3, 3, 2, 2, 2, 2, 1, 2]
non_repeated={number for number in random_numbers} —> {1, 2, 3}

También se puede construir el diccionario así:

lst1 = [...]
lst2=[...]
myDict = dict(zip(lst1, lst2)) 

código de la clase: Python comprehensions

<code>

#iterating con comprehensions
lista_de_numeros= list(range(100))
pares = [numero for numero in lista_de_numeros if numero & 2==0]
#output# [0, 1, 2, 3, .........., 97 ,98 ,99]

#create dict con comprehensions
student_uid = [1,2,3]
students = ['juan','jose','larse']
student_uid={uid: student for uid, student in zip (student_uid,students)}
#output# {1:juan, 2:jose, 3: larse}

#transform list to set con comprehensions
import random
random_numbers = []
for i in range(10):
    random_numbers.append(random.randint(1,3))
random_numbers 
#output#[1,2,3,1,2,2,2,3,2,2]
non_repeated = {number for number in random_numbers}
#outputt#{1,2,3}

</code>

No sabia que este estructura tenia ese nombre y la hbia utilizado para resolver el reto del update client de platzi ventas

 client_name_index= next((index for (index, client) in enumerate(clients) if client['name']==client_name),-1)

En el ejemplo de los pares esta es una de las formas de definir el conjunto de números pares en Teoría de Conjuntos, en este caso en el rango [ 0, 100)
NOTA: [ 0, 100) esta escrito así intencionalmente.

Definición:

pares = { x | x/2 es entero} que es equivalente a

pares = { x | x mod(2) =0} = { x | x % 2 =0}

si consideramos el rango [0, 100)

pares = { x | (x % 2 = 0) & ( x en [0, 99] ) }

NOTA: x cumple con las dos condiciones:

a) x % 2 = 0

b) x está en el rango (0, 100)

pares = { x |

https://www.geeksforgeeks.org/comprehensions-in-python/
Les comparto una página que encontré para que puedan dar una revisión y hay un par de ejemplo de cada uno de los tres tipos de Comprehensions que se han brindado en la clase

debiria explicar que es el zip, ahora se que regresa unas tuplas pero si deberia explicarlo a groso modo

Por si a alguien le sirve a mi ayudo mucho como lo explican aca: https://www.youtube.com/watch?v=Z-8Khdd2BUQ
Espero que les sea de ayuda.

Información de zip:
https://www.w3schools.com/python/ref_func_zip.asp

Buenas noches, la función zip permite emparejar el primer elemento de cada iterador luego a los segundos elementos y así sucesivamente.

jajja no sabia del keyword id que no se podia usar y yo matandome con el ejercisio anterior jajja bueno cosas que pasan jeje

Ya que estabamos con la clase de las comprehensions, en esta parte:

import random
random_numbers = []
for i in range(10):
    random_numbers.append(random.randint(1,3))  

se podria poner:

import random
random_numbers = []
random_numbers.append(random.randint(1,3) for x in range(10))

En el Curso de Python Intermedio (dictado por Facundo), él explica con mejor detalle como funcionan las list comprehensions y dicts comprehensions

¡Qué poder de las compehensions! 😯. Les dejo esta web donde con un ejemplo comparan list comprehension vs For loop

"Usando list comprehension"

h_letters = []

for letter in 'human':
    h_letters.append(letter)

print(h_letters)
>> ['h', 'u', 'm', 'a', 'n']

"Usando for loop"

h_letters = [ letter for letter in 'human' ]
print( h_letters)
>> ['h', 'u', 'm', 'a', 'n']

Hasta el momento he entendido todo y sin problemas pero hubiera sido bueno que explicaras punto por punto como se estructuran los “comprehensions”, igual que paso con el “zip” que solo lo fue usando de la nada sin ninguna explicación.
¿Podrías ampliar este conocimiento con otro video?

Los comprehensions tambien se pueden aplicar sobre Matrices como en este ejemplo

Para hacer una lista de números random utilizando List Comprehension utilice esta línea:

 random_number = [random.randint(1,11) for i in range(10)]

Muy interesante las List comprehensions

numeros_pares = [
    numero  # Nuevo valor
    for numero in range(10)  # Recorrer secuencia
    if numero % 2 == 0  # Condicional
]```

Una guia un poco mas explicativa https://www.youtube.com/watch?v=Z-8Khdd2BUQ

Muy interesante la estructura List comprehensions

numeros_pares = [
    numero  # Nuevo valor
    for numero in range(10)  # Recorrer secuencia
    if numero % 2 == 0  # Condicional
]

para generar la lista random tambien se puede usar comprehensions:

a = [random.randint(1,3) for i in range(10)]

Comparto con Uds mi código, en él implemento el ejemplo que hace el profesor con el método de list comprehensions y su alternativa usando una función y un bucle for; luego comparo los tiempos de ejecución de cada método mediante el módulo timeit; espero les sea de utilidad.

“”"
Created on Tue Apr 23 08:14:07 2019

@author: Guille
"""
import timeit

lista_de_numeros = list(range(100)) #Definimos una lista de 100 elementos

print("\n Lista original:\n", lista_de_numeros)

###Ejemplo de list comprehesions

#**Vamos a crear una nueva lista a partir de la anterior, que contenga sólo
#**los números pares.

pares = [numero for numero in lista_de_numeros if numero % 2 == 0] #Comprehension

print("\n Usando list comprehensions:\n ",pares)

###Hacemos lo mismo pero usando una función con un bucle for:

def with_for(lista):

pares_with_for = []

for numero in lista:
    if(numero % 2 == 0):
        pares_with_for.append(numero)
        
return pares_with_for

#**Mostramos la lista de pares obtenida con esa función:
print("\n Usando bucle for:\n ", with_for(lista_de_numeros))
print(’\n’)

###Vamos a hacer unas pruebas de la velocidad de ejecución de cada método

print(’*‘50);
print(‘Comparando tiempos de ejecución’)
print(’’*50 + ‘\n’);

print(’ Con list comprehensions: ‘,timeit.timeit(’[numero for numero in lista_de_numeros if numero % 2 == 0]’
, globals=globals(), number=10000))

print(’ Con for: ', timeit.timeit(‘with_for(lista_de_numeros)’, globals=globals(),
number=10000))

Para profundizar en el tema el siguiente link está muy interesante: https://www.datacamp.com/community/tutorials/python-list-comprehension

Este video me parece un buen complemento a esta clase:
https://www.youtube.com/watch?v=3dt4OGnU5sM
Me ayudo a comprenderlo mejor.

Otra forma de generar una lista de 10 numeros aleatorios es:

random_numbers = [random.randint(1,3) for num in range(0,10)]

Y podemos quitar los repetidos también con:

non_repeated = set(random_numbers)

Éxitos

Según lo que pude profundizar en una de las prácticas que pasó el profe Facundo García más abajo, como regla general nos podemos quedar con la siguiente estructura:

[EXPRESSION FOR_LOOPS CONDITIONALS]

Ya que estas comprehensions pueden complejizarse bastante si se le agregan más de un bucle iterador o también condicionales.

Por ejemplo:

	list1 = [1, 2, 3]
	list2 = [5, 10, 15]
	customlist = [num*num2 for num in list1 for num2 in list2 if num*num2%2 != 0]
	print(customlist) #[5, 15, 15, 45]

⚡️ Esta comprehension nos devuelve una nueva lista con los valores impares de multiplicar entre sí todos los números de ambas listas para lo cuál se hace uso de un for para recorrer list1 y otro para recorrer list2.

Me sorprende lo eficiente que es set comprehension vs set for loops. Se me demora 8.3s de más muchisismo.

No sé si sea el profe, o porque ya he visto varias veces el tema con otros profes y por mi cuenta leyendo, que lo comprendí genial!

import random
random_numbers = []

[random_numbers.append(random.randint(1,5)) for _ in range(10)]
print(random_numbers)


lista = {random.randint(1,5) for _ in range(10)}
print(lista)

Cada clase suelta un detalle que no se me habia ocurrido. Genial.

Hola, aqui les comparto un articulo publicado en StackOverflow, en el que explican bastante bien, como se usa la funcion zip ( )
[] (https://stackoverflow.com/questions/36375126/zip-together-each-element-of-one-list)

Ya que estamos hablando de comprehensions, la lista del 9:30 se podría hacer de la siguiente manera:

>>> random_numbers = [random.randint(1, 3) for _ in range(10)]
>>> random_numbers
[1, 3, 2, 3, 2, 3, 2, 3, 3, 2]

Las Comprehensions son constructos que nos permiten generar una secuencia a partir de otra secuencia.

existiendo 3 tipos
List comprehensions
Dictionary comprehensions
Sets comprehensions

Python comprehensions

Son como un bucle for en 1 línea de código.

• List comprehension -> [element for element in element_list if element_meets_condition]
• Dictionary comprehension -> {key: element for element in element_list if element_meets_condition}
• Set comprehensino -> {element for element in element_list if element_meets_condition}

student_uid = [1, 2, 3]
students = ['Juan', 'José', 'Larsen']
students_with_uid = {uid: student for uid, student in zip(student_uid, students)}
print(students_with_uid) # -> {1: 'Juan', 2: 'José', 3: 'Larsen'}

import random
random_numbers = []
for i in range(10):
 random_numbers.append(random.randint(1,3))

print(random_numbers) # -> [1, 3, 2, 2, 3, 2, 2, 2, 1, 2]

#Eliminando números repetidos con los sets
non_repeated = {number for number in random_numbers}
print(non_repeated) # -> {1, 2, 3}

En esta clase les enseñan list comprehensions

Y en esta clase les enseñan dictionary comprehensions

Si quieres tener más de un elemento iterable en un ciclo, nos sirve la función global: zip()

Se podría crear un set con 100 elementos de una lista de 1000 de forma aleatoria con set comprehensions o debería utilizar un bucle for

Hola comunidad, arme un pequeño programa para entender mejor las comprehensions, se los comparto para que fijándose en el código y la ejecución tengan una idea más práctica de las comprehensions:

def count_letters_in_a_word():
  word = input('\nPlease insert the word from what you want to count its letters: ')
  countedLetters = _count_letters(word)
  for key, value in countedLetters.items():
    print(key, ': ', value)


def capitalize_four_words():
  to_capitalize = []
  print('\nPlease insert four words to capitalize them')
  word = input('word 1: ')
  to_capitalize.append(word)
  word = input('word 2: ')
  to_capitalize.append(word)
  word = input('word 3: ')
  to_capitalize.append(word)
  word = input('word 4: ')
  to_capitalize.append(word)

  print('\nThe capitalized words are: ')
  print(_capitalize_words(to_capitalize))


def delete_duplicate_words():
  print('\nInsert a sentece to delete the duplicated words:')
  sentence = input('Sentence: ')
  print('\n The unique words are: ')
  print(_delete_duplicate_words(sentence))


def delete_duplicate_words_and_longer_than_three():
  print('\nInsert a sentece to delete the duplicated words:')
  sentence = input('Sentence: ')
  print('\n The unique words with a maximun long of 3 characters are: ')
  print(_delete_duplicate_words_and_longer_than_three_char(sentence))


def calculate_final_price():
  prices = []
  print('\nPlease insert four prices to calculate the finel prices')
  price = int(input('price 1: '))
  prices.append(price)
  price = int(input('price 2: '))
  prices.append(price)
  price = int(input('price 3: '))
  prices.append(price)
  price = int(input('price 4: '))
  prices.append(price)

  tax_rate = int(input('Insert the taxes value: '))

  print('\nThe prices with taxes are: ')
  print(_final_prices(prices, tax_rate))


def calculate_power():
  print('Get the power of an integer number from zero to you want')
  base = int(input('Write the number you want as base: '))
  power = int(input('Write until which exponent you want to reach: '))
  print('\n',_calculate_power_with_lambda_function(base, power))


# Retunrs a list of powers of a number
def _calculate_power_with_lambda_function(base, power):
  bases = [lambda x, i=i: x**i for i in range(power+1)] # Implementation of list comprehension using a lambda function
  return ([b(base) for b in bases]) # Gerating the list applying the lambda function


# Returns a dictionary of letter: quantity from a string with a word
def _count_letters(word):
  return {letter: word.count(letter) for letter in word}


# Returns a list of capitalized words from a list of words
def _capitalize_words(words):
  return [word.title() for word in words]


'''
  Make the sentence entirely lowercase and remove the comma and the period.
  Separate it into a list of words, and from there return a set of all the unique words
'''
def _delete_duplicate_words(sentence):
  words = sentence.lower().replace('.', '').replace(',', '').split()
  return {word for word in words}


def _delete_duplicate_words_and_longer_than_three_char(sentence):
  words = sentence.lower().replace('.', '').replace(',', '').split()
  return {word for word in words if len(word) <= 3}


# Returns a list with the calculated prices
def _final_prices(prices, TAX_RATE):
  return [_get_price_with_tax(price, TAX_RATE) for price in prices]


def _get_price_with_tax(price, TAX_RATE):
  return round(price * ( 1 + (TAX_RATE/100) ), 2)


def _print_welcome():
  print('\n','*' * 30)
  print('   -- LEARN COMPREHENSIONS --')
  print('','*' * 30)


def _print_menu():
  print('\n')
  print('*'*99)
  print('What would you like to learn?')
  print('1. Dictionary comprehension                 |  Count the letters in a word')
  print('2. List comprehension                       |  Capitalize four words')
  print('3. Set comprehension                        |  Delete the repeat it words in a sentence')
  print('4. Set comprehension with condition         |  Delete the repeat it and longer than three words in a sentence')
  print('5. List comprehension with function         |  Calculate four final prices adding the taxes')
  print('6. List comprehension with lambda function  |  Calculate the power of a number until you want')
  print('*'*99)


if __name__ == "__main__":

  _print_welcome()
  option = ''
  while option != 'q':

    _print_menu()
    option = input('\nInsert an option (q for exit): ').lower()

    if option == '1':
      count_letters_in_a_word()
    elif option == '2':
      capitalize_four_words()
    elif option == '3':
      delete_duplicate_words()
    elif option == '4':
      delete_duplicate_words_and_longer_than_three()
    elif option == '5':
      calculate_final_price()
    elif option == '6':
      calculate_power()
    elif option == 'q':
      break
    else:
      print('Invalid option')

Para poder guardar todos los correos de los clientes que pertenezcan a la empresa Apple

emails = [client['email'] for client in clients if client['empresa']=='Apple']

Para aplicar un else en una comprehension la estructura cambia, poniendo el (if , else) al principio de la comprehension.

• De un lista de números extraemos los valores pares y si no lo son, sustituimos los impares por cero.

numbers = list(range(20))
result = [number if number % 2 == 0 else 0 for number in numbers]
print(result)
[0, 0, 2, 0, 4, 0, 6, 0, 8, 0, 10, 0, 12, 0, 14, 0, 16, 0, 18, 0]

Hice un test de performance usando la funcion que recomendo al principio del video, como las listas son muy pequeñas no se ve gran diferencia, pero si es mejor usar comprehensions

import timeit

# measure a function cost (in seconds)
# differences between for loop and dict comprehensions

def merge_two_list_with_for():
    student_uid = [1, 2, 3]
    students = ['Jon', 'Katja', 'Larsen']

    students_with_uid = dict()

    for uid, student in zip(student_uid, students):
        students_with_uid[uid] = student

    return students_with_uid

def merge_two_list_with_comprehensions():
    student_uid = [1, 2, 3]
    students = ['Jon', 'Katja', 'Larsen']

    students_with_uid = {uid: student for uid, student in zip(student_uid, students)}

    return students_with_uid

print('\nFunction cost: merge_two_list_with_for')
print(timeit.timeit(merge_two_list_with_for))

print('\nFunction cost: merge_two_list_with_comprehensions')
print(timeit.timeit(merge_two_list_with_comprehensions))

studen_uid = [1, 2, 3]
students = ['Juan', 'Francisco', 'Isabel']

students_with_uid = {uid: student for uid, student in zip(studen_uid, students)}

>>> students_with_uid
{1: 'Juan', 2: 'Francisco', 3: 'Isabel'}

Según lo que veo este concepto es más potente que los propios loops

Genial!! Me encantó esta clase!

También se pueden hacer “tuple” de la siguiente forma:

<code> tuple(element for element in element_list if element_meets_condition)

imagen detallada de lo necesario para las comprenhensions.

Fabuloso!!

O mas facil aun:
zipp = zip(student_uid, students)
listado = list(zipp)
students_with_uid = dict(listado)
Output: {1: 'juan', 2: 'jose', 3: 'larsen'}

Comprehensions: Son estructuras que permite generar una secuencia a partir de otra secuencia.

Ejemplo1: Haremos una lista de los 100 números del 0 al 99. Luego, generaremos un List comprehension donde sólo queremos los números pares:

>>> lista_de_numeros = list(range(100))
>>> lista_de_numeros
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
>>> lista_de_numeros_pares = [numero for numero in lista_de_numeros if numero % 2 ==0]
>>> lista_de_numeros_pares
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98]

Ejemplo 2: Haremos un Dictionary Comprehensions con Id y el nombre de personas:

>>> people = ['German', 'Caref', 'Carlos']
>>> uid_people = [1,2,3]
>>> people_with_id = {uid: people for uid, people in zip(uid_people, people)}
>>> people_with_id
{1: 'German', 2: 'Caref', 3: 'Carlos'}

Ejmeplo 3: de una lista con números repetidos, haremos un Set comprehension

>>> import random
>>> random_numbers = []
>>> for i in range(10):
...     random_numbers.append(random.randint(1,3))
...
>>> random_numbers
[3, 1, 3, 2, 1, 2, 2, 2, 2, 2]
>>> non_repeated = {number for number in random_numbers}
>>> non_repeated
{1, 2, 3}

Tema muy interesante, es bueno tener conocimiento de este sugar syntax.

#video 29
#Comprehension
import sys
import os
import random

if __name__ == "__main__":
    os.system('clear')
    print('*'*50)
    print ('List comprehensions')
    print('*'*50)
    lista_de_numeros        = list (range(101))
    lista_de_numeros_pares  = [
       numero for numero in lista_de_numeros if numero % 2 == 0]
    print('Lista de numeros')
    print(lista_de_numeros) 
    print('Numeros pares')
    print(lista_de_numeros_pares)
    
    print('*'*50)
    print ('Dictionary comprehensions')
    print('*'*50)
    estudiante_udi      = [1,2,3]
    estudiante_nombre   = ['Angel', 'Diego', 'Velmarys']
    estudiante_con_uid  = {
        uid : estudiante for  uid, estudiante  in zip (estudiante_udi,estudiante_nombre)}
    print( estudiante_con_uid )
    
    print('*'*50)
    print ('Set comprehensions')
    print('*'*50)
    numeros_aleatorios=[]
    for i in range(10):
        numeros_aleatorios.append(random.randint(1,3))
    conjuntos= {
        numeros_de_conjunto for numeros_de_conjunto in numeros_aleatorios }
    
    
    print('Lista de numeros aleatorios: ', numeros_aleatorios)
    print('Conjunto de numero: ',conjuntos)    
    pass

sintaxis: comprehension dictionary

Uso del zip:

Fuente de información:
recursospython.com

Si quieres eliminar los objetos repetidos de una lista también puedes usar:
list(set(lista))

Ejemplo:

>>> lista = [1, 2, 2, 33, 33]
>>> lista_no_repeated = list(set(lista))
>>> lista_no_repeated
[1, 2, 33]
>>>

Muy buena clase, se entendió el concepto

Las comprensiones de listas ofrecen una manera concisa de crear listas. Sus usos comunes son para hacer nuevas listas donde cada elemento es el resultado de algunas operaciones aplicadas a cada miembro de otra secuencia o iterable, o para crear una subsecuencia de esos elementos para satisfacer una condición determinada.

¿por qué es difernte la salida despues de interear en los diccionarios?

El primero se creo de la siguiente manera

clienteseses = {‘name’:‘Jorge’}, {‘name’:‘Luis’}

y el segundo, se creo de la manera en l que mostro David durante este video

In [62]: clienteseses                                                                                              
Out[62]: ({'name': 'Jorge'}, {'name': 'Luis'})

In [63]: for idx, value in enumerate(clienteseses): 
    ...:     print(idx,value) 
    ...:                                                                                                           
0 {'name': 'Jorge'}
1 {'name': 'Luis'}

In [64]: students_with_id                                                                                          
Out[64]: {1: 'Jorge', 2: 'Mario', 3: 'Luis'}

In [65]: for idx, value in enumerate(students_with_id): 
    ...:     print(idx,value) 
    ...:      
    ...:      
    ...:                                                                                                           
0 1
1 2
2 3

¿Que es el zip? no lo entendí muy bien

Ejemplo lista numeros pares e impares: lista_de_numeros = list(range(100)) pares = [num for num in lista_de_numeros if num % 2 == 0] impares = [num for num in lista_de_numeros if num % 2 > 0]

Ejemplo diccionario: student_uid = [1, 2, 3] students = ['Juan', 'Jose', 'Larsen'] students_with_uid = {uid: student for uid, student in zip(student_uid, students)}

Ejemplo set: import random random_numbers = [] for i in range(10): random_numbers.append(random.randint(1, 3)) non_repeated = {number for number in random_numbers}

clients = [
    {
        "name": "Pablo",
        "company": "Google",
        "email": "[email protected]",
        "position": "Software Engineer"
    },
    {
        "name": "Edwin",
        "company": "Google",
        "email": "[email protected]",
        "position": "Data Engineer"
    }
]

dictElement = [element for element in clients if element["name"] == "Pablo"]
dictElement2 = [element for element in clients if element["name"] == "Edwin"]
print(dictElement)

#dictElement
[{‘name’: ‘Pablo’, ‘company’: ‘Google’, ‘email’: ‘[email protected]’, ‘position’: ‘Software Engineer’}]
#dictElement2
[{‘name’: ‘Edwin’, ‘company’: ‘Google’, ‘email’: ‘[email protected]’, ‘position’: ‘Data Engineer’}]

Hola Compañeros dejo esta pagina para consulta sobre las Built-in Funtions

Y aquí encontraran resumido todo sobre Python Collections (Arrays)

import random 
#COMPREHENSIONS LIST
def comprehensions_list():
	list_a = list(range(20))
	pares = [num for num in list_a if num % 2 == 0]
	print(pares)


#COMPREHENSIONS DICT
def comprehensions_dict():
	student_uid = [1, 2, 3]
	students = ['Juan', 'Carlos', 'Luis']

	students_with_uid = {uid: student for uid, student in zip(student_uid,students)}
	print(students_with_uid)


#COMPREHENSIONS DICT
def comprehensions_sets():
	random_numbers = []
	for num in range(10):
		random_numbers.append(random.randint(1, 3))

	print(random_numbers)

	non_repeated = {num for num in random_numbers}
	print(non_repeated)


comprehensions_list()
comprehensions_dict()
comprehensions_sets()

Los comprehensions tienen opcionalmente una condicional.

Existen tres tipos de comprehensions, The list comprehensions se abren con corchetes, The Dict Comprehensions se abren con curly brackets y tienen al principio, no solo un elemento, si no que tienen su clave o su valor. Luego los Set Comprehensions son los mismo que las listas solo que estos llevan llaves.

Los comprehensions, son constructos que nos dejan generar secuencias a apartir de otras secuencias.

IMPORTANTE Puedes agregar dos ciclos for o while dentro de el list comprehension pero no es recomendable ya que una de las caracteristicas principales de python es que sea entendible y sencillo.

el ejemplo de los random numbers no necesariamente se debe hacer con un set comprehension, pero si sirve para aprender la sintaxis obviamente 😃

random_numbers =[1,2,3,4,1,2,3,4]
a= set(random_numbers)

resultado a= {1, 2, 3, 4}

oooooooo esto esta genial

Eliminar repetidos
Con esto era suficiente y más corto

non_repeated = set(random_numbers)

se complico la cosa, 3 horas viendo este video, me entro un bloqueo mental y no avance

Excelente, creo que lo explicó de una forma sencilla y directa. Era un tema que tenía pendiente por aclarar y esta clase me ayudó bastante.
.
** Les comparto un video sobre list comprehensions**

Python cares for your sanity 💆🏽‍♀️ 🤣

También se puede escribir:

pares = [numero for numero in range(100) if numero%2 == 0]

Para el caso de la generación de las list comprehensions.

excelente explicaciòn

random_numbers = []

for i in range(10):
	random_numbers.append(random.randint(1, 3))

random_numbers
[1, 1, 2, 3, 2, 3, 1, 2, 2, 1]

non_repeted = {number for number in random_numbers}
non_repeted
{1, 2, 3}

lista_numeros = list(range(100))
>>> lista_numeros
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]

pares = [numero for numero in lista_numeros if numero % 2 == 0]

>>> pares
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98]

Ejemplos de dict comprehensions