Python · Lección 15 de 27

Anidación de estructuras

En el mundo real los datos no vienen planos: vienen como listas dentro de listas, diccionarios dentro de diccionarios, listas de diccionarios con listas adentro. Esta lección te enseña a construir, navegar y transformar cualquier estructura anidada — la habilidad que necesitás para trabajar con JSON y pandas.

90–120 min Prerrequisitos: 08 Listas, 10 Diccionarios, 14 Métodos de dicts

Concepto teórico

¿Qué es la anidación?

Anidar significa poner una estructura de datos dentro de otra. Python te permite combinar listas, tuplas, diccionarios y sets en cualquier profundidad. Los cuatro patrones de anidación que vas a usar constantemente son:

Lista de listas — una matriz o tabla: [[1,2],[3,4],[5,6]]
Lista de diccionarios — registros/filas de una tabla: [{"nombre": "García", "score": 720}, ...]
Diccionario de diccionarios — datos jerárquicos / JSON: {"cliente": {"nombre": "García", "scoring": {"valor": 720}}}
Diccionario de listas — columnas de una tabla: {"nombre": ["García","López"], "score": [720,680]}

¿Por qué esto importa tanto? Porque un DataFrame de pandas es internamente un diccionario de listas (patrón 4). Cuando hacés pd.DataFrame(data), data puede ser cualquiera de estos 4 patrones. Y cuando consumís una API REST, la respuesta JSON es siempre una combinación de patrones 2 y 3. Dominar anidación = dominar el formato de TODOS tus datos.

Lista de listas — la "matriz"

Una lista de listas representa una tabla bidimensional, como una hoja de cálculo. Cada sublista es una "fila":

# Cada fila: [nombre, edad, score, saldo]
tabla = [
    ["García",    35, 720, 150000],
    ["López",     42, 680, 320000],
    ["Martínez",  28, 590,  45000],
]
# Acceso: tabla[fila][columna]
print(tabla[0][0])   # "García"  (fila 0, columna 0)
print(tabla[1][3])   # 320000    (fila 1, columna 3)
print(tabla[2][2])   # 590       (fila 2, columna 2)

El problema de las listas de listas es que tenés que recordar qué posición es cada campo. tabla[1][3] no dice nada — ¿es el saldo? ¿la edad? Por eso, para datos con campos nombrados, se prefiere la lista de diccionarios.

Lista de diccionarios — la "base de datos en memoria"

Este es el patrón más importante de todo el curso. Cada diccionario es un registro (fila) con campos nombrados (columnas):

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},
]
# Acceso claro y descriptivo:
print(clientes[0]["nombre"])  # "García"
print(clientes[1]["saldo"])   # 320000

Analogía exacta: una lista de diccionarios es literalmente una tabla de base de datos. Cada diccionario es una fila, cada clave es un nombre de columna. Cuando hagas pd.DataFrame(clientes), pandas la convierte en una tabla perfecta automáticamente. Y cuando hagas df.to_dict("records"), obtenés de vuelta esta misma estructura.

Diccionario de diccionarios — datos jerárquicos (JSON)

Cuando los datos tienen estructura jerárquica (un cliente tiene scoring, el scoring tiene subcampos), usás diccionarios dentro de diccionarios:

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

Peligro de acceso directo: si alguna clave intermedia no existe, toda la cadena explota con KeyError. Para acceso seguro, usá .get() encadenado: cliente.get("scoring", {}).get("valor", 0). Si "scoring" no existe, el {} evita que el segundo .get() falle.

Diccionario de listas — formato columnar

Cada clave es una columna y su valor es la lista de datos de esa columna. Este es el formato que pandas usa internamente:

datos_columnar = {
    "nombre": ["García", "López", "Martínez"],
    "score":  [720, 680, 590],
    "saldo":  [150000, 320000, 45000],
}
# pd.DataFrame(datos_columnar) → tabla perfecta

Patrones de recorrido profundo

Para recorrer estructuras anidadas necesitás for anidados. La regla es simple: un for por cada nivel de anidación:

Lista simple: 1 for
Lista de listas: 2 for
Lista de dicts: 1 for + acceso por clave
Dict de dicts: 1 for (sobre .items()) + acceso a subniveles

