Python · Lección 14 de 27

Métodos de diccionarios

En la lección 10 aprendiste lo básico de diccionarios. Ahora vas a dominar los métodos avanzados que usan los profesionales: acceso seguro, merge, conteo de frecuencias, defaultdict y patrones de agrupación que son la base de lo que después harás con pandas groupby.

80–100 min Prerrequisitos: 10 Diccionarios, 13 Métodos de listas

Concepto teórico

.get() vs .setdefault() — acceso seguro con matices

Ya conocés .get(clave, default): devuelve el valor si la clave existe, o el default si no. Pero .get() NO modifica el diccionario — solo consulta. A veces necesitás algo más: si la clave no existe, crearla con un valor inicial y DESPUÉS devolver ese valor. Para eso existe .setdefault():

d = {"nombre": "García"}

# .get() — solo consulta, no modifica
email = d.get("email", "sin dato")   # devuelve "sin dato", d NO cambia
print(d)  # {"nombre": "García"} — email NO se creó

# .setdefault() — consulta Y crea si no existe
email = d.setdefault("email", "sin dato")  # devuelve "sin dato" Y lo agrega
print(d)  # {"nombre": "García", "email": "sin dato"} — email SÍ se creó

¿Cuándo usar cada uno? .get() cuando solo querés leer sin efectos secundarios (el 90% de los casos). .setdefault() cuando querés inicializar una clave la primera vez que la encontrás — típico en patrones de agrupación manual.

.update() — merge de diccionarios

.update() combina dos diccionarios. Si hay claves repetidas, los valores del diccionario que pasás como argumento sobreescriben los existentes:

base = {"nombre": "García", "score": 720}
nuevos = {"score": 735, "ciudad": "BsAs"}  # score se sobreescribe
base.update(nuevos)
# base = {"nombre": "García", "score": 735, "ciudad": "BsAs"}

Desde Python 3.9, también podés usar el operador | para merge (devuelve nuevo dict) y |= para merge in-place:

# Python 3.9+
combinado = base | nuevos      # nuevo dict (no modifica base)
base |= nuevos                 # modifica base in-place (como update)

.pop() y .popitem() — eliminar y obtener

.pop(clave, default) — elimina la clave y devuelve su valor. Si la clave no existe y no pasás default, da KeyError. Si pasás default, lo devuelve sin error.
.popitem() — elimina y devuelve el último par insertado como tupla (clave, valor). Útil para procesar un dict como cola LIFO.

Patrón: contador de frecuencias

Uno de los patrones más usados en análisis de datos es contar cuántas veces aparece cada valor. Hay tres formas, de menos a más elegante:

Forma 1 — Manual con if/else:

freq = {}
for item in datos:
    if item in freq:
        freq[item] += 1
    else:
        freq[item] = 1

Forma 2 — Con .get():

freq = {}
for item in datos:
    freq[item] = freq.get(item, 0) + 1

Forma 3 — Con Counter (la mejor):

from collections import Counter
freq = Counter(datos)

defaultdict — diccionarios con valor inicial automático

defaultdict del módulo collections es un diccionario que, cuando accedés a una clave que no existe, automáticamente la crea con un valor inicial según el tipo que le pases:

defaultdict(int) — claves nuevas se crean con valor 0
defaultdict(list) — claves nuevas se crean con [] (lista vacía)
defaultdict(set) — claves nuevas se crean con set()
defaultdict(float) — claves nuevas se crean con 0.0

Cuidado con defaultdict: como crea la clave al acceder, un simple d["clave_inexistente"] (incluso sin asignar nada) agrega esa clave al diccionario. Esto puede generar entradas "fantasma" si no tenés cuidado. Usalo solo cuando realmente necesitás la auto-creación.

Counter — el arma secreta para frecuencias

Counter de collections es una subclase de dict optimizada para contar. Tiene métodos adicionales como .most_common(n) que devuelve los N elementos más frecuentes como lista de tuplas:

