Tutorial de comprensión del diccionario Python

Diccionario Python

Un diccionario en Python es una colección de elementos a los que se accede por una clave concreta en lugar de por un índice. ¿Qué significa esto?

Imagina un diccionario en el mundo real... cuando necesitas buscar el significado de una palabra, intentas encontrar el significado utilizando la propia palabra y no el posible índice de la palabra. Los diccionarios de Python funcionan con el mismo concepto, la palabra cuyo significado buscas es la clave, y el significado de la palabra es el valor; no necesitas conocer el índice de la palabra en un diccionario para encontrar su significado.

Inicializar un diccionario en Python

Puedes inicializar un diccionario en Python de esta forma:

a = {'apple': 'fruit', 'beetroot': 'vegetable', 'cake': 'dessert'}
a['doughnut'] = 'snack'
print(a['apple'])

fruit

print(a[0])

---------------------------------------------------------------------------

KeyError                                  Traceback (most recent call last)

<ipython-input-9-00d4a978143a> in <module>()
----> 1 print(a[0])


KeyError: 0

En primer lugar, creamos un diccionario llamado a que tiene tres pares key-value: 'apple': 'fruit', 'beetroot': 'vegetable', y 'cake': 'dessert'. Las claves son cadenas que representan los nombres de los artículos, y los valores son cadenas que representan el tipo o categoría del artículo.

A continuación añadimos un nuevo par key-value al diccionario a utilizando la sintaxis a['doughnut'] = 'snack'. Esto añade la clave 'doughnut' al diccionario con el valor correspondiente 'snack'.

La tercera línea del código imprime el valor asociado a la clave 'apple' en el diccionario a. Como 'apple' es una clave del diccionario, el código imprime el valor 'fruit'.

La cuarta línea del código intenta imprimir el valor asociado a la clave 0 en el diccionario a, que no es una clave válida en el diccionario. Esto provoca un KeyError, que se produce al intentar acceder a una clave que no existe en un diccionario.

Tipos de datos del diccionario de Python

Los elementos de un diccionario pueden tener cualquier tipo de datos. Echa un vistazo a otros ejemplos de diccionario para hacerte una idea:

Crea un diccionario a con cuatro pares key-value:

a = {'one': 1, 'two': 'to', 'three': 3.0, 'four': [4,4.0]}
print(a)

{'four': [4, 4.0], 'two': 'to', 'three': 3.0, 'one': 1}

Actualiza el valor asociado a la clave 'one' del diccionario a a 1,0.

# Update a dictionary
a['one'] = 1.0 
print(a)

{'four': [4, 4.0], 'two': 'to', 'three': 3.0, 'one': 1.0}

Elimina el par key-value asociado a la clave 'one' del diccionario a.

# Delete a single element
del a['one'] 
print(a)

{'four': [4, 4.0], 'two': 'to', 'three': 3.0}

Elimina todos los pares key-value del diccionario a utilizando el método clear().

# Delete all elements in the dictionary
a.clear()
print(a)

{}

Borra el diccionario a utilizando la palabra clave del.

# Delete the dictionary
del a 
print(a)

---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-12-701c9d6596da> in <module>()
      1 del a #Deletes the dictionary
----> 2 print(a)


NameError: name 'a' is not defined

Es importante recordar que una clave tiene que ser única en un diccionario; no se permiten duplicados. Sin embargo, en caso de claves duplicadas, en lugar de dar un error, Python tomará como válida la última instancia de la clave y simplemente ignorará el primer par key-value. Compruébalo tú mismo:

sweet_dict = {'a1': 'cake', 'a2':'cookie', 'a1': 'icecream'}
print(sweet_dict['a1'])

icecream

Comprensión del diccionario Python

La comprensión de diccionarios es un método para transformar un diccionario en otro diccionario. Durante esta transformación, los elementos del diccionario original pueden incluirse condicionalmente en el nuevo diccionario, y cada elemento puede transformarse según sea necesario.

Una buena comprensión de listas puede hacer que tu código sea más expresivo y, por tanto, más fácil de leer. La clave para crear comprensiones es no dejar que sean tan complejas que tu cabeza dé vueltas cuando intentes descifrar lo que están haciendo en realidad. Ten presente la idea de que sea "fácil de leer".