Tip profesional: si te encontrás con más de 3 niveles de for anidados, es señal de que necesitás refactorizar. Extraé el loop interno a una función con nombre descriptivo. Esto mejora la legibilidad enormemente.

En el trabajo real: las APIs de bancos, fintechs y servicios financieros devuelven JSON con 4-5 niveles de anidación. Saber navegar estas estructuras con .get() encadenado, list comprehensions sobre sublistas, y extracciones selectivas es una habilidad que usás todos los días como analista.

Ejemplos explicados paso a paso

Ejemplo 1: Lista de listas — operaciones sobre tabla

ejemplo_01_matriz.pyPython

# Tabla como lista de listas
# [nombre, ciudad, score, saldo]
tabla = [
    ["García",    "BsAs",    720, 150000],
    ["López",     "Córdoba", 680, 320000],
    ["Martínez",  "Rosario", 590,  45000],
    ["Pérez",     "BsAs",    810, 890000],
    ["Fernández", "Mendoza", 645,  72000],
]

# Acceso individual
print(f"Primer cliente: {tabla[0][0]}")
print(f"Saldo del tercero: ${tabla[2][3]:,}")

# Recorrer toda la tabla
print(f"\n{'Nombre':<12} {'Ciudad':<10} {'Score':>6} {'Saldo':>12}")
print(f"{'─'*44}")
for fila in tabla:
    print(f"{fila[0]:<12} {fila[1]:<10} {fila[2]:>6} ${fila[3]:>10,}")

# Extraer una "columna" (todos los saldos)
saldos = [fila[3] for fila in tabla]
print(f"\nSaldos: {saldos}")
print(f"Total: ${sum(saldos):,}")
print(f"Promedio: ${sum(saldos)/len(saldos):,.0f}")

# Filtrar filas: solo BsAs
bsas = [fila for fila in tabla if fila[1] == "BsAs"]
print(f"\nClientes en BsAs: {len(bsas)}")
for f in bsas:
    print(f"  {f[0]}: ${f[3]:,}")

Hacé clic en ▶ Ejecutar

Ejemplo 2: Lista de diccionarios — la estructura estrella

ejemplo_02_lista_dicts.pyPython

# "Base de datos" de clientes
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},
]

# Tabla legible (acceso por nombre de campo, no por posición)
print(f"{'Nombre':<12} {'Ciudad':<10} {'Score':>6} {'Saldo':>12}")
print(f"{'─'*44}")
for c in clientes:
    print(f"{c['nombre']:<12} {c['ciudad']:<10} {c['score']:>6} ${c['saldo']:>10,}")

# "SELECT" — extraer una columna
nombres = [c["nombre"] for c in clientes]
print(f"\nNombres: {nombres}")

# "WHERE" — filtrar
aprobados = [c for c in clientes if c["score"] >= 650]
print(f"\nAprobados ({len(aprobados)}):")
for c in aprobados:
    print(f"  {c['nombre']}: {c['score']}")

# "ORDER BY" — ordenar
por_saldo = sorted(clientes, key=lambda c: c["saldo"], reverse=True)
print(f"\nTop 3 por saldo:")
for i, c in enumerate(por_saldo[:3], 1):
    print(f"  {i}. {c['nombre']}: ${c['saldo']:,}")

# "GROUP BY" — agrupar (manual)
from collections import defaultdict
por_ciudad = defaultdict(list)
for c in clientes:
    por_ciudad[c["ciudad"]].append(c["saldo"])

print(f"\nSaldo promedio por ciudad:")
for ciudad, saldos in sorted(por_ciudad.items()):
    prom = sum(saldos) / len(saldos)
    print(f"  {ciudad}: ${prom:,.0f} ({len(saldos)} clientes)")

Hacé clic en ▶ Ejecutar

Ejemplo 3: Diccionario anidado — navegando JSON

ejemplo_03_json.pyPython

