Diccionarios en Python: cómo crearlos, recorrerlos y usarlos bien

Introducción: La navaja suiza de Python

Si has estado programando en Python por más de una semana, seguramente te has encontrado con ellos. Los diccionarios (o dict en Python) son, sin lugar a dudas, una de las estructuras de datos más potentes, flexibles y utilizadas en todo el ecosistema de este lenguaje. Si las listas son la columna vertebral de Python, los diccionarios son su cerebro.

Un diccionario en Python es una colección desordenada, modificable e indexada de elementos. A diferencia de las listas o tuplas, que están indexadas por un rango de números, los diccionarios están indexados por claves (keys). Esto significa que almacenan datos en pares de clave-valor, de forma muy similar a cómo un diccionario real asocia una palabra con su definición, o cómo un objeto JSON estructura la información.

En este artículo, vamos a desmenuzar los diccionarios desde sus fundamentos más básicos hasta las técnicas avanzadas que los verdaderos profesionales de Python utilizan en su día a día.

1. Creación de diccionarios: Múltiples caminos hacia un mismo destino

Existen diversas formas de inicializar un diccionario en Python, dependiendo de cómo recibas los datos y tus preferencias de sintaxis.

Usando llaves {}

Esta es la forma más literal y común. Separas las claves y los valores con dos puntos (:) y cada par con una coma.

usuario = {
    "nombre": "Ana",
    "edad": 28,
    "profesion": "Ingeniera de Software",
    "activo": True
}

Nota sobre las claves: Las claves de un diccionario deben ser inmutables. Puedes usar strings, números o tuplas, pero nunca listas ni otros diccionarios.

Usando el constructor dict()

Muy útil cuando quieres que tu código se lea de manera más limpia, evitando el uso excesivo de comillas en las claves (siempre que las claves sean strings alfanuméricos válidos).

usuario = dict(nombre="Ana", edad=28, profesion="Ingeniera de Software", activo=True)

Desde listas de tuplas

Si tienes los datos en otro formato, como una lista de tuplas (algo común al procesar datos de una base de datos), puedes convertirla fácilmente.

datos = [("manzanas", 5), ("naranjas", 12), ("uvas", 30)]
inventario = dict(datos)
# inventario ahora es {'manzanas': 5, 'naranjas': 12, 'uvas': 30}

2. Accediendo a los valores: El arte de extraer información

Una vez que tienes tu diccionario, el siguiente paso lógico es leer su información.

Acceso directo con corchetes []

Es la forma más rápida, pero tiene un riesgo: si la clave no existe, Python lanzará un error fatal KeyError, deteniendo la ejecución de tu programa.

print(usuario["nombre"])  # Imprime: Ana
# print(usuario["apellido"]) # ¡KeyError!

El método seguro: .get()

Este es el estándar de la industria. Si la clave no existe, en lugar de romper el programa, devuelve None. Además, puedes especificar un valor por defecto.

apellido = usuario.get("apellido") # Devuelve None
apellido_seguro = usuario.get("apellido", "No especificado") # Devuelve "No especificado"

3. Modificando y añadiendo elementos

Los diccionarios son mutables, lo que significa que pueden cambiar de tamaño y contenido en tiempo de ejecución.

Actualización individual

Simplemente asignas un valor a una clave. Si la clave ya existe, sobrescribe el valor; si no existe, crea el nuevo par clave-valor.

usuario["edad"] = 29  # Modifica un valor existente
usuario["ciudad"] = "Madrid"  # Añade un nuevo par

Actualización masiva: .update()

Si necesitas añadir múltiples pares de una sola vez o fusionar otro diccionario, update() es tu mejor amigo.

nuevos_datos = {
    "edad": 30, # Esto sobrescribirá la edad anterior
    "github": "ana_dev",
    "nivel": "Senior"
}
usuario.update(nuevos_datos)

4. Eliminando elementos: Manteniendo el orden

Saber borrar datos es tan importante como saber insertarlos. Python te ofrece varias herramientas para limpiar tus diccionarios.

Usando la palabra reservada del

Elimina la clave y su valor. Lanza KeyError si la clave no existe.

del usuario["nivel"]

El método .pop()

Extrae el valor y elimina la clave del diccionario. Es increíblemente útil si necesitas el valor una última vez antes de destruirlo. También permite un valor por defecto para evitar errores.

ciudad = usuario.pop("ciudad", "Ciudad desconocida")

El método .popitem()