from collections import Counter
ventas = ["GGAL", "YPF", "GGAL", "PAMP", "GGAL", "YPF", "MELI"]
freq = Counter(ventas)
print(freq.most_common(2))  # [("GGAL", 3), ("YPF", 2)]

En pandas: Counter es el equivalente manual de df["columna"].value_counts(). Cuando no tenés pandas disponible (scripts simples, lambdas en AWS, exámenes técnicos), Counter es tu mejor amigo.

Dict comprehensions avanzadas

Los patrones más útiles que no vimos en la lección 10:

Invertir clave-valor: {v: k for k, v in original.items()}
Filtrar por valor: {k: v for k, v in d.items() if v > umbral}
Transformar valores: {k: v * 1.21 for k, v in precios.items()}
Desde lista de tuplas: {k: v for k, v in lista_tuplas}
Con .fromkeys(): dict.fromkeys(["a","b","c"], 0) — todas las claves con el mismo valor

Tip profesional: cuando necesitás "agrupar por" sin pandas, el patrón defaultdict(list) + loop es tu herramienta. Es exactamente lo que hace df.groupby("columna") por debajo.

Ejemplos explicados paso a paso

Ejemplo 1: .get() vs .setdefault() vs acceso directo

ejemplo_01_acceso.pyPython

cliente = {"nombre": "García", "score": 720}

# Acceso directo: peligroso si la clave no existe
print(f"Nombre: {cliente['nombre']}")
# print(cliente["email"])  # KeyError!

# .get(): seguro, no modifica el dict
email = cliente.get("email", "no_informado")
print(f"Email: {email}")
print(f"Dict después de get: {cliente}")  # NO tiene "email"

# .setdefault(): seguro Y crea la clave si no existe
ciudad = cliente.setdefault("ciudad", "Sin dato")
print(f"\nCiudad: {ciudad}")
print(f"Dict después de setdefault: {cliente}")  # SÍ tiene "ciudad"

# .setdefault() no sobreescribe si la clave YA existe
cliente.setdefault("score", 0)  # score ya es 720, no cambia
print(f"Score sigue siendo: {cliente['score']}")

# Caso de uso real: acumular por categoría
transacciones = [
    ("compra", 1500), ("venta", 800), ("compra", 3200),
    ("transferencia", 5000), ("compra", 950), ("venta", 2100)
]
por_tipo = {}
for tipo, monto in transacciones:
    por_tipo.setdefault(tipo, []).append(monto)

print(f"\nAgrupado: {por_tipo}")
for tipo, montos in por_tipo.items():
    print(f"  {tipo}: {len(montos)} ops, total ${sum(montos):,}")

Hacé clic en ▶ Ejecutar

Ejemplo 2: update, pop, merge

ejemplo_02_update_pop.pyPython

# .update(): merge de diccionarios
config_base = {
    "tasa_iva": 0.21,
    "moneda": "ARS",
    "banco": "Galicia",
    "sucursal": "Centro",
}
config_override = {
    "banco": "Macro",        # sobreescribe
    "sucursal": "Norte",     # sobreescribe
    "region": "NOA",         # nuevo
}
config_base.update(config_override)
print(f"Config final: {config_base}")

# .pop(): eliminar y obtener el valor
eliminado = config_base.pop("region")
print(f"\nEliminé: {eliminado}")

# .pop() con default (seguro)
inexistente = config_base.pop("api_key", "no había")
print(f"Pop inexistente: {inexistente}")

# .popitem(): elimina el último insertado
ultimo = config_base.popitem()
print(f"Último eliminado: {ultimo}")
print(f"Dict final: {config_base}")

# Merge con | (Python 3.9+) — devuelve nuevo dict
precios_ars = {"Notebook": 920000, "Mouse": 23000}
precios_nuevos = {"Mouse": 25000, "Teclado": 46000}
combinado = precios_ars | precios_nuevos  # Mouse se actualiza
print(f"\nMerge |: {combinado}")
print(f"Original intacto: {precios_ars}")

Hacé clic en ▶ Ejecutar

Ejemplo 3: Counter y frecuencias

