Python Dictionaries 101: una introducción visual detallada

Bienvenidos

En este artículo, aprenderá a trabajar con diccionarios de Python, un tipo de datos integrado increíblemente útil que definitivamente utilizará en sus proyectos.

En particular, aprenderá:

  • Para qué se utilizan los diccionarios y sus principales características.
  • Por qué son importantes para sus proyectos de programación.
  • La "anatomía" de un diccionario: claves, valores y pares clave-valor.
  • Las reglas específicas que determinan si un valor puede ser una clave.
  • Cómo acceder, agregar, modificar y eliminar pares clave-valor.
  • Cómo comprobar si una clave está en un diccionario.
  • Lo que representa la longitud de un diccionario.
  • Cómo iterar sobre diccionarios usando bucles for.
  • Qué métodos de diccionario integrados puede utilizar para aprovechar el poder de este tipo de datos.

Al final de este artículo, nos sumergiremos en un proyecto simple para aplicar su conocimiento: escribiremos una función que crea y devuelve un diccionario con un propósito particular.

¡Vamos a empezar! ⭐️

? Diccionarios en contexto

Comencemos discutiendo la importancia de los diccionarios. Para ilustrar esto, permítame hacer una comparación rápida con otro tipo de datos con el que probablemente esté familiarizado: listas.

Cuando trabaja con listas en Python, puede acceder a un elemento usando un índice, un número entero que describe la posición del elemento en la lista. Los índices comienzan desde cero para el primer elemento y aumentan en uno para cada elemento posterior de la lista. Puedes ver un ejemplo aquí mismo:

Pero, ¿qué pasa si necesitamos almacenar dos valores relacionados y mantener esta "conexión" en nuestro código? En este momento, solo tenemos valores únicos e independientes almacenados en una lista.

Digamos que queremos almacenar los nombres de los estudiantes y "conectar" cada nombre con las calificaciones de cada estudiante en particular. Queremos mantener la "conexión" entre ellos. ¿Cómo harías eso en Python?

Si usa listas anidadas, las cosas se volverían muy complejas e ineficientes después de agregar solo algunos elementos porque necesitaría usar dos o más índices para acceder a cada valor, según la lista final. Aquí es donde los diccionarios de Python vienen al rescate.

Conoce los diccionarios

Un diccionario de Python se ve así (ver más abajo). Con un diccionario, puede "conectar" un valor a otro valor para representar la relación entre ellos en su código. En este ejemplo, "Gino" está "conectado" al número entero 15 y la cadena "Nora" está "conectada" al número entero 30.

Veamos los diferentes elementos que componen un diccionario.

? La "anatomía" de un diccionario de Python

Dado que un diccionario "conecta" dos valores, tiene dos tipos de elementos:

  • Claves: una clave es un valor que se utiliza para acceder a otro valor. Las claves son el equivalente de "índices" en cadenas, listas y tuplas. En los diccionarios, para acceder a un valor, se usa la clave, que es un valor en sí mismo.
  • Valores: son los valores a los que puedes acceder con su clave correspondiente.

Estos dos elementos forman lo que se llama un par clave-valor (una clave con su valor correspondiente).

Sintaxis

Este es un ejemplo de un diccionario de Python que asigna la cadena "Gino" al número 15 y la cadena "Nora" al número 30:

>>> {"Gino": 15, "Nora": 30}
  • Para crear un diccionario, usamos llaves{ } .
  • Entre estas llaves, escribimos pares clave-valor separados por una coma.
  • Para los pares clave-valor, escribimos la clave seguida de dos puntos, un espacio y el valor que corresponde a la clave.

? Consejos:

  • Por motivos de legibilidad y estilo, se recomienda agregar un espacio después de cada coma para separar los pares clave-valor.
  • Puede crear un diccionario vacío con un par de llaves vacías {}.

Reglas importantes para las llaves

No todos los valores pueden ser claves en un diccionario de Python. Las claves deben seguir un conjunto de reglas:

Según la documentación de Python:

  • Las claves deben ser únicas dentro de un diccionario.
Es mejor pensar en un diccionario como un conjunto de pares clave: valor , con el requisito de que las claves sean únicas (dentro de un diccionario).
  • Las claves deben ser inmutables.
A diferencia de las secuencias, que están indexadas por un rango de números, los diccionarios están indexados por claves , que pueden ser de cualquier tipo inmutable ; las cadenas y los números siempre pueden ser claves.
  • Si la clave es una tupla, solo puede contener cadenas, números o tuplas.
Las tuplas se pueden usar como claves si contienen solo cadenas, números o tuplas; si una tupla contiene algún objeto mutable, ya sea directa o indirectamente, no se puede utilizar como clave.
  • Las listas no pueden ser claves porque son mutables. Esta es una consecuencia de la regla anterior.
No puede usar listas como claves, ya que las listas se pueden modificar en su lugar usando asignaciones de índice, asignaciones de sectores o métodos como append()y extend().

? Nota: Los valores no tienen reglas específicas, pueden ser valores mutables o inmutables.  

? Diccionarios en acción

