Introducci贸n

1

El Zen de Python

Conjuntos

2

Sets

3

Modificando conjuntos

4

Operaciones con conjuntos

5

Playgrounds: Elimina elementos duplicados usando conjuntos

Comprehensions

6

List Comprehension

7

Dictionary Comprehension

8

Dictionary Comprehension: condition

9

Playgrounds: Crea una lista usando List Comprehension

10

Lists vs. Tuples vs. Sets

Funciones

11

Funciones

12

Funciones: return

13

Par谩metros por defecto y m煤ltiples returns

14

El scope

15

Refactor game

16

Playgrounds: Tienda de Tecnolog铆a

17

Funciones an贸nimas: lambda

18

Higher order function: una funci贸n dentro de otra funci贸n

19

Map

20

Map con diccionarios

21

Reto: map con inmutabilidad

22

Playgrounds: Multiplica todos los elementos por dos

23

Filter

24

Playgrounds: Retorna solo palabras de 4 letras y m谩s

25

Reduce

M贸dulos

26

M贸dulos

27

Mis propios m贸dulos

28

M贸dulos como scripts: __name__ y __main__

29

Paquetes

30

Playgrounds: Calcular la suma de todas las compras

Manipulaci贸n de archivos y errores

31

Iterables

32

Errores en Python

33

Manejo de excepciones

34

Playgrounds: Captura la excepci贸n: ZeroDivisionError

35

Leer un archivo de texto

36

Escribir en un archivo

37

Leer un CSV

38

Playgrounds: Lee un CSV para calcular el total de gastos

Gr谩ficas en Python

39

Creando una gr谩fica

40

Reto: graficando la poblaci贸n de un pa铆s

41

Reto: graficando la poblaci贸n mundial

Pr贸ximos pasos

42

隆Conoce otros proyectos de este curso!

43

Reconoce tu proceso y certif铆cate

44

Toma el Curso de PIP y Entornos Virtuales con Python

No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Dictionary Comprehension

7/44
Recursos

Aportes 88

Preguntas 9

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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 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)
#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')

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

Tambien se puede crear un diccionario de esta forma
names=[鈥榥ico鈥,鈥榸ule鈥,'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)

este error me hizo trasnochar :
TypeError: 鈥榙ict鈥 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, 鈥榢鈥 y 鈥榲鈥 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 (鈥榥ico鈥, 12), la segunda tupla ser铆a (鈥榸ule鈥, 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.

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

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 鈥渘ames鈥 y el elemento dinamico seria el indice de esta misma lista. Al sacar el tama帽o de la lista con 鈥渓en鈥 y tenerlo dentro del 鈥渞ange()鈥 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

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.

# 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!

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 鈥渆lemento鈥 e 鈥渋terable鈥 es fundamental para trabajar con comprensiones de listas y diccionarios en Python.

Elemento:
En programaci贸n, un 鈥渆lemento鈥 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 鈥渋terable鈥 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 鈥渆lemento鈥 es un valor individual dentro de una colecci贸n de datos, y un 鈥渋terable鈥 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))

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

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 = [鈥渃olombia鈥 , 鈥減araguay鈥, 鈥渧enezuela鈥 , 鈥済uatemala鈥漖
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 = [鈥渕ilo鈥,鈥渃amilo鈥,鈥渟anti鈥漖
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 鈥渁鈥,

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 鈥渄ict 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))
     

Para los que todav铆a se les complica el formato 鈥渃omprehension鈥 como a m铆, aqu铆 les comparto el codigo en un ciclo for regular:

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

print(new_dict)

Hice un c贸digo para crear un password con lo visto hasta ahora en el curso:

# Libreria para limpiar pantalla
import os
os.system("cls")

import random
import string

numero_de_caracteres = int(input("驴Cu谩ntos caracteres necesitas?"))

password = [] 

letras_mayusculas = [password.append(i) for i in chr(random.randint(65, 90))]
letras_minusculas = [password.append(i) for i in chr(random.randint(97, 122))]
numeros = [password.append(str(random.randint(0, 9)))]
simbolos = [password.append(random.choice(string.punctuation))]
# print(password)