# Respuesta típica de una API bancaria (JSON)
respuesta = {
    "status": "ok",
    "timestamp": "2025-03-15T10:30:00",
    "data": {
        "cliente": {
            "id": 12345,
            "nombre": "García",
            "documento": {"tipo": "DNI", "numero": "30123456"},
            "scoring": {
                "valor": 720,
                "categoria": "A",
                "fecha_calculo": "2025-01-15"
            }
        },
        "cuentas": [
            {"numero": "001-12345", "tipo": "CA$", "moneda": "ARS", "saldo": 150000},
            {"numero": "001-12346", "tipo": "CA USD", "moneda": "USD", "saldo": 5000},
            {"numero": "001-12347", "tipo": "CC$", "moneda": "ARS", "saldo": -12000},
        ],
        "tarjetas": [
            {"marca": "Visa", "tipo": "Crédito", "limite": 500000, "consumo": 185000}
        ]
    }
}

# Navegar la estructura
print(f"Status: {respuesta['status']}")
print(f"Cliente: {respuesta['data']['cliente']['nombre']}")
print(f"DNI: {respuesta['data']['cliente']['documento']['numero']}")
print(f"Score: {respuesta['data']['cliente']['scoring']['valor']}")

# Recorrer las cuentas
print(f"\n{'Tipo':<8} {'Moneda':<6} {'Saldo':>12}")
print(f"{'─'*30}")
for cuenta in respuesta["data"]["cuentas"]:
    print(f"{cuenta['tipo']:<8} {cuenta['moneda']:<6} {cuenta['saldo']:>12,}")

# Saldo total en ARS
total_ars = sum(
    c["saldo"] for c in respuesta["data"]["cuentas"]
    if c["moneda"] == "ARS"
)
print(f"Total ARS: ${total_ars:,}")

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

# Tarjeta: consumo vs límite
for t in respuesta["data"]["tarjetas"]:
    uso_pct = t["consumo"] / t["limite"] * 100
    print(f"\n{t['marca']} {t['tipo']}: {uso_pct:.0f}% usado (${t['consumo']:,}/${t['limite']:,})")

Hacé clic en ▶ Ejecutar

Ejemplo 4: Construir estructura anidada desde datos planos

ejemplo_04_construir.pyPython

from collections import defaultdict

# Datos planos (como vendrían de un CSV con JOIN)
registros = [
    ("García", "BsAs", "Cuenta", 150000),
    ("García", "BsAs", "Tarjeta", 0),
    ("García", "BsAs", "Plazo fijo", 500000),
    ("López", "Córdoba", "Cuenta", 320000),
    ("López", "Córdoba", "Préstamo", -150000),
    ("Pérez", "BsAs", "Cuenta", 890000),
]

# Construir estructura anidada (agrupando por cliente)
clientes = {}
for nombre, ciudad, producto, saldo in registros:
    if nombre not in clientes:
        clientes[nombre] = {
            "nombre": nombre,
            "ciudad": ciudad,
            "productos": [],
            "saldo_total": 0,
        }
    clientes[nombre]["productos"].append({"tipo": producto, "saldo": saldo})
    clientes[nombre]["saldo_total"] += saldo

# Mostrar resultado
print("=== Estructura anidada ===")
for nombre, datos in clientes.items():
    print(f"\n{nombre} ({datos['ciudad']}) — Total: ${datos['saldo_total']:,}")
    for p in datos["productos"]:
        print(f"  · {p['tipo']}: ${p['saldo']:,}")

# Ahora tenemos una estructura rica que podemos consultar fácilmente
# ¿Quién tiene más productos?
top = max(clientes.values(), key=lambda c: len(c["productos"]))
print(f"\nMás productos: {top['nombre']} ({len(top['productos'])})")

Hacé clic en ▶ Ejecutar

Ejemplo 5: Comprehensions sobre estructuras anidadas

ejemplo_05_comprehensions.pyPython

clientes = [
    {"nombre": "García", "cuentas": [{"tipo": "CA$", "saldo": 150000}, {"tipo": "PF", "saldo": 500000}]},
    {"nombre": "López",  "cuentas": [{"tipo": "CA$", "saldo": 320000}]},
    {"nombre": "Pérez",  "cuentas": [{"tipo": "CA$", "saldo": 890000}, {"tipo": "CA USD", "saldo": 5000}]},
]

# Extraer todos los saldos de todas las cuentas (aplanar)
todos_saldos = [
    cuenta["saldo"]
    for cliente in clientes
    for cuenta in cliente["cuentas"]
]
print(f"Todos los saldos: {todos_saldos}")
print(f"Total general: ${sum(todos_saldos):,}")

