Dictionary Comprehension

Comparto otra forma de resolver el último ejercicio:

names = ['nico', 'zule', "santi"]
edades = [12,56,98]
new_dict = {names[i]:edades[i] for i in range(len(names))}

Comparto método clásico y dictionary comprehension con dos métodos:

names = ['Nico','Zule','Santi']
ages = [12,56,98]

• classical method

dict = {}
for i in range(len(names)):
  dict[names[i]] = ages[i]

• Dictionary Comprehension

dict_2 = {names[i] : ages[i] for i in range(len(names))}

• Dictionary Comprehension (explicado en clase)

new_dict = {name: age for (name, age) in zip(names, ages)}

Revisando los comentarios para las personas que usan una iteracion con len estan asumiendo que las 2 listas contiene la misma cantidad de elementos. y para este caso especifico el output es correcto.

como obervacion: y que pasa si una lista tiene un elemento mas o menos que la otra, con la iteraciones de indices de las 2 lista se rompe el programa por el error IndexError: list index out of range, por que un elemento no tiene un indice homologo en la otra lista, espero hay sido claro.

para mi gusto la mejor manera es usar la funcion zip ya que ese elemento que no tiene pareja la omite y solo une las listas con los elementos con indices iguales.

el primera instancia eso me ahorraria mucha logica tratando ese error de los indices.

tengo la duda de porque no lo hizo directamente de esta forma pero les dejo el dato que se puede hacer directamente

names = ['nico', 'zule', 'santi']
ages = [12, 56, 98]
print (dict(zip(names, ages)))

Dict comprehensions

• Los Dictionary comprehensions -o Dict comprehensions para abreviar- son estructuras semejantes a las vistas pero, tal y como indica su nombre, generan diccionarios. Un ejemplo es el siguiente:

cities = ["Madrid", "Barcelona", "Milán", "Santander"]

{c: len(c) for c in cities}

{'Madrid': 6, 'Barcelona': 9, 'Milán': 5, 'Santander': 9}

• En este ejemplo hemos hecho referencia a una única lista, pero no tiene por qué ser así:

cities = ["Madrid", "Barcelona", "Milán", "Santander"]
years = [2017, 2018, 2019, 2020]

{c: y for c in cities for y in years}

{'Madrid': 2020, 'Barcelona': 2020, 'Milán': 2020, 'Santander': 2020}

• Obsérvese que, en este caso, también se está simulando el mismo bucle for anidado que ya hemos visto:

d = {}
for c in cities:
    for y in years:
        d.update({c: y})
d

{'Madrid': 2020, 'Barcelona': 2020, 'Milán': 2020, 'Santander': 2020}

• Solo subsisten cuatro parejas clave-valor (en lugar de 16) pues ya sabemos que en un diccionario no puede haber claves repetidas, por lo que para cada valor c se recorren todos los años en la variable “y” y se va sobrescribiendo el valor que pueda existir para la clave c.

• Si quisiéramos obtener un diccionario que relacionase cada par de valores de cities y years, podríamos hacerlo con la función zip:

{c: y for c, y in zip(cities, years)}

{'Madrid': 2017, 'Barcelona': 2018, 'Milán': 2019, 'Santander': 2020}

Hice tanto la explicacion de la clase como la solucion que dieron algunos compañeros y ambos codigos tienen exactamente el mismo output

<code> 
names = ['nico','zule','santi']
ages = [12, 56, 98]

dict2=dict(zip(names,ages))
print(dict2)

new_dict = {name:age for (name,age) in zip(names,ages)}
print(new_dict)

Hola platzi comunity, este tema no me fue fácil y decidí hacer un código de rutinas de ejercicios. Esto me ayudo a entender mejor el concepto y la base de la formulación, así como:
La llave de un diccionario, es inmutable y su valor no puede ser lista sino de una tupla.

Grandioso curso la verdad hace que se comprenda todo lo que se quiere lograr por que comienzas de lo simple o lo que ya se conoce a lo complejo por decirlo de alguna forma.

que hace que lo complejo se vuelva fácil

#iteracion con base en dos listas

names = ['Luis','Maria','Jose','Pedro','Juan','Pablo','Luisa','Marta','Sofia','Camila','Andrea','Sara']