La forma de crear comprensión de diccionario en Python es poder acceder a los objetos key y a los objetos value de un diccionario.

¿Cómo puede hacerse?

¡Python te ayuda! Puedes utilizar simplemente los métodos incorporados para ello:

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
# Put all keys of `dict1` in a list and returns the list
dict1.keys()

dict_keys(['c', 'd', 'a', 'b'])

# Put all values saved in `dict1` in a list and returns the list
dict1.values()

dict_values([3, 4, 1, 2])

El código anterior crea un diccionario Python llamado dict1 con cuatro pares key-value. Se llama al método keys() sobre el diccionario, que devuelve un objeto vista que contiene todas las claves del diccionario.

También se llama al método values() sobre el diccionario, que devuelve un objeto vista que contiene todos los valores del diccionario.

Ambos objetos de vista se comportan como conjuntos y pueden utilizarse para realizar operaciones de conjunto sobre las claves y los valores, respectivamente.

Ten en cuenta que no se garantiza que el orden de las claves y valores en los objetos de la vista sea el mismo que el orden en que se añadieron al diccionario.

Utilizar el método items()

Así que, ahora que ya sabes cómo acceder a todas las claves y sus valores en un diccionario. También puedes acceder a cada par key-value dentro de un diccionario utilizando el método items():

dict1.items()

dict_items([('c', 3), ('d', 4), ('a', 1), ('b', 2)])

Esta es la plantilla general que puedes seguir para la comprensión de diccionarios en Python:

dict_variable = {key:value for (key,value) in dictonary.items()}

Esto puede servir como plantilla básica y la más sencilla. Esto puede volverse cada vez más complejo a medida que le añades condicionalidades.

Ejemplo básico de comprensión de diccionario Python

Empecemos con una simple comprensión de diccionario:

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
# Double each value in the dictionary
double_dict1 = {k:v*2 for (k,v) in dict1.items()}
print(double_dict1)

{'e': 10, 'a': 2, 'c': 6, 'b': 4, 'd': 8}

En el código de comprensión anterior, creamos un nuevo diccionario double_dict1 a partir de un diccionario dict1, simplemente duplicando cada valor que contiene.

También puedes modificar los valores de las claves. Por ejemplo, creemos el mismo diccionario que antes, pero cambiemos también los nombres de las claves.

dict1_keys = {k*2:v for (k,v) in dict1.items()}
print(dict1_keys)

{'dd': 4, 'ee': 5, 'aa': 1, 'bb': 2, 'cc': 3}

¿Por qué utilizar la comprensión del diccionario?

La comprensión de diccionarios es un concepto potente y puede utilizarse para sustituir los bucles for y las funciones lambda. Sin embargo, no todos los for loops pueden escribirse como una comprensión de diccionario, pero toda comprensión de diccionario puede escribirse con un for loop.

Considera el siguiente problema, en el que quieres crear un nuevo diccionario cuya clave es un número divisible por 2 en un rango de 0-10, y su valor es el cuadrado del número.

Veamos cómo puedes resolver el mismo problema utilizando un for loop y la comprensión del diccionario:

numbers = range(10)
new_dict_for = {}

# Add values to `new_dict` using for loop
for n in numbers:
    if n%2==0:
        new_dict_for[n] = n**2

print(new_dict_for)

{0: 0, 8: 64, 2: 4, 4: 16, 6: 36}

# Use dictionary comprehension
new_dict_comp = {n:n**2 for n in numbers if n%2 == 0}

print(new_dict_comp)

{0: 0, 8: 64, 2: 4, 4: 16, 6: 36}

Alternativa a for loops

Los for loops se utilizan para repetir una determinada operación o un bloque de instrucciones de un programa un número determinado de veces. Sin embargo, los for loops anidados (for loop dentro de otro for loop) pueden resultar confusos y complejos. Las comprensiones de diccionario son mejores en estas situaciones y pueden simplificar la legibilidad y tu comprensión del código.

Consejo: consulta el tutorial de DataCamp Loops en Python para obtener más información sobre los bucles en Python.

Alternativa a funciones lambda