#Listaa para almacenar los caracteres para completar el password
caracteres_para_completar = [] 
caracteres_para_completar_list = []
#Agrega letras mayusculas a la lista de caracteres para comletar el password
letras_mayusculas_extras = [caracteres_para_completar.append(chr(i)) for i in range(65, 91)] 
#Agrega letras min煤sculas a la lista de caracteres para comletar el password
letras_minusculas_extras = [caracteres_para_completar.append(chr(i)) for i in range(97, 122)] 
#Agrega numeros a la lista de caracteres para comletar el password
numeros_extras = [caracteres_para_completar.append(str(i)) for i in range(0, 10)]
#Agrega simbolos a la lista de caracteres para comletar el password
simbolos_extras = [caracteres_para_completar.append(random.choice(string.punctuation)) for i in string.punctuation]
#reordena aleatoreamente la lista de caracteres para comletar el password
random.shuffle(caracteres_para_completar)
#convierte en un conjunto la lista de caracteres para comletar el password para eliminar duplicados
caracteres_para_completar_set = set(caracteres_para_completar)
#convierte en una lista el conjunto de caracteres para comletar el password
caracteres_para_completar_list = list(caracteres_para_completar_set)
#reordena aleatoreamente la lista de caracteres para comletar el password
random.shuffle(caracteres_para_completar_list)

#Elige los caracteres necesarios para completar elpassword
for i in range(numero_de_caracteres - 4):
    caracteres_para_completar_elegidos = random.choice(caracteres_para_completar_list)
    password.append(caracteres_para_completar_elegidos)
    
#Imprime el password final
random.shuffle(password)
password = "".join(password)
print(password)

Implementando f-strings en el Output:

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

for keys, values in population.items():
  print(f'In {keys} there are {values} people')

Output:
In col there are 43 people
In mex there are 79 people
In bra there are 68 people
In pe there are 66 people

ar_asoc = [['name','alvaro'],['lastn','ruiz'],['age',36]]
dict_fromArray ={item[0]:item[1] for item in ar_asoc}
#{'name': 'alvaro', 'lastn': 'ruiz', 'age': 36}

array_asoc = [['name','alvaro'],['lastn','ruiz'],['age',36]]
dicc_whitMetodo = dict(array_asoc)
#{'name': 'alvaro', 'lastn': 'ruiz', 'age': 36}

Comprehension es super elegante

cuando vi esta clase me pregunte, que pasa si las listas son de diferente tama帽o, y quiero llenar el valor faltante con un valor por defecto.

La respuesta la encontr茅 aqu铆:
Passing Arguments of Unequal Length

Probando en c贸digo:

from itertools import zip_longest
names = ['nico', 'juan', 'maria', 'robert']
ages = [12, 24, 36]
names_to_ages = {name:age for (name,age) in zip_longest(names, ages, fillvalue = "NA")}
print(names_to_ages)

Y la salida es:

{'nico': 12, 'juan': 24, 'maria': 36, 'robert': 'NA'}

Hice esta soluci贸n antes de terminar de ver la resoluci贸n del profe:

family_2 = {name:ages[names.index(name)] for name in names}
print(family_2)

Que tal! comparto mi c贸digo

'''
Dictionaty Comprehensions

{key: value for var in iterable}
'''
jumpline = '=' * 25

# Voy a crear una lista donde el key sea un numero y el valor sea el numero * 2
dict = {}
for i in range(1,5):
  dict[i] = i * 2
print(dict) # {1: 2, 2: 4, 3: 6, 4: 8}
print(jumpline)

# Puedo crear la misma lista con comprehensions
dict_v2 = {i : i*2 for i in range(1,5)}
print(dict_v2) # {1: 2, 2: 4, 3: 6, 4: 8}
print(jumpline)

