Python · Lección 10 de 27

Diccionarios

Los diccionarios son la estructura de datos más importante para representar datos del mundo real. Cada fila de una base de datos, cada registro JSON de una API y cada fila de un CSV es esencialmente un diccionario: pares de clave y valor.

90–120 min Prerrequisitos: 08 Listas, 09 Tuplas

Concepto teórico

¿Qué es un diccionario?

Un diccionario (dict) es una colección de pares clave: valor. Cada clave es un identificador único que apunta a un valor. Es como un diccionario real de idiomas: buscás una palabra (clave) y encontrás su definición (valor). En Python se crean con llaves {}.

cliente = {
    "nombre": "García",
    "edad": 35,
    "ciudad": "Buenos Aires",
    "score": 720,
    "saldo": 250000,
    "activo": True
}

A diferencia de las listas (que accedés por posición numérica), en los diccionarios accedés por clave: cliente["nombre"] devuelve "García". Esto es mucho más legible y mantenible que cliente[0].

Punto clave: un diccionario es la versión Python de un registro (fila) de una base de datos. Cuando trabajés con pandas, cada fila de un DataFrame es convertible a diccionario con .to_dict(). Y cuando leas un JSON de una API, lo que recibís es un diccionario (o lista de diccionarios).

Características de los diccionarios

Ordenados (desde Python 3.7+): mantienen el orden de inserción. Antes de 3.7 no lo garantizaban.
Mutables: podés agregar, modificar y eliminar pares clave-valor después de crear el diccionario.
Claves únicas: si asignás dos veces la misma clave, la segunda sobreescribe la primera. No hay claves duplicadas.
Claves inmutables: las claves deben ser hashables (strings, números, tuplas). Las listas NO pueden ser claves.
Valores de cualquier tipo: el valor puede ser int, str, list, otro dict, función, lo que sea.
Acceso O(1): buscar por clave es instantáneo (no importa si el diccionario tiene 10 o 10 millones de entradas). Las listas necesitan O(n) para buscar un valor.

Analogía: un diccionario es como una guía telefónica: buscás por nombre (clave) y encontrás el teléfono (valor). No necesitás recorrer toda la guía — vas directo al nombre que necesitás. Una lista sería como tener los teléfonos en orden de llegada, sin nombres: para encontrar uno tenés que recorrer todos.

Acceso: [] vs .get()

Hay dos formas de acceder a un valor:

dict["clave"] — devuelve el valor. Si la clave NO existe, lanza KeyError (error).
dict.get("clave", default) — devuelve el valor. Si la clave no existe, devuelve default (en vez de error). Si no pasás default, devuelve None.

Regla profesional: usá .get() siempre que no estés 100% seguro de que la clave existe. En datos del mundo real, nunca sabés si un campo viene completo. Un KeyError en producción a las 3 AM te arruina el fin de semana. Un .get("score", 0) te devuelve un valor seguro.

Agregar, modificar y eliminar

Agregar y modificar usan la misma sintaxis: dict["clave"] = valor. Si la clave no existe, la crea. Si existe, la sobreescribe.

Para eliminar: del dict["clave"] (lanza error si no existe) o dict.pop("clave", default) (seguro, devuelve el valor eliminado).

Recorrer diccionarios

Los tres métodos de iteración que usás constantemente:

.keys() — devuelve las claves. for k in dict.keys(): (o simplemente for k in dict:)
.values() — devuelve los valores. for v in dict.values():
.items() — devuelve pares (clave, valor). for k, v in dict.items(): — el más usado.

Diccionarios anidados

Un diccionario puede contener otros diccionarios como valores. Esto es la forma natural de representar datos JSON, que es el formato estándar de las APIs web:

cliente = {
    "nombre": "García",
    "scoring": {"valor": 720, "fecha": "2025-01-15", "entidad": "BCRA"},
    "cuentas": [
        {"tipo": "CA$", "saldo": 150000},
        {"tipo": "CA USD", "saldo": 5000}
    ]
}
# Acceso anidado:
print(cliente["scoring"]["valor"])     # 720
print(cliente["cuentas"][0]["saldo"])   # 150000

En el trabajo real: el 90% de los datos que vas a consumir vienen como JSON (APIs) o como DataFrames (pandas). Ambos son, en esencia, diccionarios o listas de diccionarios. Cada vez que hagas df.to_dict('records'), obtenés una lista de dicts. Cada vez que hagas requests.get(url).json(), obtenés un dict.

Dict comprehensions

Al igual que las list comprehensions, podés crear diccionarios en una línea:

{clave: valor for item in iterable if condición}

Tip profesional: los dict comprehensions son ideales para transformar datos rápidamente. Por ejemplo, invertir un diccionario ({v: k for k, v in original.items()}), filtrar pares ({k: v for k, v in d.items() if v > 100000}), o crear mappings ({nombre: score for nombre, score in zip(nombres, scores)}).