ages = [random.randint(1,100) for edad in range(len(names))] #se crea una lista con numeros aleatorios entre 1 y 100, la lista tiene la misma longitud que la lista de nombres
print(ages)

#tenemos dos listas, una con nombres y otra con edades, queremos crear un diccionario con los nombres como llaves y las edades como valores.
#el algoritmo seria: para cada nombre en la lista de nombres, se agrega al diccionario con su llave correspondiente, y el valor de la llave es la edad correspondiente en la lista de edades.

print(list(zip(names, ages))) #se crea una lista de tuplas con los nombres y las edades, zip ayuda a unir dos listas en una lista de tuplas

people = {name: age for (name, age) in zip(names, ages)} # se lee: para cada nombre en la lista de nombres, se agrega al diccionario con su llave correspondiente, y el valor de la llave es la edad correspondiente en la lista de edades.
print(people)

para el ejemplo de la clase también funciona de la siguiente forma

names=['nico', 'zule', 'santi']
ages=[12, 34, 56]

dict2=dict(zip(names,ages))
print(dict2)

ZIP, Permite unir dos tuplas:

a = ("Bolivia", "Peru", "Colombia")
b = ("Boliviano", "Sol", "Peso")

x = zip(a, b)
for i in x:
  print(i)

Salida

('Bolivia', 'Boliviano')
('Peru', 'Sol')
('Colombia', 'Peso')

Quiero compartir una funcion que ayuda a ver de forma visual el diccionario

def printDic(data):
    print("key:value")
    # for element in data:
    #     print(element, ':', data[element])
    for key,value in data.items():
        print(f' {key} : {value}')


dict = {}
for element in range(1, 11):
    dict[element] = element*2
# print(dict)
printDic(dict)

'''
key:value
 1 : 2
 2 : 4
 3 : 6
 4 : 8
 5 : 10
 6 : 12
 7 : 14
 8 : 16
 9 : 18
 10 : 20
'''