ejemplo_03_counter.pyPython

from collections import Counter

# Contar operaciones por ticker
operaciones = ["GGAL", "YPF", "GGAL", "PAMP", "GGAL", "YPF",
               "MELI", "PAMP", "GGAL", "YPF", "MELI", "GGAL"]

freq = Counter(operaciones)
print(f"Frecuencias: {dict(freq)}")

# Top 3 más operados
print(f"\nTop 3:")
for ticker, cantidad in freq.most_common(3):
    pct = cantidad / len(operaciones) * 100
    barra = "█" * cantidad
    print(f"  {ticker:<6} {cantidad:>2} ({pct:4.1f}%) {barra}")

# Operaciones aritméticas entre Counters
q1 = Counter({"GGAL": 50, "YPF": 30, "PAMP": 20})
q2 = Counter({"GGAL": 45, "YPF": 35, "MELI": 15})
total = q1 + q2    # suma las cantidades
print(f"\nQ1 + Q2: {dict(total)}")

diferencia = q1 - q2  # resta (no va a negativo)
print(f"Q1 - Q2: {dict(diferencia)}")

# Contar caracteres en un string
texto = "supercalifragilisticoespialidoso"
letras = Counter(texto)
print(f"\nTop 5 letras: {letras.most_common(5)}")

Hacé clic en ▶ Ejecutar

Ejemplo 4: defaultdict para agrupación

ejemplo_04_defaultdict.pyPython

from collections import defaultdict

# Agrupar clientes por ciudad (equivalente manual de groupby)
clientes = [
    ("García", "BsAs", 150000),
    ("López", "Córdoba", 320000),
    ("Martínez", "BsAs", 45000),
    ("Pérez", "BsAs", 890000),
    ("Fernández", "Córdoba", 72000),
    ("Sosa", "Rosario", 210000),
]

# Con defaultdict(list): no necesitás verificar si la clave existe
por_ciudad = defaultdict(list)
for nombre, ciudad, saldo in clientes:
    por_ciudad[ciudad].append({"nombre": nombre, "saldo": saldo})

print("=== Clientes por ciudad ===")
for ciudad, lista in sorted(por_ciudad.items()):
    total = sum(c["saldo"] for c in lista)
    print(f"\n{ciudad} ({len(lista)} clientes, total: ${total:,}):")
    for c in lista:
        print(f"  - {c['nombre']}: ${c['saldo']:,}")

# defaultdict(int): contar sin verificar
ventas_por_vendedor = defaultdict(int)
operaciones = [("García", 50000), ("López", 30000), ("García", 45000),
               ("López", 60000), ("García", 20000)]
for vendedor, monto in operaciones:
    ventas_por_vendedor[vendedor] += monto

print(f"\nVentas totales: {dict(ventas_por_vendedor)}")

# defaultdict(set): acumular valores únicos
productos_por_cliente = defaultdict(set)
compras = [("García", "Tarjeta"), ("López", "Cuenta"), ("García", "Cuenta"),
           ("García", "Tarjeta"), ("López", "Préstamo")]  # García-Tarjeta duplicado
for cliente, producto in compras:
    productos_por_cliente[cliente].add(producto)

print(f"\nProductos únicos: {dict(productos_por_cliente)}")

Hacé clic en ▶ Ejecutar

Ejemplo 5: Dict comprehensions avanzadas

ejemplo_05_comprehensions.pyPython

# Filtrar pares por valor
saldos = {"García": 150000, "López": 320000, "Martínez": 45000,
          "Pérez": 890000, "Sosa": 72000}

grandes = {k: v for k, v in saldos.items() if v > 100000}
print(f"Saldos > $100K: {grandes}")

# Transformar valores (aplicar rendimiento 5%)
con_interes = {k: round(v * 1.05) for k, v in saldos.items()}
print(f"Con 5% interés: {con_interes}")

# Invertir clave-valor
codigos = {"GGAL": "Galicia", "YPF": "YPF SA", "PAMP": "Pampa Energía"}
invertido = {v: k for k, v in codigos.items()}
print(f"\nInvertido: {invertido}")