Ejemplos explicados paso a paso

Ejemplo 1: Crear, acceder y modificar

Las operaciones CRUD (Create, Read, Update, Delete) básicas de un diccionario.

ejemplo_01_crud.pyPython

# Crear
cliente = {
    "nombre": "García",
    "edad": 35,
    "score": 720,
    "saldo": 250000,
}
print(f"Cliente: {cliente}")

# Leer (Read) — dos formas
print(f"\nNombre: {cliente['nombre']}")
print(f"Score: {cliente.get('score')}")
print(f"Email: {cliente.get('email', 'No informado')}")  # seguro

# Actualizar (Update) — misma sintaxis que crear
cliente["saldo"] = 300000         # modificar existente
cliente["email"] = "g@mail.com"   # agregar nuevo
print(f"\nActualizado: {cliente}")

# Eliminar (Delete)
eliminado = cliente.pop("email")  # seguro, devuelve el valor
print(f"Eliminé email: {eliminado}")

# .update() para merge masivo
nuevos_datos = {"score": 735, "ciudad": "Buenos Aires", "activo": True}
cliente.update(nuevos_datos)
print(f"\nDespués de update: {cliente}")
print(f"Claves: {list(cliente.keys())}")
print(f"Cantidad de campos: {len(cliente)}")

Hacé clic en ▶ Ejecutar

Ejemplo 2: Recorrer con .items() — el patrón más usado

El 80% de las veces que trabajás con diccionarios, los recorrés con .items().

ejemplo_02_recorrer.pyPython

cliente = {
    "nombre": "López",
    "edad": 42,
    "ciudad": "Córdoba",
    "score": 680,
    "saldo": 320000,
    "productos": ["Cuenta", "Tarjeta", "Préstamo"]
}

# Recorrer con .items()
print("=== Ficha del cliente ===")
for clave, valor in cliente.items():
    if isinstance(valor, list):
        print(f"  {clave}: {', '.join(valor)}")
    elif isinstance(valor, (int, float)) and clave == "saldo":
        print(f"  {clave}: ${valor:,}")
    else:
        print(f"  {clave}: {valor}")

# Solo claves
print(f"\nCampos: {list(cliente.keys())}")

# Solo valores numéricos
numeros = {k: v for k, v in cliente.items() if isinstance(v, (int, float))}
print(f"Valores numéricos: {numeros}")

# Verificar existencia de clave
print(f"\n¿Tiene email? {'email' in cliente}")
print(f"¿Tiene nombre? {'nombre' in cliente}")

Hacé clic en ▶ Ejecutar

Ejemplo 3: Lista de diccionarios — la "base de datos en memoria"

Este es el patrón más importante del curso. Una lista de diccionarios es exactamente lo que devuelve df.to_dict('records') en pandas.

ejemplo_03_tabla.pyPython

# "Base de datos" = lista de diccionarios
clientes = [
    {"nombre": "García", "ciudad": "BsAs", "score": 720, "saldo": 150000},
    {"nombre": "López", "ciudad": "Córdoba", "score": 680, "saldo": 320000},
    {"nombre": "Martínez", "ciudad": "Rosario", "score": 590, "saldo": 45000},
    {"nombre": "Pérez", "ciudad": "BsAs", "score": 810, "saldo": 890000},
    {"nombre": "Fernández", "ciudad": "Mendoza", "score": 645, "saldo": 72000},
]

# Estadísticas
total_saldos = sum(c["saldo"] for c in clientes)
promedio = total_saldos / len(clientes)
print(f"Total: ${total_saldos:,}")
print(f"Promedio: ${promedio:,.0f}")

# Filtrar: clientes con score >= 650
aprobados = [c for c in clientes if c["score"] >= 650]
print(f"\nAprobados ({len(aprobados)}):")
for c in aprobados:
    print(f"  {c['nombre']}: score {c['score']}, ${c['saldo']:,}")

# Top cliente por saldo
top = max(clientes, key=lambda c: c["saldo"])
print(f"\nTop: {top['nombre']} con ${top['saldo']:,}")

# Agrupar por ciudad (manual — después pandas lo hace automático)
por_ciudad = {}
for c in clientes:
    ciudad = c["ciudad"]
    if ciudad not in por_ciudad:
        por_ciudad[ciudad] = []
    por_ciudad[ciudad].append(c["nombre"])
print(f"\nPor ciudad: {por_ciudad}")

Hacé clic en ▶ Ejecutar

Ejemplo 4: Dict comprehensions

Creá y transformá diccionarios en una sola línea.

ejemplo_04_comprehension.pyPython