Tambien se puede crear un diccionario de esta forma
names=[‘nico’,‘zule’,'santi]
ages=[12,56,98]
new_dict=dict(zip(names, ages)

'''
dict = {}
for i in range(1,5):
  dict[i] = i *2

print(dict)

dict_2 = {i:i *2 for i in range(1,5)}
print(dict_2)

import random
con = ['col','mex','bol','pe']
pobla ={}
for cont in con:
  pobla[cont] = random.randint(1,100)

print(pobla)

pobla_2 ={cont: random.randint(1,100) for cont in con}
print(pobla_2)
'''
name = ['nico','zoro','sanji']
age = [30,21,21]

print(list(zip(name, age)))

new_dict = {name: age for (name,age)in zip(name,age)}
print(new_dict)

ME ENCANTO!! La verdad es que Nicolás es un GRAN docente:

import random

dic_v1 = {}

for i in range(1,11):
  dic_v1[i] = i * 2

print(dic_v1)

dic_v2 = {i: i * 2 for i in range(1,11)}
print(dic_v2)


contries_mercosur = ['ar','br','pr','uy']
population = {}
for i in contries_mercosur:
  population[i] = random.randint(3,220)
print(population)

pop_v2 = {i: random.randint(3,220) for i in contries_mercosur}
print(pop_v2)

names = ['pedro','marcelo','cacho']
ages = [21,54,35]

print(list(zip(names,ages)))

new_dic = {names: ages for (names,ages) in zip(names,ages)}
print(new_dic)

Comparto los ejercicios de la clase pero con mis notas para comprender más tarde que se hizo o como funciona

<#Creo una variable diccionario diccionario
"""dict = {}"""

#Indico en el codigo que mi |key| va a ser el rango establecido en el ciclo |for| y le voy a agregar el valor a la key el cada ciclo indicandole que en cada espacio de la |key| quiero el valor del elemento multiplicado por 2
"""for i in range(1, 5):
  dict[i] = i * 2

print(dict)"""

#Creo un diccionario e indico que quiero que el elemento (en este caso denotado por la letra |i|) sea la |key| y el valor de la |key| va a ser el doble del valor introducido en esta, estos valores se obtienen de ciclo for, en el cual indicamos que el valor en la |key| va a estar establecido por un |range|
"""dict_v2 = {i: i * 2 for i in range(1, 5)}
print(dict_v2)"""

#Generamos un diccionario a partir de una lista

#Importo ña utilidad random para agregar un numero aleatorio más adelante
"""import random"""
#Establecemos una lista con los paises
"""countries = ["col", "mex", "bol", "pe"]"""

#Creamos la variable que va a ser un diccionario
"""population = {}"""

#Iteramos cada uno de los paises dentro de la lista de paises

"""for country in countries:"""
  #Agrego al diccionario, basado en el pais, un número aleatorio llamando a la utilidad random estableciendo un rango en especifico, este numero debe de ser un entero

   #"""population[country] = random.randint(1, 100)"""

"""print(population)"""

#Ejercicio utilizando el dictionari comprehension

#Donde nuestro diccionario esta constituido por la |key| country cuyo valor es un numero aleatorio y entero dentro del rango 1 a 100, los cuales obtendremos de un ciclo |for| sacando los valores de la lista |countries|
"""population_v2 = {country: random.randint(1,100) for country in countries}

print(population_v2)"""

#Ejercicio de iterar 2 listas y con ellas generar un diccionario

names = ["apolo", "artemisa", "hermes"]
ages= [12, 56, 98]

#Para unir una lista con otra se utiliza la función |zip|, pero, si la usamos así sin más nos arroja una referencia, para que el resultado sea una lista, para que arroje una lista hay que convertirla a lista con la función |list|
print(list(zip(names, ages)))

#Agregamos un par clave valor (|key|: |value|) al diccionario que este par |key| |value| nombre y edad viene de iterar un iterable que es una lista con tuplas y esto se obtiene de las listas de nombre y edades
new_dict = {name: age for (name, age) in zip(names, ages)}

#Como resultado aparece un diccionario con los pares |key| y |value| que se obtuvieron de las dos listas
print(new_dict)> 

este error me hizo trasnochar :
TypeError: ‘dict’ object is not callable
al ejecutar

names = ['nico', 'zule', 'zoe']
ages = [12, 56, 90]

# print(dict(zip(names, ages))) or
my_dict = dict(zip(names, ages))
print(my_dict)

por alguna extraña razón en una terminal me da error y en otra no. no se si sea tema de librerias instaldas o que.

👀Les dejo mi aporte que según mi punto es el mejor y más sencillo:
En seguida les explico que se hizo ✔

diccionario = {k: v for k, v in zip(names, ages)} 

En este ejemplo, ‘k’ y ‘v’ son variables que se utilizan para iterar sobre los elementos de las listas claves y valores (Lo que posee un diccionario). El dictionary comprehension asigna a cada elemento de la lista claves (que se almacena en la variable k) su elemento correspondiente de la lista valores (que se almacena en la variable v).

Antes de eso recordemos la sintaxis de la comprensión de diccionarios:

{key_expression: value_expression for item in iterable} 

En este caso, key_expression es k y value_expression es v. Al iterar sobre los elementos de las listas claves y valores con la función zip(), se obtiene una secuencia de tuplas, donde cada tupla contiene un elemento de cada lista. Por ejemplo, la primera tupla sería (‘nico’, 12), la segunda tupla sería (‘zule’, 56), y así sucesivamente. Al asignar cada elemento de la tupla a la variable k y v, se puede utilizar esta información para crear el diccionario.

Este es un poco mas complicado abordar pero, vamos a lo simple para entender lo complejo.

Los diccionary comprehension son parte de la estructura de datos avanzadas que lo que hace es crear un diccionario con un resultado segun lo que contenga.

operacion = {}

for i in range(1,10):
    operacion[i] = i*2
print(operacion)

esta misma linea de codigo, puedes escribirla asi:

operacion = {i:i*2 for i in range(1,10)}

print(operacion)

Si te preguntas, esto para que es util, puedes verlo como una manera mas avanzada para tu codigo, ahorro en la linea y ademas es enriquecimiento en la linea de codigo.

Hay otras formas para llegar al mismo resultado, entre ellas esta la siguiente:

names = ['nico', 'zule', "santi"]
ages = [12,56,98]

# Opcion 1
new_dict = {}
for i in range(len(names)):
    item = names[i]
    new_dict[item] = ages[i]  
print(new_dict)

# Opcion 2
new_dict = {names[i] : ages[i] for i in range(len(names))}
print(new_dict)  

Con " range(len(names) " extraemos el numero de veces que se debe iterar.

Gente, les dejo otra forma de hacer lo ultimo.
Nuestro iterador va a ser la lista de “names” y el elemento dinamico seria el indice de esta misma lista. Al sacar el tamaño de la lista con “len” y tenerlo dentro del “range()” estamos iterando en un rango de 0-2 (range(3) sin incluir el 3). De esta forma tomaria el primer indice de ambas listas y las acomodaria en el diccionario. La limitante de esto es que deben de ser del mismo tamaño ambas listas.

names = ['nico', 'zule', 'santi']
ages = [12, 56, 98]

people_v3 = {names[i]: ages[i] for i in range(len(names))]
print(people_v3)

Comparto 3 maneras de unir las dos listas en un Dict

# Generate a dictionary in a single line of code
ani = ['conejo', 'pez', 'sapo', 'perro', 'gato', 'tigre']
nums = [nums+1 for nums in range(len(ani))]
nw_dic = {nums[i]: ani[i] for i in range(len(ani))}
nwdic_O = {nums[i]: ani[i] for i in range(len(ani)) if 'o' in ani[i]}

if __name__ == "__main__":
    print("Dictionary\n\t", nw_dic)
    print("Animals with 'o'\n\t", nwdic_O)

Investigando pude encontrar que podemos incluir mas de 2 listas, en este caso voy a tener 3 listas, las cuales me contienen los siguientes datos:

names = {"pedro", "andres", "carlos"}
ages = {21, 35, 40}
countrie = {"col", "mex", "arg"}

Ahora si vamos a print podemos obtenemos el siguiente resultado:

print(set(zip(names, ages, countrie)))
{('andres', 40, 'col'), ('pedro', 21, 'arg'), ('carlos', 35, 'mex')}

Pero al momento de utilizar dictionary comprehension, encontramos que zip() nos permite comprimir 3 listas y realizar operaciones más representativas.

for names, ages, countrie in zip(names, ages, countrie):
  print(f"Su nombre es {names} tiene {ages} y vive en {countrie}")

Obtenemos:

Su nombre es andres tiene 40 y vive en col
Su nombre es carlos tiene 35 y vive en mex
Su nombre es pedro tiene 21 y vive en arg

Comparto el articulo de las funciones de zip()

Estan geniales los Dictionary Comprenhensions!

Dictionary Comprehension

dict = {}
for i in range(1, 11):
    dict[i] = i * 2
print(dict)

‘’‘con Dictionary Comprehension’’’

dict2 = {i: i * 2 for i in range(1, 11)}
print(dict2)

‘’’’’’

import random

countries = ['col', 'pe', 'cad']
population = {}
for country in countries:
    population[country] = random.randint(1, 100)

print(population)

‘’‘el ejercicio anterior se puede escribir mejor así:’’’

countries = ['col', 'pe', 'cad']
populationV2 = { country: random.randint(1, 100) for country in countries }
print(populationV2)

‘’‘union entre listas’’’

names = ['nico', 'zule', 'santi']
ages = [12, 45, 21]

union = zip(names, ages)
listNames = list(union)
print(zip(names, ages))
print(listNames)

#generando diccionario de listNames

newDict = { name: age for (name, age) in listNames }
print(newDict)
print(list(newDict))

Dictionary Comprehension o Comprensión de Diccionarios es una manera de guardar elementos como lo haríamos en una lista, pero en lugar de acceder a los elementos usando su indice o “index”, le asignamos una llave para acceder a este elemento con esa misma llave.

mi_diccionario = {"key1":<value1>,"key2":<value2>,"key3":<value3>,"key4":<value4>}

Esta sigue el principio de “Hacer más con menos código”. No solo se trata de escribir menos código, sino también de hacer que el código sea más legible y fácil de entender.

Cada elemento en un diccionario contiene una clave y un valor, es decir, un par de clave-valor

La comprensión de diccionarios puede ser muy útil para crear nuevos diccionarios basados en diccionarios existentes e iterables.

Otro ejemplo:

alumnos = ['Juancho', 'Rodri', 'Axel']
notas = [10, 6, 9]
notas_de_alumnos = {alumno: nota for alumno, nota in zip(alumnos, notas)}
print(notas_de_alumnos)

1. Definición de listas:

   alumnos = ['Juancho', 'Rodri', 'Axel']
   notas = [10, 6, 9]
   

   Se crean dos listas: alumnos que contiene nombres de estudiantes, y notas que contiene las calificaciones correspondientes. Cada nombre de estudiante en la lista alumnos está asociado con una calificación en la misma posición en la lista notas.

2. Uso de zip:

   zip(alumnos, notas)
   

   La función zip combina elementos de las listas alumnos y notas en tuplas. En este caso, crea un iterador que produce las siguientes tuplas: ('Juancho', 10), ('Rodri', 6), y ('Axel', 9).

3. Comprensión de diccionario:

   {alumno: nota for alumno, nota in zip(alumnos, notas)}
   

   Utilizando una comprensión de diccionario, se crea un nuevo diccionario llamado notas_de_alumnos. Para cada tupla (alumno, nota) generada por zip, se crea una entrada en el diccionario donde el nombre del alumno es la clave y la nota es el valor.

4. Resultado final:

   print(notas_de_alumnos)
   

   Después de ejecutar este código, notas_de_alumnos contendrá:

   {'Juancho': 10, 'Rodri': 6, 'Axel': 9}
   

   El diccionario resultante asocia cada nombre de estudiante con su respectiva calificación. En este caso, se utiliza para representar las notas de los alumnos como pares clave-valor en un diccionario.

Para unir dos listas en un solo diccionario, puedes utilizar la función zip junto con un diccionario de comprensión. Aquí hay un ejemplo:

nombres = ['nico', 'zule', 'santi']
edades = [12, 56, 98]

# Usando zip y un diccionario de comprensión para combinar las listas
diccionario_resultante = {nombre: edad for nombre, edad in zip(nombres, edades)}

print(diccionario_resultante)

Explicación:

1. zip(nombres, edades): La función zip toma dos o más iterables y devuelve un iterador que genera tuplas conteniendo elementos correspondientes de los iterables originales. En este caso, crea un iterador que combina los elementos de las listas nombres y edades en tuplas.

2. {nombre: edad for nombre, edad in zip(nombres, edades)}: Utiliza una comprensión de diccionario para crear un nuevo diccionario. Para cada tupla (nombre, edad) generada por zip, crea una entrada en el diccionario donde el nombre es la clave y la edad es el valor.

3. print(diccionario_resultante): Imprime el diccionario resultante.

Después de ejecutar este código, diccionario_resultante contendrá:

{'nico': 12, 'zule': 56, 'santi': 98}

Cada nombre en la lista nombres está emparejado con la edad correspondiente en la lista edades, formando un diccionario.

En este código, se asume que las dos listas tienen la misma longitud, y se crea un diccionario donde los elementos en la posición i de la lista names son las claves, y los elementos en la posición i de la lista edades son los valores correspondientes.

Aquí hay una explicación detallada del código:

1. Definición de listas:

   names = ['nico', 'zule', "santi"]
   edades = [12, 56, 98]
   

   Se crean dos listas, names y edades, que contienen nombres y edades respectivamente. Cada nombre en la lista names está asociado con la edad en la misma posición en la lista edades.

2. Comprensión de diccionario:

   new_dict = {names[i]: edades[i] for i in range(len(names))}
   

   Esta línea de código utiliza una comprensión de diccionario para crear un nuevo diccionario llamado new_dict. Aquí hay una desglose de lo que sucede:

   • range(len(names)): Genera una secuencia de números desde 0 hasta la longitud de la lista names menos 1. En este caso, crea la secuencia [0, 1, 2].
   • names[i]: edades[i]: Para cada valor de i en la secuencia generada, toma el elemento en la posición i de la lista names como clave y el elemento en la posición i de la lista edades como valor.
   • {...}: Construye un diccionario con las claves y valores generados.

3. Resultado final:
   Después de ejecutar este código, new_dict contendrá un diccionario que asocia los nombres con las edades de la siguiente manera:

   {'nico': 12, 'zule': 56, 'santi': 98}
   

   Cada nombre en la lista names se convierte en una clave en el diccionario, y la edad correspondiente en la lista edades se convierte en el valor asociado.

Trate de hacerlo mas simple y este fue mi resultado

data = [('nico', 12), ('zule', 56), ('santi', 98)]
names, edades = zip(*data)
new_dict = dict(data)

Es increible la forma de realizar comprehensions a base de diccionario. Es interesante lo que se puede aprender.

Forma alternativa al ultimo ejercicio

names = ['nico', 'zule', 'santi']
ages = [12, 56, 98]

users = { name: ages[i] for i, name in enumerate(names) }
print(users)

Dictionary comprehensions

💡 Nota:

• El if es completamente opcional
• Se lee “Para cada elemento en el iterable, Coloco una llave y un valor, si se cumple la condición”

LIMIT = 100
my_dict = { i: i**3 for i in range(1,LIMIT+1) if i % 3 != 0 }
print(my_dict)

import random 

empresas = ["amazon", "linio", "mercado libre"]
presupuesto = {}

for empresa in empresas :
  presupuesto[empresa] = random.randint(1, 2800)

print(presupuesto)

✅

Algo que descubrí y se los comparto:

# What happens when one list is shorter than the other?

numbers = [1, 3, 6, 7, 8, 4, 3, 2]
letters = ['a', 'c', 'v', 'm']

print("list(zip(numbers, letters)): ", list(zip(numbers, letters)))     # list(zip(numbers, letters)):  [(1, 'a'), (3, 'c'), (6, 'v'), (7, 'm')]

# the resulting list of tuples will be the size of the shorter list

# what happens when there're now 3 lists of different sizes each? 

bools = [True, True, False]

print("same but with 3 lists: ", list(zip(numbers, letters, bools)))        # same but with 3 lists:  [(1, 'a', True), (3, 'c', True), (6, 'v', False)]

# the resulting list will be of the size of the smaller list

El mio quedo asi:

mascotas = ['perro', 'gato', 'perico', 'pato', 'hamster']
nombres_mascotas = ['Max', 'Michi', 'Poli', 'Patroclo', 'Solovino']

list_dict = {nombre_mascota:mascota for mascota, nombre_mascota in zip(mascotas, nombres_mascotas)}
print(list_dict)

Entender los conceptos de “elemento” e “iterable” es fundamental para trabajar con comprensiones de listas y diccionarios en Python.

Elemento:
En programación, un “elemento” se refiere a un valor individual dentro de una secuencia o colección de datos. Puede ser un número, una cadena de texto, un objeto, o cualquier otro tipo de dato. Por ejemplo, en una lista [1, 2, 3], cada número (1, 2, 3) es un elemento de la lista.

Iterable:
Un “iterable” es un objeto en Python que puede ser iterado o recorrido elemento por elemento. Los iterables son secuencias de datos que permiten acceder a sus elementos en un orden específico. Algunos ejemplos de iterables en Python incluyen listas, tuplas, cadenas, diccionarios y conjuntos.

Un iterable es una estructura de datos que puede ser recorrida utilizando un bucle for. Cada vez que el bucle for itera sobre el iterable, obtiene un elemento del iterable en cada paso hasta que se hayan procesado todos los elementos.

Ejemplos de iterables:

• Listas: mi_lista = [1, 2, 3]
• Tuplas: mi_tupla = (1, 2, 3)
• Cadenas: mi_cadena = "Hola"
• Diccionarios: mi_diccionario = {'a': 1, 'b': 2}
• Conjuntos: mi_conjunto = {1, 2, 3}

Un “elemento” es un valor individual dentro de una colección de datos, y un “iterable” es una estructura de datos que permite recorrer sus elementos en un orden específico utilizando un bucle for u otras técnicas de iteración. Las List Comprehensions y las Dictionary Comprehensions son útiles para crear nuevas colecciones (listas o diccionarios) a partir de iterables aplicando una expresión a cada elemento del iterable.

names = ['david','jose','mari']
edad = [19,12,43]

resultado_reniec = {i:edad[names.index(i)] for i in names}
print (resultado_reniec)

Esto también funciona.

names = ['nico', 'zule', "santi"]
edades = [12, 56, 98]

mix = zip(names,edades)
print(dict(mix))

Tengo más aportes:

# Mientras tanto en ciudad gotica...
# Te imaginas poder tener el poder de las list comprenhension en diccionarios...
'''
dict = {}
for i in range(1, 5):
  dict[i] = i * 2

print(dict) # Estoy cansado de eso

# Espera acaso es...

dict_v2 = { i: i * 2 for i in range(1, 5) }
print(dict_v2)
'''
# MI SALVACIÓN!!!!!!

'''
import random

countries = ['col', 'mex', 'bol', 'pe']
population = {}
for country in countries:
  population[country] = random.randint(1, 100)

print(population)

population_v2 = { country: random.randint(1, 100) for country in countries }
print(population_v2)
'''

names = ['nico', 'zule', 'santi']
ages = [12, 56, 98]

print(list(zip(names, ages)))

new_dict = { name: age for (name, age) in zip(names, ages) }
print(new_dict)

diccionario = {}
for i in range (1,11):
diccionario[i]= i*2
print(diccionario)

diccionario_2 ={i: i*2 for i in range (1,5)}
print(diccionario_2)

import random
paises = [“colombia” , “paraguay”, “venezuela” , “guatemala”]
poblacion = {}
for pais in paises:
poblacion[pais] = random.randint(1,100)
print(poblacion)

poblacion2={pais:random.randint(1,100)for pais in paises}

union de dos listas

nombres = [“milo”,“camilo”,“santi”]
edad = [12,15,18]

print(list(zip(nombres, edad)))

nuevo_diccionario = {nombres: edad for (nombres , edad) in zip (nombres , edad)}

randomico == aleatorio

la segunda opcion veo sencillo pero ay que seguir aprendiendo

'''

Los dict comprehensions en Python son una forma concisa y eficiente de construir diccionarios en una sola línea de código. Permiten crear y asignar pares clave-valor a un diccionario utilizando una sintaxis compacta.

'''
import random

#Agregar elementos a un diccionario de forma tradicional
dict = {}
for i in range(1,11):
  dict[i] = i * 2
print(dict)

#Agregar elementos a un diccionario de forma dict comprehensions
dict_2 = {i:i * 2 for i in range(1,11)}
print(dict_2)

#Agregar clave a los valores de la lista de forma tradicional
countries = ['arg', 'brasil', 'mex', 'can', 'ua']
population = {}
for country in countries:
  population[country] = random.randint(1, 100)
print(population)

#Agregar clave a los valores de la lista con dict comprehensions
population_2 = {country: random.randint(1,100) for country in countries}
print(population_2)

#Crear un diccionario con ambas listas en list comprehension
names = ['Guillermo', 'Danae', 'Rafael', 'Hector', 'Jesus', 'Fernando', 'Ignacio', 'Suri', 'Antonio', 'Samuel', 'Alejandro']
ages = [29, 28, 30, 28, 27, 28, 29, 28, 25, 31, 28]

#Uso de la función zip
dict_list = list(zip(names, ages))
print(dict_list)
print(type(dict_list)) #Regresa una lista de Tuples

dict_3 = {name : age for (name,age) in zip(names,ages)}
print(dict_3)
print(type(dict_3)) #Regresa un diccionario

Otro pequeño ejemplo de la compresión de diccionarios:

Tomamos un diccionario con una lista de materias y calificaciones, y devolvemos otro diccionario pero con las materias en mayúsculas.

Notas de clase

dict = {}

for i in range(1,6):
  dict[i] = i
print(dict)

#Con Dictionary Comprehension
dict_v2 = {i:i for i in range(1,6)}
print(dict_v2)

#Otro ejemplo
import random
countries = ['col', 'mex']
population = {}

for i in countries:
  population[i] = random.randint(1, 999)

print(population)

#Con Dictionary Comprehension
population_v2 = {i:random.randint(1, 999) for i in countries}

print(population_v2)

#Otro ejemplo con dos listas
names = ['Jose', 'María']
edades = [18, 20]

dict = {names[i] : edades[i] for i in range(len(names))}
print(dict)

  

Se que no es comprension de listas, pero si se busca una solucion rapida puedes hacer directamente lo siguiente:

new_dict = dict(zip(names, ages))
#se crea el diccionario con el par clave:valor

personas = ['Alexander', 'Raquel', 'Jose']
edades = [28,29,68]

dict_persona_edad = {personas[i]:edades[i] for i in range(0,len(personas))}
print(dict_persona_edad)

# agregando nombres de una lista y agregando una key con su respectivo numero

dict = {}
names = ["Daniel", "Jose", "pepe", "cheo", "kali", "Esmeralda"]
for element in range(0, len(names)):
  dict[element] = names[element]

print(dict)

OUTPUT:
{0: 'Daniel', 1: 'Jose', 2: 'pepe', 3: 'cheo', 4: 'kali', 5: 'Esmeralda'}

En este ejemplo quise practicar hacer un dicionario donde sus llaves fueran las letras del abecedario empezando desde la “a”,

Para hacer esto utilice la libreria de string y su metodo llamado string.ascii_lowercase

import string
#asigno el metodo a la variable s para usarla mas comodamente.

s= string.ascii_lowercase

names = ["Rocket", "Lylla", "Floor", "Dientes"]

#Creamos el diccionario
dict = { i: names[s.index(i)] for i in s[s.index("a"):len(names)]}

print(dict)

OUTPUT:
{'a': 'Rocket', 'b': 'Lylla', 'c': 'Floor', 'd': 'Dientes'}

Consejo, no llamen a una variable con el mismo nombre de una función, me comí la cabeza por una cosa muy sencilla.

'''
dict = {}
for i in range(1, 6):
  dict[i] = i * 2
print(dict)

dict_v2 = {i: i * 2 for i in range(1, 6)}
print(dict_v2)
'''
'''
import random
countries = ['col', 'mex', 'bol', 'pe']
population = {}
for country in countries:
  population[country] = random.randint(1, 100)
print(population)

population_v2 = { country: random.randint(1, 100) for country in countries}
print(population_v2)
'''

names = ['andres', 'tata', 'geo']
ages = [22, 18, 45]

print(list(zip(names, ages)))

new_dict = {name: age for (name, age) in zip(names, ages)}
print(new_dict)

Yo lo resolvi asi, aunque no se si cuenta como “dict comprehention”

family = dict(zip(members, age))

Una única observación. No son necesarios los parentesis para recorrer el iterable zip con dos variables distintas. Podría hacerse así perfectamente:

    names = ["nico", "zule", "santi"]
    ages = [12, 56, 68]
    myDict = { name : age for name, age in zip(names, ages)}
    print(myDict)

Dejo otra alternativa para armar el mismo diccionario con dos listas distintas (siempre que la segunda lista tenga al menos la misma cantidad de elementos que la primera referenciada en el for:

    names = ["nico", "zule", "santi"]
    ages = [12, 56, 68]
    myDict = { names[i] : ages[i] for i in range(len(names)) } 
    print(myDict)

Saludos!!!

Les comparto el cómo generar un diccionario a partir de otro diccionario:

my_list = range(1, 11)
my_dict = {i : i * 2 for i in my_list if i % 2 == 0 }
print(my_dict)
# Forma uno
my_new_dict = { key:value for key, value in my_dict.items() if key >= 4 and key <= 8 }
# Forma dos
my_new_dict = { key: my_dict[key] * 1 for key in my_dict if key >= 4 and key <= 8 }

print(my_new_dict)
# {
#     4: 8, 
#     6: 12, 
#     8: 16
# }

seria mas bonito si las los nombres, paises , edad, fueran en español

Dictionary comprehension es una característica de Python que permite crear diccionarios de manera concisa y eficiente. Es una sintaxis compacta para crear un diccionario a partir de otro iterable, utilizando una única línea de código.

Buen día, compañeros.
Les comparto otra manera de resolver el último ejercicio usando funciones:

# Se determina el nombre con su respectiva edad correspondiente.
def name_age (list_1, list_2):
	"""Se determina la edad de cada persona en orden, tomando como referencia dos listas: una con los "nombres" y otra con las "edades" correspondientes.

    return: El resultado es un diccionario que contiene los nombres y sus edades respectivas, presentados de manera ordenada y correspondiente.
    """

	return {i: a  for i, a in zip(list_1, list_2)}

dict_list = {}
list = ['goku', 'vegeta', 'gohan', 'yamcha']

dict_list = {personaje : random.randint(1000,1000000) for personaje in list }

print(dict_list)

for nombre , poder in dict_list.items():
  if poder == max(dict_list.values()):
    print('El poder mas alto es de: ' + nombre + ' cuyo poder es de: ' + str(poder))