# Generemos un diccionario a partir de una lista donde el key sea el nombre del pais y value una poblacion aleatoria entre 1 y 150
import random
countries = ['col', 'mex', 'bol', 'pe']
population = {}
for i in countries:
  population[i] = random.randint(1, 150)
print(population)
print(jumpline)

# Tambien podemos hacerlo con list comprehension
countries = ['col', 'mex', 'bol', 'pe']
population_2 = {i: random.randint(1,150) for i in countries}
print(population_2)
print(jumpline)

# Ahora generaremos un diccionario a partir de dos listas
names = ['sergio', 'mathias', 'maxi']
ages = [20, 11, 9]
# Puedo unir las listas con .zip(lista,lista) y se vuelve una lista de tuplas
brothers = {name: age for (name, age) in zip(names, ages)}
print(brothers)

# Otra forma de hacer este ejercicio
brothers_2 = {names[i]: ages[i] for i in range(len(names))}
print(brothers_2)

espero ayude

En Python, se puede fusionar listas para formar un dictionary comprehension utilizando la funci贸n zip() que empareja elementos de m煤ltiples listas en tuplas y luego se pueden convertir en un diccionario usando la sintaxis de diccionario comprehension. A

Ejemplo 1: Fusionar dos listas para crear un diccionario.

# Fusionar dos listas para crear un diccionario
keys = ['a', 'b', 'c']
values = ['Alzate', 'Botero', 'Casas']
dict_comp = {keys:values for keys, values in zip(keys, values)}
print(dict_comp) 

Comparto el m茅todo cl谩sico (largo) que encontr茅 para el 煤ltimo ejemplo:

nombres = ['Marte', 'Venus', 'Mercurio']
edades = [15, 12, 23]

dict2 = {}
for nombre, edad in zip(nombres, edades):
  dict2[nombre] = edad
  
print(dict2)

Una forma que encontr茅 para resolver este problema en el pasado fue:

key_list = [n for n in range(1,11)]
value_list = [n * 2 for n in range(1,11)]

dict_test = dict(zip(key_list, value_list))
print(dict_test)

Pero me inclino por usar dict comprehensions, mucho m谩s legible.

codigo usando enumerate para resolver el ultimo ejercicio:
people_v2 = {name: ages[i] for i, name in enumerate(names)}
print(people_v2)

Hola!

Les comparto el c贸digo de la clase:

# Dictionary Comprehension

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

print(dict)

# Usando dict comprehension
dict_v2 = { i: i * 2 for i in range(1, 6) }
print(dict)


# Generar diccionario a partir de una lista
import random
countries = ["col", "mex", "bol", "peru"]
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)


# Iterar dos listas para generar un diccionario
names = ["nico", "zule", "santi"]
ages = [12, 56, 98]

# Unir listas
print(list(zip(names, ages)))

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

Si quieren acceder al index de sus valores en cada lista lo hacen con la funcion enumerate(list)
Aqui un ejemplo de enumerate con dictionary comprehension

names = ["Vladi", "Chicha", "Dolphy"]

people = { name: index for index, name in enumerate(names) }
print(people)

La funcion zip() nos permite fusionar una lista con otra

Por que usar el metodo zip().

  • La funci贸n zip(), realiza la union de dos listas de acuerdo al tama帽o de las mismas, es decir, en caso que una lista sea mas larga que la otra, la union se realizara teniendo en cuenta el tama帽o de la mas corta evitando as铆 errores.
names = ['Isabel', 'Juand', 'Carlos', 'Rosita', 'Felix', 'Francisco']
ages = [40, 22, 39, 60, 61, 45]

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

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

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

Comparto la forma 鈥渓arga鈥 de revolver el 煤ltimo ejercicio:

people = {}
for (name, age) in zip(names, ages):
  people[name] = age

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

print(dict(zip(names, ages)))
# {'nico': 12, 'zule': 56, 'santi': 98}
'''
Diccionario por comprension

{key:value for var in iterable}
Elemento        Ciclo donde se extraen
llave-valor     elementos de cualquier iterable
'''