# .fromkeys(): crear dict con todas las claves iguales
campos = ["nombre", "edad", "ciudad", "score", "saldo"]
template = dict.fromkeys(campos, None)
print(f"Template: {template}")

# Crear scoring desde listas con dict + zip
nombres = ["García", "López", "Pérez"]
scores = [720, 680, 810]
scoring = dict(zip(nombres, scores))
print(f"\nScoring: {scoring}")

# Combinar: solo los que pasaron, con categoría
categorizado = {
    nombre: ("Premium" if score >= 750 else "Estándar")
    for nombre, score in scoring.items()
    if score >= 650
}
print(f"Categorizados: {categorizado}")

Hacé clic en ▶ Ejecutar

Referencia rápida

Método	Modifica dict?	Devuelve	Cuándo usar
`.get(k, default)`	No	Valor o default	Lectura segura (90% de los casos)
`.setdefault(k, v)`	Sí (si k no existe)	Valor existente o v	Inicializar clave la primera vez
`.update(dict2)`	Sí	`None`	Merge de diccionarios
`.pop(k, default)`	Sí	Valor eliminado	Eliminar y usar el valor
`.popitem()`	Sí	(clave, valor)	Procesar como cola LIFO
`.fromkeys(keys, v)`	—	Nuevo dict	Template con claves predefinidas
`d1 \| d2` (3.9+)	No	Nuevo dict	Merge funcional
`d1 \|= d2` (3.9+)	Sí	`None`	Merge in-place

Herramienta collections	Qué hace	Equivalente pandas
`Counter(iterable)`	Cuenta frecuencias	`.value_counts()`
`Counter.most_common(n)`	Top N más frecuentes	`.value_counts().head(n)`
`defaultdict(list)`	Agrupar valores por clave	`.groupby().agg(list)`
`defaultdict(int)`	Acumular sumas por clave	`.groupby().sum()`
`defaultdict(set)`	Acumular únicos por clave	`.groupby().nunique()`

Ejercicios

Nivel 1 · Básico

Ejercicio 1: .get() con default

Dado prod = {"nombre": "Notebook", "precio": 920000}, usá .get() para acceder a "stock" con default 0. Imprimí el resultado. Debe incluir Stock: 0.

ejercicio_01.pyDebe incluir "Stock: 0"

prod = {"nombre": "Notebook", "precio": 920000}

# Accedé a stock con default:

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 2: .update() para merge

Tenés base = {"nombre": "García", "score": 700} y nuevo = {"score": 735, "ciudad": "BsAs"}. Mergealos con .update(). El score debe quedar en 735. Debe incluir 735.

ejercicio_02.pyDebe incluir "735"

base = {"nombre": "García", "score": 700}
nuevo = {"score": 735, "ciudad": "BsAs"}

# Mergeá e imprimí:

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 3: .pop() para eliminar

Dado config = {"host": "db.local", "port": 5432, "debug": True}, eliminá "debug" con .pop() y mostrá el valor eliminado. Debe incluir True.

ejercicio_03.pyDebe incluir "True"

config = {"host": "db.local", "port": 5432, "debug": True}

# Eliminá debug y mostrá:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 4: Contar frecuencias con .get()

Dada ciudades = ["BsAs","Córdoba","BsAs","Rosario","BsAs","Córdoba","Mendoza"], contá la frecuencia de cada ciudad usando el patrón .get(k, 0) + 1. Debe incluir 3 (BsAs aparece 3 veces).

ejercicio_04.pyDebe incluir "3"

ciudades = ["BsAs", "Córdoba", "BsAs", "Rosario", "BsAs", "Córdoba", "Mendoza"]

# Contá frecuencias:
freq = {}

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 5: Counter con most_common

Dada la lista de tickers ["GGAL","YPF","GGAL","PAMP","GGAL","YPF","MELI","PAMP","GGAL"], usá Counter para encontrar los 2 más operados. Debe incluir GGAL.

ejercicio_05.pyDebe incluir "GGAL"