Ahora veamos cómo podemos trabajar con diccionarios en Python. Vamos a acceder, agregar, modificar y eliminar pares clave-valor.

Empezaremos a trabajar con este diccionario, asignado a la agesvariable:

>>> ages = {"Gino": 15, "Nora": 30}

Acceder a los valores mediante claves

If we need to access the value associated with a specific key, we write the name of the variable that references the dictionary followed by square brackets [] and, within the square brackets, the key that corresponds to the value:

[]

This is an example of how we can access the value that corresponds to the string "Gino":

>>> ages = {"Gino": 15, "Nora": 30} >>> ages["Gino"] 15

Notice that the syntax is very similar to indexing a string, tuple, or list, but now we are using the key as the index instead of an integer.

If we want to access the value that corresponds to "Nora", we would do this:

>>> ages = {"Gino": 15, "Nora": 30} >>> ages["Nora"] 30

? Tip: If you try to access a key that does not exist in the dictionary, you will get a KeyError:

>>> ages = {"Gino": 15, "Nora": 30} >>> ages["Talina"] Traceback (most recent call last): File "", line 1, in  ages["Talina"] KeyError: 'Talina'

Add Key-Value Pairs

If a key-value pair doesn't exist in the dictionary, we can add it. To do this, we write the variable that references the dictionary followed by the key within square brackets, an equal sign, and the new value:

This is an example in IDLE:

>>> ages = {"Gino": 15, "Nora": 30} # Add the key-value pair "Talina": 24 >>> ages["Talina"] = 24 # The dictionary now has this key-value pair >>> ages {'Gino': 15, 'Nora': 30, 'Talina': 24}

Modify a Key-Value Pair

To modify the value associated to a specific key, we use the same syntax that we use to add a new key-value pair, but now we will be assigning the new value to an existing key:

>>> ages = {"Gino": 15, "Nora": 30} # The key "Gino" already exists in the dictionary, so its associated value # will be updated to 45. >>> ages["Gino"] = 45 # The value was updated to 45. >>> ages {'Gino': 45, 'Nora': 30}

Deleting a Key-Value Pair

To delete a key-value pair, you would use the del keyword followed by the name of the variable that references the dictionary and, within square brackets [], the key of the key-value pair:

This is an example in IDLE:

>>> ages = {"Gino": 15, "Nora": 30, "Talina": 45} # Delete the key-value pair "Gino": 15. >>> del ages["Gino"] # The key-value pair was deleted. >>> ages {'Nora': 30, 'Talina': 45}

? Check if a Key is in a Dictionary

Sometimes, it can be very helpful to check if a key already exists in a dictionary (remember that keys have to be unique).

Según la documentación de Python:

Para comprobar si hay una sola clave en el diccionario, utilice la inpalabra clave.
>>> ages = {"Gino": 15, "Nora": 30, "Talina": 45} >>> "Talina" in ages True >>> "Gino" in ages True >>> "Lulu" in ages False

El inoperador comprueba las claves, no los valores. Si escribimos esto:

>>> 15 in ages False

Estamos comprobando si la clave 15 está en el diccionario, no el valor. Por eso la expresión se evalúa como False.

? Sugerencia: Puede usar el inoperador para verificar si un valor está en un diccionario con .values ​​().

>>> ages = {"Gino": 15, "Nora": 30, "Talina": 45} >>> 30 in ages.values() True >>> 10 in ages.values() False

? Longitud de un diccionario Python

La longitud de un diccionario es el número de pares clave-valor que contiene. Puede verificar la longitud de un diccionario con la función len () que usamos comúnmente, al igual que verificamos la longitud de listas, tuplas y cadenas:

# Two key-value pairs. Length 2. >>> ages = {"Gino": 15, "Nora": 30} >>> len(ages) 2 # Three key-value pairs. Length 3. >>> ages = {"Gino": 15, "Nora": 30, "Talina": 45} >>> len(ages) 3

? Iterando sobre diccionarios en Python

You can iterate over dictionaries using a for loop. There are various approaches to do this and they are all equally relevant. You should choose the approach that works best for you, depending on what you are trying to accomplish.

First Option - Iterate over the Keys

We can iterate over the keys of a dictionary like this:

for  in : # Do this

For example:

>>> ages = {"Gino": 15, "Nora": 30, "Talina": 45} >>> for student in ages: print(student) Gino Nora Talina

Second Option - Iterate over the Key-Value Pairs

To do this, we need to use the built-in method .items(), which allows us to iterate over the key-value pairs as tuples of this format (key, value).

for  in .items(): # Do this

For example:

>>> ages = {"Gino": 15, "Nora": 30, "Talina": 45} >>> for pair in ages.items(): print(pair) ('Gino', 15) ('Nora', 30) ('Talina', 45)

Third Option - Assign Keys and Values to Individual Variables

With .items() and for loops, you can use the power of a tuple assignment to directly assign the keys and values to individual variables that you can use within the loop:

>>> ages = {"Gino": 15, "Nora": 30, "Talina": 45} # Tuple assignment to assign the key to the variable key # and the value to the variable value. >>> for key, value in ages.items(): print("Key:", key, "; Value:", value) Key: Gino ; Value: 15 Key: Nora ; Value: 30 Key: Talina ; Value: 45

Fourth Option - Iterate over the Values

You can iterate over the values of a dictionary using the .values() method.

>>> ages = {"Gino": 15, "Nora": 30, "Talina": 45} >>> for age in ages.values(): print(age) 15 30 45

? Dictionary Methods

Dictionaries include very helpful built-in methods that can save you time and work to perform common functionality:

.clear()

This method removes all the key-value pairs from the dictionary.

>>> ages = {"Gino": 15, "Nora": 30, "Talina": 45} >>> ages.clear() >>> ages {}

.get(, )

This method returns the value associated with the key. Otherwise, it returns the default value that was provided as the second argument (this second argument is optional).

>>> ages = {"Gino": 15, "Nora": 30, "Talina": 45} >>> ages.get("Nora") 30 >>> ages.get("Nor", "Not Found") 'Not Found'

If you don't add a second argument, this is equivalent to the previous syntax with square brackets []that you learned:

>>> ages = {"Gino": 15, "Nora": 30, "Talina": 45} >>> ages["Nora"] 30 >>> ages.get("Nora") 30

.pop(, )

This method removes the key-value pair from the dictionary and returns the value.

>>> ages = {"Gino": 15, "Nora": 30, "Talina": 45} >>> ages.pop("Talina") 45 >>> ages {'Gino': 15, 'Nora': 30}

.update()

This method replaces the values of a dictionary with the values of another dictionary only for those keys that exist in both dictionaries.

An example of this would be a dictionary with the original grades of three students (see code below). We only want to replace the grades of the students who took the make-up exam (in this case, only one student took the make-up exam, so the other grades should remain unchanged).

>>> grades = {"Gino": 0, "Nora": 98, "Talina": 99} >>> new_grades = {"Gino": 67} >>> grades.update(new_grades) >>> grades {'Gino': 67, 'Nora': 98, 'Talina': 99}

By using the .update() method, we could update the value associated with the string "Gino" in the original dictionary since this is the only common key in both dictionaries.

The original value would be replaced by the value associated with this key in the dictionary that was passed as argument to .update().

? Tips: To learn more about dictionary methods, I recommend reading this article in the Python Documentation.

? Mini Project - A Frequencies Dictionary

Now you will apply your knowledge by writing a function freq_dict that creates and returns a dictionary with the frequency of each element of a list, string, or tuple (the number of times the element appears). The elements will be the keys and the frequencies will be the values.

Code

We will be writing the function step-by-step to see the logic behind each line of code.

  • Step 1: The first thing that we need to do is to write the function header. Notice that this function only takes one argument, the list, string or tuple, which we call data.
def freq_dict(data):
  • Step 2: Then, we need to create an empty dictionary that will map each element of the list, string, or tuple to its corresponding frequency.
def freq_dict(data): freq = {}
  • Step 3: Then, we need to iterate over the list, string, or tuple to determine what to do with each element.
def freq_dict(data): freq = {} for elem in data: 
  • Step 4: If the element has already been included in the dictionary, then the element appears more than once and we need to add 1 to its current frequency. Else, if the element is not in the dictionary already, it's the first time it appears and its initial value should be 1.
def freq_dict(data): freq = {} for elem in data: if elem in freq: freq[elem] += 1 else: freq[elem] = 1
  • Step 5: Finally, we need to return the dictionary.
def freq_dict(data): freq = {} for elem in data: if elem in freq: freq[elem] += 1 else: freq[elem] = 1 return freq

❗️Important: Since we are assigning the elements as the keys of the dictionary, they have to be of an immutable data type.

Examples

Here we have an example of the use of this function. Notice how the dictionary maps each character of the string to how many times it occurs.

>>> def freq_dict(data): freq = {} for elem in data: if elem in freq: freq[elem] += 1 else: freq[elem] = 1 return freq >>> freq_dict("Hello, how are you?") {'H': 1, 'e': 2, 'l': 2, 'o': 3, ',': 1, ' ': 3, 'h': 1, 'w': 1, 'a': 1, 'r': 1, 'y': 1, 'u': 1, '?': 1}

This is another example applied to a list of integers:

>>> def freq_dict(data): freq = {} for elem in data: if elem in freq: freq[elem] += 1 else: freq[elem] = 1 return freq >>> freq_dict([5, 2, 6, 2, 6, 5, 2, 2, 2]) {5: 2, 2: 5, 6: 2}

Great Work! Now we have the final function.

? In Summary

  • Dictionaries are built-in data types in Python that associate (map) keys to values, forming key-value pairs.
  • You can access a value with its corresponding key.  
  • Keys have to be of an immutable data type.
  • You can access, add, modify, and delete key-value pairs.
  • Dictionaries offer a wide variety of methods that can help you perform common functionality.

I really hope you liked my article and found it helpful. Now you can work with dictionaries in your Python projects. Check out my online courses. Follow me on Twitter. ⭐️