dict={}

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

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

for key,value in dict_v2.items():
    print(key,value)
    
import random
    
paises=["col","mex","per","bol"]
poblacion={}

for pais in paises:
    poblacion[pais]=random.randint(1,100)
print(poblacion)


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

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

print(list(zip(names,edades)) )

nuevo_dict={name:edad for (name,edad) in zip(names,edades)}

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


muy interesante zip(), jamas lo habia visto

A m铆 me gusta nombrar las variables dentro de los for de otra manera ya que siento que si los nombras parecidos ya no sabes si est谩s llamando a la lista o a la variable dentro del for.
Les dejo la manera en la que yo lo escrib铆 por si a alguien le sirve(tambi茅n me parece es m谩s com煤n hacerlo as铆)

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

new_dict = {i: v for (i, v) in zip(names, ages)}
print(new_dict)

Est谩 bueno el tema! De seguro ayuda a refactorizar un mont贸n de c贸digo

TIP: dejo la documentaci贸n de la funci贸n zip, sirve para unir tuplas:
https://www.w3schools.com/python/ref_func_zip.asp

#otra solucion al ultimo ejercicio

names=[鈥榥ico鈥,鈥榸ule鈥,鈥榮anti鈥橾
ages=[12,56,98]

dict={name:ages[names.index(name)] for name in names}

print(dict)

comparto forma de crear la union de dos listas usando el FOR鈥NUMERATE

<code> 
name=['a','b','c','d']
age=[10,20,30,40]

dic={name:age[idx] for idx,name in enumerate (name)}
print(dic)

Les dejo un peque帽o script en el que uno listas de paises aleatorios y animales.

import random
import os
from countries import list_countries, list_animals

def main():
    a_bit_of_countries = [random.choice(list_countries) for x in range(10)]
    population = {country: random.randint(1,1000) for country in a_bit_of_countries }
    

    a_bit_of_animals = [random.choice(list_animals) for x in range(10)]

    new_dict = {k:v for k, v in zip(a_bit_of_countries, a_bit_of_animals)}

    print(f'This dictionary results to join the list of countries with random numbers as values: \n {population} \n')
    print(f'This dictionary results to join the list of countries with the list of animals: \n {new_dict}')

if __name__ == '__main__':
    os.system('clear')
    main()

El resto de los scripts no los coloco ya que sugiere archivos adicionales, solo quiero plasmar la idea que surgi貌 a partir de esta clase.

#Las dos maneras del ejercicio anterior:

names = ['nico', 'zule', 'santi']
ages = [12,56,98]
name_age= {}
for key in names:
  for value in ages:
    name_age[key] = value
    ages.remove(value)
    break
print(name_age)

#comprehesion

print(list(zip(names,ages)))
new_dict = {name: age for (name, age) in zip(names, ages)}
print(new_dict) 
'''
dict = {}
for i in range(1, 5):
  dict[i] = i * 2

print(dict)

dict_v2 = { i : i*2 for i in range(1, 5)}
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 = ['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)

referencias = dict(zip(nombres, edades))
print(referencias)

import random
""" dict comprehension """

# clasic
numbers = {}
for i in range(1, 6):
  numbers[i] = i * 3
print(numbers)

# dict comprenhension
numbers_v2 = {i: i * 3 for i in range(1, 6)}
print(numbers_v2)

print("-" * 35)

countries = ["ar", "bol", "col", "mex", "pe"]

# clasic
population = {}
for country in countries:
  population[country] = random.randint(50, 100)
print(population)

# dict comprehension
population_v2 = {country: random.randint(50, 100) for country in countries}
print(population_v2)

print("-" * 35)

names = ["Dolores", "Jashin", "Mifune", "Minos"]
ages = [21, 19, 23, 22]

# clasic
person = {}
for i in range(len(names)):
  person[names[i]] = ages[i]
print(person)

# list comprehension
person_v2 = {names[i]: ages[i] for i in range(len(names))}
print(person_v2)

# zip
"""a = zip(names, ages)
b = list(zip(names, ages))
c = tuple(zip(names, ages))"""
d = dict(zip(names, ages))

"""print(a)
print(b)
print(c)"""
print(d)

Este ejercicio me ayudo a entender como funciona, el cual consiste en crear un cliente para luego aplicar le un descuento de forma aleatoria con otro diccionario

import random
clientes = []
def registrar():
    rpt =0
    while rpt==0:
        cliente = input("Nombre del cliente")
        clientes.append(cliente)
        print(str(clientes))
        rpt = int(input("oprima 0 para ingresar otro nombre o otro numero para salir"))
def descuento():
    repetirr=0
    while repetirr ==0:

        diccionario_descuentos = {cliente: random.randint(1, 100) for cliente in clientes}
        print(diccionario_descuentos)
        repetirr= int(input("1 para salir "))
if __name__ == "__main__":
    repetir = 0
    while repetir==0:
        menu = """
                Registro de clientes
         
         1.Registrar clientes
         2.aplicar descuentos"""

        print(menu)
        opc = int(input("elija"))
        if opc == 1:
            registrar();
            repetir = int(input("0 para volver al menu"))
        if opc == 2:
            descuento();
        else:
            print("opcion no valida")

miembros = [鈥榙iego鈥, 鈥榤arce鈥, 鈥榮ara鈥, 鈥榚len鈥橾
edades = [39, 40, 14, 10]
print(list(zip(miembros, edades)))

familia = {miembros: edades for (miembros, edades) in zip(miembros, edades)}
print(familia)

Como nota, pueden observar los diferentes resultados seg煤n el tipo de conversi贸n

# Convertir a Lista
new_dict=list(zip(names,edades))
print(new_dict)

# Convertir a Tupla
new_dict=tuple(zip(names,edades))
print(new_dict)

# Convertir a Diccionario
new_dict= dict(zip(names,edades))
print(new_dict)

Dict Comprehension

#-----------------Dict Comprehension-----------------

# crear un diccionario con for
dict = {}
for i in range(1, 6):
  dict[i] = i*2

print(dict)
--> {1: 2, 2: 4, 3: 6, 4: 8, 5: 10}

# crear un diccionario con Comprehension
dict_2 = {i:i * 2 for i in range(1,6)}
print(dict_2)
--> {1: 2, 2: 4, 3: 6, 4: 8, 5: 10}

#crear un diccionario a partir de una lista
import random
countries = ['colombia', 'mexico', 'bolivia', 'venezuela']
population = {}

for country in countries:
  population[country] = random.randint(1,100)
print(population)
--> {'colombia': 74, 'mexico': 12, 'bolivia': 9, 'venezuela': 52}

#crear un diccionario a partir de una lista con comprehension
population_2 = { country: random.randint(1, 100) for country in countries}
print(population_2)
--> {'colombia': 11, 'mexico': 10, 'bolivia': 47, 'venezuela': 28}


#crear una dict comprehension a partir de dos listas
names = ['nico', 'miguel', 'angel', 'laura']
ages = [13,25,20,14]

#zip une dos listas y crea tuplas como elementos
print(list(zip(names, ages)))  
--> [('nico', 13), ('miguel', 25), ('angel', 20), ('laura', 14)]

new_dict = {name: age for (name, age) in zip(names, ages)}
print(new_dict)
--> {'nico': 13, 'miguel': 25, 'angel': 20, 'laura': 14}

Sintaxis de un Dict Comprehension

{key:value for var in iterable}
  Elemento          Ciclo donde se extraen elementos
llave-valor         de cualquier iterable

Ranking FIFA:

Este fue el ejemplo que intent茅 realizar, pero ten铆a una consulta: 驴c贸mo podr铆a hacer para que dentro del diccionario no me aparezcan con comillas?

Creo que esta es otra forma sencilla de generar el diccionario con la funci贸n zip a partir de 2 objetos iterables (en este caso las 2 listas):

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

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