Las funciones lambda son una forma de crear pequeñas funciones anónimas. Son funciones sin nombre. Estas funciones son funciones de usar y tirar, que sólo se necesitan donde se han creado. Las funciones lambda se utilizan principalmente en combinación con las funciones filter(), map() y reduce().

Veamos la función lambda junto con la función map():

# Initialize `fahrenheit` dictionary 
fahrenheit = {'t1':-30, 't2':-20, 't3':-10, 't4':0}

#Get the corresponding `celsius` values
celsius = list(map(lambda x: (float(5)/9)*(x-32), fahrenheit.values()))

#Create the `celsius` dictionary
celsius_dict = dict(zip(fahrenheit.keys(), celsius))

print(celsius_dict)

{'t2': -28.88888888888889, 't3': -23.333333333333336, 't1': -34.44444444444444, 't4': -17.77777777777778}

Ejemplo de comprensión del diccionario Python

Veamos otra situación en la que quieras convertir un diccionario de temperaturas Fahrenheit a celsius.

Desglosemos el código: primero, tienes que definir una fórmula matemática que haga la conversión de Fahrenheit a Celsius.

En el código, esto se hace con ayuda de la función lambda. A continuación, pasas esta función como argumento a la función map(), que aplica la operación a cada elemento de la lista fahrenheit.values().

¿Recuerdas la función values()? Devuelve una lista que contiene los elementos almacenados en el diccionario.

Lo que tienes ahora es una lista que contiene el valor de la temperatura en grados centígrados, pero la solución requiere que sea un diccionario.

Python tiene una función incorporada llamada zip() que recorre los elementos de los iteradores y los agrega. Puedes leer más sobre la función zip() en este ejemplo de Python.

En nuestro ejemplo anterior, la función zip agrega el elemento de fahrenheit.keys() y la lista celsius, dando un par key-value que puedes juntar en un diccionario utilizando la función dict, que es el resultado deseado.

Ahora, intentemos resolver el mismo problema utilizando la comprensión del diccionario:

# Initialize the `fahrenheit` dictionary 
fahrenheit = {'t1': -30,'t2': -20,'t3': -10,'t4': 0}

# Get the corresponding `celsius` values and create the new dictionary
celsius = {k:(float(5)/9)*(v-32) for (k,v) in fahrenheit.items()}

print(celsius_dict)

{'t2': -28.88888888888889, 't3': -23.333333333333336, 't1': -34.44444444444444, 't4': -17.77777777777778}

Aquí tienes un desglose de lo que hemos creado en el código anterior: 

1. Crea un diccionario llamado fahrenheit con cuatro pares key-value que representen lecturas de temperatura en grados Fahrenheit.
2. Define un nuevo diccionario llamado celsius.
3. Utiliza una comprensión de diccionario para iterar sobre el diccionario fahrenheit y convertir las lecturas de temperatura Fahrenheit a Celsius utilizando la fórmula (5/9) * (F-32).
4. Para cada par key-value en fahrenheit, la clave se asigna a la variable k y el valor se asigna a la variable v.
5. El valor de la temperatura Celsius correspondiente a cada temperatura Fahrenheit se calcula utilizando la fórmula anterior y se añade como par key-value al diccionario celsius.
6. El diccionario celsius resultante se imprime en la consola.

Como puedes ver, el problema se puede resolver con una sola línea de código utilizando la comprensión del diccionario, en comparación con el proceso de dos pasos y la comprensión del funcionamiento de tres funciones (lambda, map() y zip()) para la primera implementación.

Además, la solución es intuitiva y fácil de entender con la comprensión del diccionario. Por tanto, la comprensión de diccionarios puede ser una buena alternativa a las funciones lambda.

Añadir condicionales a la comprensión del diccionario

A menudo necesitas añadir condiciones a una solución mientras abordas los problemas. Exploremos cómo puedes añadir condicionales a la comprensión del diccionario para hacerla más potente.

Condición If

Supongamos que necesitas crear un nuevo diccionario a partir de un diccionario dado, pero con elementos mayores que 2. Esto significa que tienes que añadir una condición a la plantilla original que has visto antes...

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

# Check for items greater than 2
dict1_cond = {k:v for (k,v) in dict1.items() if v>2}