# Crear desde dos listas con zip
nombres = ["García", "López", "Martínez", "Pérez"]
scores = [720, 680, 590, 810]
scoring = {n: s for n, s in zip(nombres, scores)}
print(f"Scoring: {scoring}")

# Filtrar: solo score >= 650
buenos = {n: s for n, s in scoring.items() if s >= 650}
print(f"Buenos: {buenos}")

# Transformar valores: aplicar un ajuste de +50 al score
ajustados = {n: s + 50 for n, s in scoring.items()}
print(f"Ajustados: {ajustados}")

# Invertir clave-valor
invertido = {s: n for n, s in scoring.items()}
print(f"Invertido: {invertido}")

# Contar frecuencias (patrón muy común)
ciudades = ["BsAs", "Córdoba", "BsAs", "Rosario", "BsAs", "Córdoba"]
frecuencias = {}
for c in ciudades:
    frecuencias[c] = frecuencias.get(c, 0) + 1
print(f"\nFrecuencias: {frecuencias}")

# Lo mismo pero con Counter (preview)
from collections import Counter
print(f"Con Counter: {dict(Counter(ciudades))}")

Hacé clic en ▶ Ejecutar

Ejemplo 5: Diccionarios anidados — simulando JSON

Los datos de APIs y bases de datos NoSQL vienen como diccionarios anidados. Aprender a navegar estas estructuras es esencial.

ejemplo_05_anidado.pyPython

# Estructura JSON típica de una API bancaria
respuesta_api = {
    "status": "ok",
    "cliente": {
        "id": 12345,
        "nombre": "García",
        "scoring": {
            "valor": 720,
            "fecha": "2025-01-15",
            "fuente": "BCRA"
        },
        "cuentas": [
            {"tipo": "CA$", "moneda": "ARS", "saldo": 150000},
            {"tipo": "CA USD", "moneda": "USD", "saldo": 5000},
        ]
    }
}

# Navegar la estructura
print(f"Status: {respuesta_api['status']}")
print(f"Nombre: {respuesta_api['cliente']['nombre']}")
print(f"Score: {respuesta_api['cliente']['scoring']['valor']}")
print(f"Fuente: {respuesta_api['cliente']['scoring']['fuente']}")

# Acceder a las cuentas
print(f"\nCuentas:")
total_ars = 0
for cuenta in respuesta_api["cliente"]["cuentas"]:
    print(f"  {cuenta['tipo']}: {cuenta['moneda']} {cuenta['saldo']:,}")
    if cuenta["moneda"] == "ARS":
        total_ars += cuenta["saldo"]
print(f"Total ARS: ${total_ars:,}")

# Acceso seguro con .get() encadenado
email = respuesta_api.get("cliente", {}).get("email", "No informado")
print(f"\nEmail: {email}")

Hacé clic en ▶ Ejecutar

Referencia rápida

Operación	Sintaxis	Nota
Crear	`{"k": v}` o `dict(k=v)`	Las claves deben ser únicas
Leer (inseguro)	`d["clave"]`	KeyError si no existe
Leer (seguro)	`d.get("clave", default)`	Devuelve default si no existe
Agregar/Modificar	`d["clave"] = valor`	Crea si no existe, sobreescribe si existe
Eliminar (inseguro)	`del d["clave"]`	KeyError si no existe
Eliminar (seguro)	`d.pop("clave", default)`	Devuelve el valor eliminado
Merge	`d.update(otro_dict)`	Agrega/sobreescribe con otro dict
Claves	`d.keys()`	Vista de claves
Valores	`d.values()`	Vista de valores
Pares	`d.items()`	Vista de (clave, valor)
Pertenencia	`"clave" in d`	`True/False` — O(1)
Largo	`len(d)`	Cantidad de pares
Copiar	`d.copy()`	Copia superficial
Vaciar	`d.clear()`	Elimina todo
Comprehension	`{k:v for k,v in ...}`	Crear dict en una línea

Ejercicios

Nivel 1 · Básico

Ejercicio 1: Crear y acceder

Creá un diccionario producto con claves nombre, precio y stock. Imprimí cada valor. Debe incluir el nombre del producto.

ejercicio_01.pyDebe incluir "Notebook"

# Creá el diccionario e imprimí:
producto = {
    "nombre": "Notebook",
    # completá
}

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 2: .get() seguro

Dado un diccionario de cliente sin campo "email", usá .get() para acceder al email con default "No informado". Debe incluir No informado.

ejercicio_02.pyDebe incluir "No informado"

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

# Accedé al email de forma segura:

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 3: Recorrer con .items()

Dado moneda = {"nombre": "Dólar", "código": "USD", "cotización": 1150}, recorrelo con .items() e imprimí cada par. Debe incluir USD.

ejercicio_03.pyDebe incluir "USD"

moneda = {"nombre": "Dólar", "código": "USD", "cotización": 1150}