from collections import Counter

tickers = ["GGAL", "YPF", "GGAL", "PAMP", "GGAL", "YPF", "MELI", "PAMP", "GGAL"]

# Top 2 con Counter:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 6: Dict comprehension para filtrar

Dado saldos = {"García": 150000, "López": 320000, "Martínez": 45000, "Pérez": 890000}, creá un nuevo dict solo con los que tienen saldo > $100K. Debe incluir Pérez.

ejercicio_06.pyDebe incluir "Pérez"

saldos = {"García": 150000, "López": 320000, "Martínez": 45000, "Pérez": 890000}

# Filtrá > $100K con comprehension:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 7: defaultdict(list) para agrupar

Agrupá estas transacciones por tipo usando defaultdict(list): [("compra",1500), ("venta",800), ("compra",3200), ("venta",2100), ("compra",950)]. Imprimí el total por tipo. Debe incluir 5650.

ejercicio_07.pyDebe incluir "5650"

from collections import defaultdict

transacciones = [("compra", 1500), ("venta", 800), ("compra", 3200),
                 ("venta", 2100), ("compra", 950)]

# Agrupá con defaultdict:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 8: Invertir diccionario

Dado codigos = {"AR": "Argentina", "BR": "Brasil", "CL": "Chile", "UY": "Uruguay"}, creá un dict invertido (país → código) con comprehension. Debe incluir Argentina.

ejercicio_08.pyDebe incluir "Argentina"

codigos = {"AR": "Argentina", "BR": "Brasil", "CL": "Chile", "UY": "Uruguay"}

# Invertí con comprehension:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 9: Pipeline merge + transform

Tenés precios_q3 = {"GGAL": 4800, "YPF": 25000} y precios_q4 = {"GGAL": 5200, "PAMP": 3100}. Mergealos (Q4 sobreescribe), después creá un nuevo dict aplicando +10% a cada precio. Debe incluir 5720 (GGAL con 10%).

ejercicio_09.pyDebe incluir "5720"

precios_q3 = {"GGAL": 4800, "YPF": 25000}
precios_q4 = {"GGAL": 5200, "PAMP": 3100}

# Merge + transformar:

Hacé clic en ▶ Ejecutar

Nivel 4 · Desafío

Ejercicio 10: Reporte de ventas agrupado por vendedor

Dadas estas ventas como lista de tuplas (vendedor, producto, monto), generá un reporte agrupado por vendedor que muestre: cantidad de ventas, monto total, productos únicos y venta promedio. Usá defaultdict. Debe incluir REPORTE.

ejercicio_10_desafio.pyDebe incluir "REPORTE"

from collections import defaultdict

ventas = [
    ("García", "Tarjeta", 5000),
    ("López", "Préstamo", 120000),
    ("García", "Cuenta", 0),
    ("López", "Tarjeta", 8000),
    ("García", "Préstamo", 85000),
    ("Pérez", "Cuenta", 0),
    ("López", "Cuenta", 0),
    ("Pérez", "Tarjeta", 3500),
    ("García", "Tarjeta", 12000),
]

# Agrupá y generá reporte:
print("=== REPORTE DE VENTAS ===")

Hacé clic en ▶ Ejecutar

Resumen y conexión

.get(k, default) lee sin modificar. .setdefault(k, v) lee Y crea si no existe.
.update() y |/|= (3.9+) mergean diccionarios. Las claves del segundo sobreescriben.
.pop(k, default) elimina y devuelve. .popitem() elimina el último par.
Counter cuenta frecuencias en una línea. .most_common(n) da el top N.
defaultdict(list/int/set) es el equivalente manual de groupby en pandas.
Dict comprehensions filtran, transforman e invierten dicts en una línea.

En la siguiente lección (15 · Anidación) vas a combinar todo lo que aprendiste: listas de listas, listas de diccionarios, diccionarios de diccionarios y recorridos profundos sobre estructuras complejas.

Recursos: collections module · dict methods

Hecho con ❤️ por Rodri Gonzalez