Métodos de Diccionario en Python

Los diccionarios de Python almacenan datos como pares clave-valor y cuentan con un amplio conjunto de métodos integrados para leer, agregar, actualizar y eliminar entradas. Este capítulo cubre todos los métodos de diccionario disponibles en Python 3, con ejemplos correctos y notas prácticas sobre cuándo — y cuándo no — usar cada uno.

Para una introducción general a los diccionarios (creación, acceso a elementos, anidamiento), consulta el capítulo Python Dictionaries.

¿Qué es un Diccionario de Python?

Un diccionario asigna claves únicas a valores. Las claves deben ser hashables (los strings, números y tuplas de hashables funcionan; las listas no). Los valores pueden ser cualquier objeto de Python.

person = {"name": "Alice", "age": 28, "city": "Berlin"}

Los diccionarios mantienen el orden de inserción desde Python 3.7 — al iterarlos siempre se obtienen las claves en el orden en que fueron añadidas.

Métodos de Diccionario de un Vistazo

clear()

clear() elimina todos los elementos del diccionario en el lugar, dejando un dict vacío. Úsalo cuando necesites reutilizar el mismo objeto dict en lugar de crear uno nuevo.

Error frecuente: inventory = {} parece similar, pero crea un nuevo objeto dict. Si otra variable apunta al mismo dict, clear() lo vacía para ambas; la reasignación no lo hace.

a = {"x": 1}
b = a
a.clear()
print(b)   # Output: {}  — b sees the change

a = {"x": 1}
b = a
a = {}
print(b)   # Output: {'x': 1}  — b is unaffected

copy()

copy() retorna una copia superficial — un nuevo dict con las mismas claves y referencias a los mismos valores.

Error frecuente: Si algún valor es un objeto mutable (lista, dict, conjunto), tanto el original como la copia comparten ese objeto. Usa copy.deepcopy() cuando necesites independencia total.

Para más detalles sobre cómo copiar dicts de forma segura, consulta Copy Dictionaries.

fromkeys()

fromkeys(iterable, value) es un método de clase que construye un nuevo dict a partir de una secuencia de claves, todas asignadas al mismo valor (por defecto None).

fields = ["name", "email", "phone"]
record = dict.fromkeys(fields, "")
print(record)
# Output: {'name': '', 'email': '', 'phone': ''}

Error frecuente: Si el valor predeterminado es mutable (por ejemplo, una lista), todas las claves comparten el mismo objeto:

bad = dict.fromkeys(["a", "b"], [])
bad["a"].append(1)
print(bad)  # Output: {'a': [1], 'b': [1]}  — both share the list!

La solución es usar una comprensión de dict en su lugar:

good = {k: [] for k in ["a", "b"]}
good["a"].append(1)
print(good)  # Output: {'a': [1], 'b': []}

get()

get(key, default=None) retorna el valor de key si existe, o default en caso contrario. Nunca lanza KeyError.

Cuándo usarlo: prefiere get() sobre dict[key] siempre que la clave pueda estar ausente. Usa la forma de dos argumentos para proporcionar un valor predeterminado significativo en lugar de capturar KeyError en un bloque try/except.

items()

items() retorna una vista dict_items — un iterable de tuplas (key, value) que refleja el estado actual del dict.

El uso más común es desempaquetar la clave y el valor en un bucle for:

scores = {"math": 90, "english": 85, "science": 92}
for subject, grade in scores.items():
    print(f"{subject}: {grade}")
# Output:
# math: 90
# english: 85
# science: 92

Las vistas son en vivo — reflejan los cambios en el dict sin necesidad de ser regeneradas.

Para más patrones de bucle, consulta Loop Dictionaries.

keys()

keys() retorna una vista dict_keys de todas las claves en orden de inserción.

Al ser una vista, puedes usarla en operaciones de conjuntos para comparar dos dicts:

a = {"x": 1, "y": 2}
b = {"y": 3, "z": 4}