print(dict1_cond)

{'e': 5, 'c': 3, 'd': 4}

¡No es tan difícil! Pero, ¿y si tienes varias condiciones?

Múltiples condiciones If

En el problema anterior, ¿qué pasa si no sólo tienes que obtener los elementos mayores que 2, sino que también tienes que comprobar si son múltiplos de 2 al mismo tiempo?

dict1_doubleCond = {k:v for (k,v) in dict1.items() if v>2 if v%2 == 0}
print(dict1_doubleCond)

{'d': 4}

La solución para añadir múltiples condicionales es tan fácil como añadir las condiciones una tras otra en tu comprensión. Sin embargo, debes tener cuidado con lo que intentas hacer en el problema. Recuerda que las sentencias if consecutivas funcionan como si tuvieran cláusulas and entre ellas.

Veamos un ejemplo más con tres condicionales:

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f':6}

dict1_tripleCond = {k:v for (k,v) in dict1.items() if v>2 if v%2 == 0 if v%3 == 0}

print(dict1_tripleCond)

{'f': 6}

En un for loop, esto corresponderá a:

dict1_tripleCond = {}

for (k,v) in dict1.items():
    if (v>=2 and v%2 == 0 and v%3 == 0):
            dict1_tripleCond[k] = v

print(dict1_tripleCond)

{'f': 6}

Condiciones If-Else

Tratar una condición if-else también es fácil con la comprensión del diccionario. Mira el siguiente ejemplo para verlo por ti mismo:

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f':6}

# Identify odd and even entries
dict1_tripleCond = {k:('even' if v%2==0 else 'odd') for (k,v) in dict1.items()}

print(dict1_tripleCond)

{'f': 'even', 'c': 'odd', 'b': 'even', 'd': 'even', 'e': 'odd', 'a': 'odd'}

Comprensión de diccionario anidado

La anidación es un concepto de programación en el que los datos se organizan en capas, o en el que los objetos contienen otros objetos similares. Seguro que has visto a menudo una estructura 'if' anidada, que es una condición 'if' dentro de otra condición 'if'.

Del mismo modo, los diccionarios pueden anidarse y, por tanto, también sus comprensiones. Veamos qué significa esto:

nested_dict = {'first':{'a':1}, 'second':{'b':2}}
float_dict = {outer_k: {float(inner_v) for (inner_k, inner_v) in outer_v.items()} for (outer_k, outer_v) in nested_dict.items()}
print(float_dict)

{'first': {1.0}, 'second': {2.0}}

Este es un ejemplo de diccionario anidado. nested_dict es un diccionario con las claves: first y second, que contienen objetos de diccionario en sus valores. El código trabaja con los valores internos del diccionario y los convierte a flotante, y luego combina las claves externas con los nuevos valores internos flotantes en un nuevo diccionario.

El código también tiene una comprensión de diccionario anidada, que es una comprensión de diccionario dentro de otra. La comprensión del diccionario, cuando está anidada, puede llegar a ser bastante difícil de leer, así como de entender, lo que le quita todo el sentido al uso de las comprensiones en primer lugar.

A medida que la estructura del diccionario con el que trabajas se complica, la comprensión del diccionario también empieza a complicarse. En tales situaciones, quizá sea mejor que no utilices comprensiones complicadas en tu código.

Ten en cuenta que puedes reescribir el trozo de código anterior también con un for loop anidado:

nested_dict = {'first':{'a':1}, 'second':{'b':2}}

for (outer_k, outer_v) in nested_dict.items():
    for (inner_k, inner_v) in outer_v.items():
        outer_v.update({inner_k: float(inner_v)})
nested_dict.update({outer_k:outer_v})

print(nested_dict)

{'first': {'a': 1.0}, 'second': {'b': 2.0}}

Reflexiones finales

Esperamos que ahora hayas aprendido sobre los diccionarios en Python, el concepto de comprensión y por qué y dónde puede ser útil la comprensión de diccionarios en Python. 

¡La práctica mejora tu Python! Echa un vistazo a algunos de nuestros mejores consejos y trucos de Python para mejorar tu código, o sigue nuestro programa de habilidades de Python para dominar más los fundamentos.