Elimina y devuelve el último par clave-valor que fue insertado en el diccionario (en forma de tupla). (A partir de Python 3.7, los diccionarios mantienen el orden de inserción).

ultimo_elemento = usuario.popitem()

5. Recorriendo diccionarios: Bucles for como un profesional

Iterar sobre diccionarios es el pan de cada día de cualquier programador Python. Tienes tres perspectivas principales para iterar.

Iterar por Claves (Keys)

Es el comportamiento por defecto cuando usas un bucle for directamente sobre el diccionario, aunque puedes usar .keys() para ser explícito.

for clave in usuario:
    print(clave)
    
# Equivalente y más legible:
for clave in usuario.keys():
    print(clave)

Iterar por Valores (Values)

Si las claves no te importan y solo quieres los datos.

for valor in usuario.values():
    print(valor)

Iterar por Claves y Valores a la vez (Items)

Esta es, de lejos, la forma más utilizada y la más "Pythónica". El método .items() devuelve tuplas que podemos desempaquetar directamente en el bucle for.

for clave, valor in usuario.items():
    print(f"La clave es {clave} y el valor es {valor}")

6. Diccionarios anidados: Estructuras de datos complejas

Los valores de un diccionario pueden ser cualquier tipo de dato en Python... incluyendo otros diccionarios o listas. Esto te permite modelar datos jerárquicos estructurados, idénticos a los documentos JSON.

empresa = {
    "nombre": "TechCorp",
    "empleados": {
        "dev_01": {"nombre": "Ana", "rol": "Backend"},
        "dev_02": {"nombre": "Luis", "rol": "Frontend"}
    },
    "tecnologias": ["Python", "Django", "React"]
}

# Accediendo a datos anidados:
rol_luis = empresa["empleados"]["dev_02"]["rol"]
print(rol_luis) # Imprime: Frontend

7. Fusión de diccionarios (Merging): Python 3.9+

A partir de la versión 3.9, Python introdujo el operador de unión (|), haciendo que la fusión de diccionarios sea excepcionalmente limpia, evitando el uso del unpacking ** o el método update cuando quieres crear un nuevo diccionario.

config_default = {"theme": "light", "port": 8080}
config_usuario = {"theme": "dark", "debug": True}

# Fusionando (el diccionario de la derecha tiene prioridad sobre el de la izquierda)
config_final = config_default | config_usuario
print(config_final) # {'theme': 'dark', 'port': 8080, 'debug': True}

8. Dictionary Comprehensions: Magia en una sola línea

Al igual que las List Comprehensions, Python permite crear diccionarios dinámicamente en una sola línea de código, aplicando lógica y filtrado.

numeros = [1, 2, 3, 4, 5]
# Crear un diccionario donde la clave es el número y el valor es su cuadrado
cuadrados = {n: n**2 for n in numeros}
# {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# Con condicionales (solo pares)
cuadrados_pares = {n: n**2 for n in numeros if n % 2 == 0}

9. Técnicas Avanzadas: El módulo collections

Para casos de uso específicos, la biblioteca estándar de Python nos regala herramientas especializadas que heredan de los diccionarios.

defaultdict

Importado desde collections, te salva de escribir comprobaciones para ver si una clave existe antes de modificarla. Si la clave no existe, se crea automáticamente con un valor por defecto (como un int 0, o una lista vacía).

from collections import defaultdict

# Contar frecuencias de letras
palabra = "programacion"
conteo = defaultdict(int)

for letra in palabra:
    conteo[letra] += 1  # No necesitamos comprobar si la letra ya existe en el dict

Counter

Aún mejor para el ejemplo anterior. Counter está diseñado específicamente para contar elementos iterables.

from collections import Counter

frecuencias = Counter("programacion")
print(frecuencias.most_common(2)) # Imprime las 2 letras más comunes

Conclusión

Los diccionarios son, fundamentalmente, tablas Hash altamente optimizadas bajo el capó (escritas en C para CPython). Esto les otorga una complejidad de tiempo de O(1) para buscar, añadir o borrar elementos. En términos simples: son extremadamente rápidos y eficientes.

Dominar los diccionarios, saber cuándo usar .get(), cómo iterar con .items() y aprovechar el módulo collections, es la diferencia entre escribir código que simplemente "funciona" y escribir código elegante, robusto y verdaderamente "Pythónico". Sigue practicando estas operaciones y pronto estructurarás tus datos como un profesional.