# Recorré con .items():

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 4: Agregar, modificar y eliminar

Partiendo de {"nombre": "López", "saldo": 100000}: agregá "ciudad": "Córdoba", modificá saldo a 150000, eliminá ciudad con .pop(). Imprimí el dict final. Debe incluir 150000.

ejercicio_04.pyDebe incluir "150000"

cliente = {"nombre": "López", "saldo": 100000}

# Agregá, modificá, eliminá:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 5: Dict comprehension desde listas

Tenés tickers = ["GGAL", "YPF", "PAMP"] y precios = [5200, 28000, 3100]. Creá un diccionario con dict comprehension y zip. Imprimilo. Debe incluir GGAL.

ejercicio_05.pyDebe incluir "GGAL"

tickers = ["GGAL", "YPF", "PAMP"]
precios = [5200, 28000, 3100]

# Dict comprehension:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 6: Contar frecuencias

Dada transacciones = ["compra", "venta", "compra", "compra", "venta", "transferencia", "compra"], contá cuántas veces aparece cada tipo usando un diccionario. Debe incluir compra y 4.

ejercicio_06.pyDebe incluir "4"

transacciones = ["compra", "venta", "compra", "compra", "venta", "transferencia", "compra"]

# Contá frecuencias:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 7: Filtrar lista de diccionarios

Dada una lista de 4 clientes (dict con nombre, score, saldo), filtrá los que tienen score >= 650 y calculá el saldo promedio de los filtrados. Debe incluir Promedio.

ejercicio_07.pyDebe incluir "Promedio"

clientes = [
    {"nombre": "García", "score": 720, "saldo": 150000},
    {"nombre": "López", "score": 580, "saldo": 45000},
    {"nombre": "Pérez", "score": 810, "saldo": 890000},
    {"nombre": "Sosa", "score": 645, "saldo": 72000},
]

# Filtrá score >= 650 y calculá promedio de saldos:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 8: Diccionario anidado

Creá un diccionario sucursal con "nombre", "ciudad" y "empleados" (lista de dicts con nombre y cargo). Imprimí el nombre del primer empleado accediendo a la estructura anidada. Debe incluir Gerente.

ejercicio_08.pyDebe incluir "Gerente"

# Creá la estructura anidada:
sucursal = {
    # completá
}

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 9: Transformar dict con comprehension

Dado precios_ars = {"Notebook": 920000, "Mouse": 23000, "Teclado": 46000} y DOLAR = 1150, creá un nuevo diccionario con los precios en USD (dividir por DOLAR, redondear a 2 decimales). Debe incluir USD.

ejercicio_09.pyDebe incluir "USD"

precios_ars = {"Notebook": 920000, "Mouse": 23000, "Teclado": 46000}
DOLAR = 1150

# Convertí a USD con dict comprehension:

Hacé clic en ▶ Ejecutar

Nivel 4 · Desafío

Ejercicio 10: Reporte de cartera desde lista de dicts

Dada una lista de 5 clientes (nombre, ciudad, score, saldo), generá un reporte que incluya: tabla con todos los clientes, total de la cartera, promedio por ciudad (agrupación manual), y el cliente con mayor saldo. Debe incluir REPORTE.

ejercicio_10_desafio.pyDebe incluir "REPORTE"

clientes = [
    {"nombre": "García", "ciudad": "BsAs", "score": 720, "saldo": 150000},
    {"nombre": "López", "ciudad": "Córdoba", "score": 680, "saldo": 320000},
    {"nombre": "Martínez", "ciudad": "BsAs", "score": 590, "saldo": 45000},
    {"nombre": "Pérez", "ciudad": "BsAs", "score": 810, "saldo": 890000},
    {"nombre": "Fernández", "ciudad": "Córdoba", "score": 645, "saldo": 72000},
]

# Generá el reporte completo:
print("=== REPORTE DE CARTERA ===")

Hacé clic en ▶ Ejecutar

Resumen y conexión

Los diccionarios guardan pares clave: valor. Se crean con {}. Acceso por clave, no por posición.
Usá .get("clave", default) para acceso seguro (sin KeyError).
Recorrer con .items() es el patrón más común: for k, v in dict.items():
Una lista de diccionarios es la "base de datos en memoria" — el paso previo a DataFrames de pandas.
Dict comprehensions ({k:v for ...}) permiten crear y transformar dicts en una línea.
Los dicts anidados representan JSON — el formato estándar de APIs y datos web.

En la siguiente lección (11 · Sets) vas a aprender la última estructura de datos fundamental: conjuntos sin duplicados, ideales para deduplicar datos y hacer operaciones matemáticas de conjuntos.

Recursos: Python docs — Dictionaries · dict methods

Hecho con ❤️ por Rodri Gonzalez