# Extraer pares (nombre, saldo) para cada cuenta
detalle = [
    (cliente["nombre"], cuenta["tipo"], cuenta["saldo"])
    for cliente in clientes
    for cuenta in cliente["cuentas"]
]
print(f"\nDetalle:")
for nombre, tipo, saldo in detalle:
    print(f"  {nombre} | {tipo}: ${saldo:,}")

# Solo cuentas en ARS con saldo > 200K
grandes_ars = [
    f"{c['nombre']}: ${cta['saldo']:,}"
    for c in clientes
    for cta in c["cuentas"]
    if cta["tipo"] == "CA$" and cta["saldo"] > 200000
]
print(f"\nGrandes CA$ (>$200K): {grandes_ars}")

# Saldo total por cliente (dict comprehension)
totales = {
    c["nombre"]: sum(cta["saldo"] for cta in c["cuentas"])
    for c in clientes
}
print(f"\nTotal por cliente: {totales}")

Hacé clic en ▶ Ejecutar

Referencia rápida

Patrón	Estructura	Acceso	Uso principal
Lista de listas	`[[1,2],[3,4]]`	`m[fila][col]`	Matrices, tablas sin encabezado
Lista de dicts	`[{"k":v}, ...]`	`lista[i]["clave"]`	Registros/filas de tabla (el más usado)
Dict de dicts	`{"a": {"b": v}}`	`d["a"]["b"]`	JSON, datos jerárquicos
Dict de listas	`{"col": [v1,v2]}`	`d["col"][i]`	Formato columnar (pandas interno)

Operación	Sintaxis
Extraer columna de lista de dicts	`[d["campo"] for d in lista]`
Filtrar registros	`[d for d in lista if d["campo"] > x]`
Aplanar lista de listas	`[x for sub in lista for x in sub]`
Aplanar sublistas de dicts	`[item for d in lista for item in d["sublista"]]`
Acceso seguro profundo	`d.get("a", {}).get("b", default)`
Convertir a DataFrame	`pd.DataFrame(lista_de_dicts)`

Ejercicios

Nivel 1 · Básico

Ejercicio 1: Acceso a lista de listas

Dada tabla = [["GGAL",5200],["YPF",28000],["PAMP",3100]], imprimí el nombre y precio de cada acción. Debe incluir 28000.

ejercicio_01.pyDebe incluir "28000"

tabla = [["GGAL", 5200], ["YPF", 28000], ["PAMP", 3100]]

# Recorré e imprimí:

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 2: Acceso a lista de dicts

Dada clientes = [{"nombre":"García","score":720},{"nombre":"López","score":680}], imprimí cada nombre con su score. Debe incluir García.

ejercicio_02.pyDebe incluir "García"

clientes = [
    {"nombre": "García", "score": 720},
    {"nombre": "López", "score": 680},
]

# Recorré e imprimí:

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 3: Acceso a dict anidado

Dado data = {"cliente": {"nombre": "Pérez", "scoring": {"valor": 810}}}, imprimí el nombre y el valor del scoring accediendo con claves encadenadas. Debe incluir 810.

ejercicio_03.pyDebe incluir "810"

data = {"cliente": {"nombre": "Pérez", "scoring": {"valor": 810}}}

# Accedé al nombre y al score:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 4: Extraer columna de lista de dicts

De la lista de clientes, extraé todos los saldos en una lista usando comprehension. Calculá el total. Debe incluir 1477000.

ejercicio_04.pyDebe incluir "1477000"

clientes = [
    {"nombre": "García",    "saldo": 150000},
    {"nombre": "López",     "saldo": 320000},
    {"nombre": "Martínez",  "saldo": 45000},
    {"nombre": "Pérez",     "saldo": 890000},
    {"nombre": "Fernández", "saldo": 72000},
]

# Extraé saldos y sumá:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 5: Filtrar lista de dicts con comprehension

De la misma lista, filtrá los clientes con saldo > $100K e imprimí sus nombres. Debe incluir Pérez.

ejercicio_05.pyDebe incluir "Pérez"

