Diccionarios en Python: crear, acceder, actualizar e iterar dict

Un diccionario es una tabla de búsqueda

Las listas se indexan por posición. Los diccionarios se indexan por clave — normalmente un string o un número — y cada clave mapea a un valor. Ese cambio solo desbloquea una categoría enorme de programas: inventarios, configuraciones, payloads JSON, perfiles de usuario, cachés.

prices = {
    "apple": 0.50,
    "bread": 2.00,
    "milk": 1.20,
}

print(prices["apple"])
print(prices["bread"])

Las claves y los valores pueden ser casi cualquier cosa. Las claves deben ser hasheables (así que: números, strings, tuplas; no listas u otros dicts). Los valores no tienen restricción — un dict puede contener cualquier cosa, incluidos otros dicts o listas.

Crear diccionarios

Varias formas, cada una con su sitio:

# Literal con llaves
user = {"name": "Rosa", "age": 30, "city": "Lisbon"}
print(user)

# Dict vacío, construido con el tiempo
counts = {}
counts["a"] = 1
counts["b"] = 2
print(counts)

# Desde una lista de pares (clave, valor)
pairs = [("one", 1), ("two", 2), ("three", 3)]
mapping = dict(pairs)
print(mapping)

# Con argumentos por palabra clave
config = dict(host="localhost", port=8080, debug=True)
print(config)

Leer valores

Dos formas, y la elección importa:

prices = {"apple": 0.50, "bread": 2.00}

# [] — indexación directa. KeyError si no está.
print(prices["apple"])

# .get() — devuelve None (o un default) si no está.
print(prices.get("milk"))              # None
print(prices.get("milk", 0.00))        # 0.00

Elige por intención:

• Usa [] cuando la clave deba estar. Si no está, es un bug y quieres el error ruidoso.
• Usa .get() cuando "no presente" sea un caso válido. Te deja escribir valores por defecto sin try/except.

Añadir, actualizar, borrar

Asignar a una clave la crea o la actualiza:

prices = {"apple": 0.50, "bread": 2.00}

prices["milk"] = 1.20        # clave nueva
prices["apple"] = 0.60       # clave existente, sobrescrita

print(prices)

del prices["bread"]          # quita una clave; KeyError si no está
print(prices)

gone = prices.pop("apple")   # quita y devuelve; acepta un default
print("was:", gone, "now:", prices)

# pop con default para que no lance
prices.pop("missing", None)

update() fusiona otro dict o iterable de pares:

settings = {"theme": "dark", "font": "mono"}
overrides = {"font": "sans", "zoom": 1.2}

settings.update(overrides)
print(settings)

Las claves compartidas en overrides sobrescriben las de settings.

Comprobar una clave

in comprueba las claves, no los valores:

user = {"name": "Rosa", "age": 30}

print("name" in user)      # True
print("email" in user)     # False
print("Rosa" in user)      # False — eso es un valor, no una clave

Para comprobar valores específicamente, usa user.values():

print(30 in user.values())

Cómo iterar un diccionario

Tienes tres vistas sobre las que puedes iterar:

scores = {"ada": 90, "rosa": 85, "malik": 78}

# Claves (el valor por defecto)
for name in scores:
    print(name)

# Valores
for score in scores.values():
    print(score)

# Ambos — el caso común
for name, score in scores.items():
    print(f"{name}: {score}")

.items() es lo que usarás la mayor parte del tiempo — te da el par, desempaquetado, listo para usar.

El orden de iteración en Python moderno (3.7+) coincide con el orden de inserción. Un dict no es una "bolsa mágica" — si añades a, luego b, luego c, iterar los devuelve en ese orden. Es una garantía del lenguaje en la que puedes confiar.

Cómo ordenar un diccionario

Los diccionarios preservan el orden de inserción, así que "ordenar" un dict realmente significa construir un nuevo dict cuyas claves se insertan en el orden que quieres:

scores = {"rosa": 85, "ada": 90, "malik": 78}

# Ordenar por clave
by_key = dict(sorted(scores.items()))
print(by_key)

# Ordenar por valor (ascendente)
by_value = dict(sorted(scores.items(), key=lambda item: item[1]))
print(by_value)

# Ordenar por valor, descendente
top = dict(sorted(scores.items(), key=lambda item: item[1], reverse=True))
print(top)

sorted() devuelve una lista de pares; envolver eso en dict(...) reconstruye un diccionario con el nuevo orden. Si solo necesitas los pares ordenados (no un dict), sáltate la llamada externa a dict().

Cómo fusionar dos diccionarios

Python 3.9+ te da el operador |:

defaults = {"theme": "dark", "font": "mono"}
overrides = {"font": "sans", "zoom": 1.2}

merged = defaults | overrides
print(merged)

Los valores del dict de la derecha ganan en colisiones de clave. .update() es el equivalente in-place. En versiones más antiguas de Python, usa {**defaults, **overrides}.

El patrón setdefault

Una necesidad común: "si la clave está, usa su valor; si no, pon un default y úsalo".

counts = {}

for word in ["one", "two", "one", "three", "two", "one"]:
    counts.setdefault(word, 0)
    counts[word] += 1

print(counts)

O, mejor, usa collections.Counter:

from collections import Counter

words = ["one", "two", "one", "three", "two", "one"]
print(Counter(words))

Counter es una subclase de dict que cuenta por defecto. Es la elección correcta siempre que estés contando apariciones.

Dict comprehensions

Paralelas a las list comprehensions, pero para construir dicts:

numbers = [1, 2, 3, 4, 5]
squares = {n: n * n for n in numbers}
print(squares)

# Invertir un dict (las claves se vuelven valores y viceversa)
prices = {"apple": 0.50, "bread": 2.00}
lookup = {v: k for k, v in prices.items()}
print(lookup)

Mismas reglas que las list comprehensions, pero con key: value entre las llaves.

Dict como gemelo de JSON

Los dicts de Python se alinean casi exactamente con los objetos JSON. Convertir entre ellos es una sola llamada:

import json

data = {"name": "Rosa", "age": 30, "tags": ["python", "docs"]}

as_json = json.dumps(data)
print(as_json)

back = json.loads(as_json)
print(back)

Por eso los dicts aparecen por todas partes en el trabajo web — tus peticiones y respuestas de API son básicamente manipulación de dicts con algo de red en el medio.

Un ejemplo práctico

Un pequeño programa tipo configuración que guarda un perfil de usuario:

user = {
    "name": "Rosa",
    "email": "rosa@example.com",
    "preferences": {
        "theme": "dark",
        "notifications": True,
    },
    "tags": ["python", "docs"],
}

print(user["name"])
print(user["preferences"]["theme"])
print(user.get("last_login", "never"))

user["tags"].append("seo")
user["preferences"]["theme"] = "light"

print(user)

Dicts anidados, valores mutables, .get() con default — el kit básico de herramientas para cualquier dato con forma de registro.

Seguimos

Listas, tuplas, sets, dicts. Con esas cuatro colecciones en la mano, puedes modelar casi cualquier dato con el que te encuentres al principio. A continuación, aprenderemos la list comprehension — la forma compacta que tiene Python de transformar una colección en otra.