print(a.keys() & b.keys())  # Output: {'y'}    — keys in both
print(a.keys() | b.keys())  # Output: {'x', 'y', 'z'}  — all keys
print(a.keys() - b.keys())  # Output: {'x'}    — keys only in a

values()

values() retorna una vista dict_values de todos los valores.

Casos de uso comunes:

prices = {"apple": 0.99, "banana": 0.59, "cherry": 2.49}

total = sum(prices.values())
print(f"Total: {total:.2f}")   # Output: Total: 4.07

most_expensive = max(prices.values())
print(most_expensive)          # Output: 2.49

A diferencia de keys(), values() no admite operaciones de conjuntos porque no se garantiza que los valores sean únicos.

pop()

pop(key, default) elimina el elemento con la clave indicada y retorna su valor. Si la clave está ausente y no se proporciona un valor predeterminado, lanza KeyError.

Cuándo usarlo: pop() es la herramienta correcta cuando necesitas eliminar un elemento y usar su valor en la misma operación, como al procesar elementos de un dict tipo cola.

popitem()

popitem() elimina y retorna el par clave-valor insertado en último lugar como una tupla (key, value). Llamarlo en un dict vacío lanza KeyError.

data = {"a": 1, "b": 2, "c": 3}

last = data.popitem()
print(last)   # Output: ('c', 3)
print(data)   # Output: {'a': 1, 'b': 2}

Un patrón práctico es procesar un dict de forma destructiva hasta que esté vacío:

tasks = {"write tests": True, "review PR": False, "deploy": True}
while tasks:
    name, done = tasks.popitem()
    status = "done" if done else "pending"
    print(f"{name}: {status}")

setdefault()

setdefault(key, default=None) retorna el valor de key si existe. Si key está ausente, lo inserta con default y retorna default.

options = {"color": "blue"}

# Key exists — returns existing value, does NOT overwrite
print(options.setdefault("color", "red"))   # Output: blue

# Key absent — inserts and returns default
print(options.setdefault("size", "medium")) # Output: medium

print(options)
# Output: {'color': 'blue', 'size': 'medium'}

Caso de uso principal: construir diccionarios de listas (agrupación):

words = ["apple", "avocado", "banana", "blueberry", "cherry"]
grouped = {}
for word in words:
    grouped.setdefault(word[0], []).append(word)

print(grouped)
# Output: {'a': ['apple', 'avocado'], 'b': ['banana', 'blueberry'], 'c': ['cherry']}

Esto es más limpio que una comprobación if key not in d: d[key] = [] en cada iteración.

update()

update(other) fusiona other en el diccionario, sobreescribiendo las claves existentes. other puede ser otro dict, un iterable de pares (key, value) o argumentos de palabra clave.

Alternativa en Python 3.9+: el operador |= de fusión en el lugar hace lo mismo de manera más concisa:

profile = {"name": "Alice", "age": 28}
profile |= {"age": 29, "city": "Berlin"}
print(profile)
# Output: {'name': 'Alice', 'age': 29, 'city': 'Berlin'}

El operador | (sin =) retorna un nuevo dict en lugar de modificar en el lugar.

Acceder y Modificar Elementos

Más allá de los métodos anteriores, Python ofrece sintaxis directa para leer, agregar y eliminar entradas de un diccionario.

Leer un valor por clave:

Acceder a una clave que no existe lanza KeyError. Usa get() para evitar esto.

Agregar o sobreescribir un valor:

person = {"name": "Alice", "age": 28}
person["occupation"] = "Engineer"  # new key
person["age"] = 29                 # overwrite existing key
print(person)
# Output: {'name': 'Alice', 'age': 29, 'occupation': 'Engineer'}

Iterar sobre claves y valores:

Elegir el Método Correcto

Capítulos Relacionados

• Python Dictionaries — fundamentos: creación, acceso y prueba de pertenencia
• Nested Dictionaries — dicts de dicts para datos jerárquicos
• Loop Dictionaries — todos los patrones de bucle con keys(), values() e items()
• Copy Dictionaries — copia superficial vs. profunda en detalle
• List Methods — la referencia equivalente para listas de Python

Práctica