clientes = [
    {"nombre": "García",    "saldo": 150000},
    {"nombre": "López",     "saldo": 320000},
    {"nombre": "Martínez",  "saldo": 45000},
    {"nombre": "Pérez",     "saldo": 890000},
    {"nombre": "Fernández", "saldo": 72000},
]

# Filtrá > $100K:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 6: Aplanar lista de listas

Dada cuentas = [[150000, 500000], [320000], [890000, 5000, 12000]], aplanalas en una sola lista y calculá el total. Debe incluir 1877000.

ejercicio_06.pyDebe incluir "1877000"

cuentas = [[150000, 500000], [320000], [890000, 5000, 12000]]

# Aplana y sumá:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 7: Acceso seguro con .get() encadenado

Dado un dict donde algunos campos pueden no existir, accedé de forma segura al scoring, email y teléfono con defaults. Debe incluir No informado.

ejercicio_07.pyDebe incluir "No informado"

cliente = {
    "nombre": "García",
    "scoring": {"valor": 720, "fecha": "2025-01-15"},
    # NO tiene "contacto" ni "email"
}

# Acceso seguro:
score = # accedé al scoring valor con default 0
email = # accedé a contacto > email con default "No informado"
print(f"Score: {score}")
print(f"Email: {email}")

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 8: Construir lista de dicts desde datos planos

Dados nombres = ["García","López","Pérez"], scores = [720,680,810], saldos = [150000,320000,890000], construí una lista de diccionarios con campos nombre, score, saldo. Debe incluir 810.

ejercicio_08.pyDebe incluir "810"

nombres = ["García", "López", "Pérez"]
scores = [720, 680, 810]
saldos = [150000, 320000, 890000]

# Construí la lista de dicts:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 9: Comprehension sobre sublistas de dicts

Dados clientes con sublista de cuentas, extraé TODAS las cuentas como tuplas (nombre_cliente, tipo_cuenta, saldo) con una comprehension anidada. Debe incluir CA$.

ejercicio_09.pyDebe incluir "CA$"

clientes = [
    {"nombre": "García", "cuentas": [{"tipo": "CA$", "saldo": 150000}, {"tipo": "PF", "saldo": 500000}]},
    {"nombre": "López",  "cuentas": [{"tipo": "CA$", "saldo": 320000}]},
]

# Extraé todas las cuentas como (nombre, tipo, saldo):

Hacé clic en ▶ Ejecutar

Nivel 4 · Desafío

Ejercicio 10: Reporte completo desde API simulada

Procesá esta respuesta de API simulada: extraé el nombre del cliente, su score, listá todas las cuentas con su saldo, calculá el saldo total, y verificá si el uso de tarjeta supera el 80% del límite. Debe incluir REPORTE.

ejercicio_10_desafio.pyDebe incluir "REPORTE"

api_response = {
    "status": "ok",
    "data": {
        "cliente": {
            "nombre": "Pérez",
            "scoring": {"valor": 810, "categoria": "A"},
        },
        "cuentas": [
            {"tipo": "CA$", "saldo": 890000},
            {"tipo": "CA USD", "saldo": 5000},
            {"tipo": "CC$", "saldo": -15000},
        ],
        "tarjetas": [
            {"marca": "Visa", "limite": 500000, "consumo": 420000},
            {"marca": "Mastercard", "limite": 300000, "consumo": 180000},
        ]
    }
}

# Procesá y generá reporte:
print("=== REPORTE ===")

Hacé clic en ▶ Ejecutar

Resumen y conexión

Los 4 patrones de anidación son: lista de listas (matriz), lista de dicts (tabla), dict de dicts (JSON), dict de listas (columnar).
La lista de diccionarios es el patrón más importante — es la "base de datos en memoria" y el input directo de pd.DataFrame().
Acceso profundo: encadená [] o usá .get() encadenado para seguridad.
Comprehensions anidadas ([x for sub in lista for x in sub]) aplanan y extraen datos de estructuras complejas.
Construir estructuras anidadas desde datos planos es un patrón fundamental para preparar datos.

En la siguiente lección (16 · While) vas a aprender el primer bucle con condición: cómo repetir código mientras se cumpla una condición, simulaciones financieras mes a mes, y patrones de validación de input.

Recursos: Nested List Comprehensions · JSON module

Hecho con ❤️ por Rodri Gonzalez