Mapeos avanzados, conjuntos y persistencia de archivos

Cómo usar esta guía

• Pregunta
• →
• Exploración
• →
• Implementación
• →
• Resultado
• →
• Interpretación
• →
• Verificación

Qué puedes usar esta semana

Lecturas de preparación

• [PCC] Cap. 6 “Dictionaries”. Enfócate en: pares clave-valor, get() con valor por defecto, recorrer con items(), y anidar (lista de diccionarios, diccionario dentro de diccionario).
• [PCC] Cap. 10 “Files and Exceptions”. Enfócate en: leer y escribir con Path, try/except/else, fallar en silencio vs. informar, y guardar datos con json.

Reading checkpoint

Diccionarios: datos con nombre

producto = {"codigo": "A01", "nombre": "Aceite 1 L", "precio": 12.50, "stock": 40}

print(producto["nombre"], "cuesta", producto["precio"])
producto["stock"] -= 5                 # vendimos 5
producto["proveedor"] = "La Ceiba"     # clave nueva
print(producto.get("descuento", 0))    # no existe: valor por defecto

for clave, valor in producto.items():
    print(f"  {clave:<10} {valor}")

Aceite 1 L cuesta 12.5
0
  codigo     A01
  nombre     Aceite 1 L
  precio     12.5
  stock      35
  proveedor  La Ceiba

El problema de la semana 5, en tres líneas

En la semana 5 sumaste las ventas por vendedor con dos listas paralelas. Con un diccionario:

ventas = [("Ana", 120), ("Luis", 80), ("Ana", 200),
          ("Eva", 150), ("Luis", 40), ("Ana", 30)]

totales = {}
for vendedor, monto in ventas:
    totales[vendedor] = totales.get(vendedor, 0) + monto

print(totales)
mejor = max(totales, key=totales.get)
print(f"Mejor vendedor: {mejor} con ${totales[mejor]}")

{'Ana': 350, 'Luis': 120, 'Eva': 150}
Mejor vendedor: Ana con $350

totales.get(vendedor, 0) devuelve 0 la primera vez que aparece un vendedor. Este patrón (acumular por clave) resuelve “total por categoría”, “ventas por mes”, “stock por bodega”… max(totales, key=totales.get) busca la clave cuyo valor es mayor.

Lista de diccionarios: una tabla en memoria

catalogo = [
    {"codigo": "A01", "nombre": "Aceite 1 L", "precio": 12.50, "stock": 40},
    {"codigo": "B07", "nombre": "Arroz 5 lb", "precio": 4.25, "stock": 8},
    {"codigo": "C12", "nombre": "Azúcar 5 lb", "precio": 3.90, "stock": 0},
]

valor_total = 0
for p in catalogo:
    valor_total += p["precio"] * p["stock"]
    if p["stock"] < 10:
        print(f"Reordenar: {p['nombre']} (quedan {p['stock']})")
print(f"Valor del inventario: ${valor_total:,.2f}")

Reordenar: Arroz 5 lb (quedan 8)
Reordenar: Azúcar 5 lb (quedan 0)
Valor del inventario: $534.00

Conjuntos: únicos y comparaciones

clientes_mayo = {"Ana", "Luis", "Eva", "José", "Marta"}
clientes_junio = {"Ana", "Eva", "Carla", "Pedro"}

repiten = clientes_mayo & clientes_junio      # en los dos meses
nuevos = clientes_junio - clientes_mayo        # solo en junio
perdidos = clientes_mayo - clientes_junio      # compraron en mayo y no volvieron
todos = clientes_mayo | clientes_junio

print("Repiten:", sorted(repiten))
print("Nuevos:", sorted(nuevos))
print("Perdidos:", sorted(perdidos))
print(f"Retención: {len(repiten) / len(clientes_mayo):.0%}")
print("Clientes distintos en total:", len(todos))

Repiten: ['Ana', 'Eva']
Nuevos: ['Carla', 'Pedro']
Perdidos: ['José', 'Luis', 'Marta']
Retención: 40%
Clientes distintos en total: 7

Archivos: que los datos sobrevivan

import csv
from pathlib import Path

ruta = Path("ventas.csv")
ruta.write_text("""fecha,categoria,monto
2026-09-01,abarrotes,120.50
2026-09-01,limpieza,45.00
2026-09-02,abarrotes,80.25
2026-09-02,bebidas,60.00
2026-09-03,limpieza,15.75
""")

por_categoria = {}
with ruta.open() as archivo:
    for fila in csv.DictReader(archivo):          # cada fila es un diccionario
        monto = float(fila["monto"])
        por_categoria[fila["categoria"]] = por_categoria.get(fila["categoria"], 0) + monto

for categoria, total in sorted(por_categoria.items()):
    print(f"{categoria:<10} ${total:>8.2f}")

abarrotes  $  200.75
bebidas    $   60.00
limpieza   $   60.75

JSON: guardar estructuras completas

JSON guarda diccionarios y listas (también anidados) tal cual. Es el formato ideal para el estado del proyecto.

import json
from pathlib import Path

ruta = Path("inventario.json")
inventario = {"A01": {"nombre": "Aceite 1 L", "stock": 40},
              "B07": {"nombre": "Arroz 5 lb", "stock": 8}}

ruta.write_text(json.dumps(inventario, indent=2, ensure_ascii=False))   # guardar

cargado = json.loads(ruta.read_text())                                   # cargar
cargado["B07"]["stock"] += 20
print(cargado["B07"])
print(ruta.read_text()[:60], "...")

{'nombre': 'Arroz 5 lb', 'stock': 28}
{
  "A01": {
    "nombre": "Aceite 1 L",
    "stock": 40
  } ...

Excepciones: fallar sin caerse

def pedir_monto(texto):
    """Convierte el texto a monto positivo; devuelve None si no es válido."""
    try:
        monto = float(texto)
    except ValueError:
        print(f"  '{texto}' no es un número.")
        return None
    else:
        if monto <= 0:
            print(f"  {monto} no es un monto positivo.")
            return None
        return monto


for entrada in ["150.75", "diez", "", "-5", "1e3"]:
    print(repr(entrada), "->", pedir_monto(entrada))

'150.75' -> 150.75
  'diez' no es un número.
'diez' -> None
  '' no es un número.
'' -> None
  -5.0 no es un monto positivo.
'-5' -> None
'1e3' -> 1000.0

Cargar datos sin cerrarse

import json
from pathlib import Path


def cargar_inventario(ruta):
    """Carga el inventario; si no existe o está dañado, empieza vacío sin cerrarse."""
    try:
        return json.loads(Path(ruta).read_text())
    except FileNotFoundError:
        print(f"Aviso: {ruta} no existe todavía. Se empieza con un inventario vacío.")
        return {}
    except json.JSONDecodeError:
        print(f"Aviso: {ruta} está dañado. Se empieza vacío (revisa el respaldo).")
        return {}


Path("danado.json").write_text('{"A01": 40, ')      # archivo cortado a la mitad
print(cargar_inventario("no_existe.json"))
print(cargar_inventario("danado.json"))

Aviso: no_existe.json no existe todavía. Se empieza con un inventario vacío.
{}
Aviso: danado.json está dañado. Se empieza vacío (revisa el respaldo).
{}

Lanzar tus propias excepciones con raise

Cuando una función no puede cumplir su trabajo, en vez de devolver un valor raro (None, -1), puede lanzar una excepción con un mensaje claro. Quien la llama decide qué hacer.

def retirar(saldo, monto):
    """Devuelve el nuevo saldo; lanza ValueError si el retiro no es posible."""
    if monto <= 0:
        raise ValueError("el monto debe ser positivo")
    if monto > saldo:
        raise ValueError(f"saldo insuficiente: hay ${saldo}, se pidieron ${monto}")
    return saldo - monto


saldo = 100
for monto in [30, 500, -2]:
    try:
        saldo = retirar(saldo, monto)
        print(f"Retiro de ${monto} aprobado. Saldo: ${saldo}")
    except ValueError as error:
        print(f"Retiro de ${monto} rechazado: {error}")

Retiro de $30 aprobado. Saldo: $70
Retiro de $500 rechazado: saldo insuficiente: hay $70, se pidieron $500
Retiro de $-2 rechazado: el monto debe ser positivo

Tablas de traza

Traza 1 · Un diccionario que cambia

stock = {"A01": 40, "B07": 8}
stock["B07"] -= 3
stock["C12"] = 15
stock["A01"] = stock.get("A01", 0) + 10
total = sum(stock.values())
hay_D = "D05" in stock

Al final, total vale 70 (50 + 5 + 15) y hay_D es False.

Traza 2 · ¿Qué bloque se ejecuta?

Para try: n = int(x) / d con except ValueError, except ZeroDivisionError y else. Escribe ValueError, ZeroDivisionError o else.

• Traza 1 completa.
• Traza 2 completa.

Ejercicios

precios = {"A01": 12.50, "B07": 4.25, "C12": 3.90, "D03": 6.75}

# 1. Subir 5 % todos los precios (redondeados a centavos)
for codigo in precios:
    precios[codigo] = round(precios[codigo] * 1.05, 2)

# 2. Productos de más de $5
caros = {c: p for c, p in precios.items() if p > 5}

# 3. Producto más barato
barato = min(precios, key=precios.get)

print(precios)
print(caros)
print(f"Más barato: {barato} (${precios[barato]})")

{'A01': 13.12, 'B07': 4.46, 'C12': 4.09, 'D03': 7.09}
{'A01': 13.12, 'D03': 7.09}
Más barato: C12 ($4.09)

ventas = [{"mes": "ene", "producto": "Aceite", "monto": 300},
          {"mes": "ene", "producto": "Arroz", "monto": 120},
          {"mes": "feb", "producto": "Aceite", "monto": 450},
          {"mes": "feb", "producto": "Café", "monto": 200},
          {"mes": "mar", "producto": "Arroz", "monto": 90}]

por_mes = {}
por_producto = {}
for v in ventas:
    por_mes[v["mes"]] = por_mes.get(v["mes"], 0) + v["monto"]
    por_producto[v["producto"]] = por_producto.get(v["producto"], 0) + v["monto"]

print("Por mes:", por_mes)
print("Por producto:", por_producto)
lider = max(por_producto, key=por_producto.get)
print(f"Producto líder: {lider} ({por_producto[lider] / sum(por_producto.values()):.0%} de las ventas)")

Por mes: {'ene': 420, 'feb': 650, 'mar': 90}
Por producto: {'Aceite': 750, 'Arroz': 210, 'Café': 200}
Producto líder: Aceite (65% de las ventas)

from pathlib import Path

ruta = Path("bitacora.txt")
if ruta.exists():
    ruta.unlink()          # empezar limpio para el ejemplo


def registrar(mensaje):
    """Agrega una línea al final del archivo sin borrar lo anterior."""
    anterior = ruta.read_text() if ruta.exists() else ""
    ruta.write_text(anterior + mensaje + "\n")


registrar("09:00 Caja abierta")
registrar("09:15 Venta $25.50")
registrar("18:00 Caja cerrada")

lineas = ruta.read_text().splitlines()
print(f"{len(lineas)} registros")
for linea in lineas:
    print(" -", linea)

3 registros
 - 09:00 Caja abierta
 - 09:15 Venta $25.50
 - 18:00 Caja cerrada

import json
from pathlib import Path


def cargar(ruta):
    try:
        datos = json.loads(Path(ruta).read_text())
        total = 0
        for codigo in datos:
            total = total + datos[codigo]["precio"] * datos[codigo]["stock"]
        return total
    except:
        return 0

import json
from pathlib import Path


def cargar(ruta):
    """Lee el inventario; devuelve {} si no existe (primera ejecución)."""
    try:
        return json.loads(Path(ruta).read_text())
    except FileNotFoundError:
        return {}


def valor_inventario(datos):
    """Suma precio x stock; ignora (y reporta) productos incompletos."""
    total = 0
    for codigo, p in datos.items():
        if "precio" not in p or "stock" not in p:
            print(f"Aviso: al producto {codigo} le faltan datos.")
            continue
        total += p["precio"] * p["stock"]
    return total


Path("inv.json").write_text('{"A01": {"precio": 12.5, "stock": 4}, "B07": {"precio": 4.25}}')
print(valor_inventario(cargar("inv.json")))
print(valor_inventario(cargar("no_existe.json")))

Aviso: al producto B07 le faltan datos.
50.0
0

Práctica intensiva

Primero ejercicios rápidos que se corrigen solos; luego problemas tipo laboratorio. Pulsa ▶ Ejecutar en las soluciones y modifícalas con Editar.

Ejercicios rápidos · ¿Qué resulta?

Con d = {"a": 1, "b": 2} cuando aparezca. Escribe el resultado; si da error, escribe el nombre del error.

d["b"]

d.get("c", 0)

d["c"]

len({"x": 1, "x": 2})

d["a"] = 5
d

"a" in d

len({3, 1, 3, 2})

{1, 2, 3} & {2, 3, 4}

int("12.5")

10 / 0

• Completé los ejercicios rápidos sin ejecutar el código.

Problemas tipo examen

import csv
from pathlib import Path

Path("transacciones.csv").write_text("""id,tipo,categoria,monto
1,ingreso,ventas,1500.00
2,gasto,alquiler,600.00
3,gasto,servicios,85.40
4,ingreso,ventas,abc
5,gasto,planilla,900.00
6,retiro,otros,50.00
7,ingreso,ventas,820.00
""")

ingresos = 0
gastos = {}
rechazadas = []
with open("transacciones.csv") as archivo:
    for fila in csv.DictReader(archivo):
        try:
            monto = float(fila["monto"])
        except ValueError:
            rechazadas.append(f"id {fila['id']}: monto inválido '{fila['monto']}'")
            continue
        if fila["tipo"] == "ingreso":
            ingresos += monto
        elif fila["tipo"] == "gasto":
            gastos[fila["categoria"]] = gastos.get(fila["categoria"], 0) + monto
        else:
            rechazadas.append(f"id {fila['id']}: tipo desconocido '{fila['tipo']}'")

total_gastos = sum(gastos.values())
print(f"Ingresos: ${ingresos:,.2f}")
for categoria, monto in sorted(gastos.items(), key=lambda par: par[1], reverse=True):
    print(f"  {categoria:<10} ${monto:>8,.2f}  ({monto / total_gastos:.0%})")
print(f"Utilidad: ${ingresos - total_gastos:,.2f}")
print("Rechazadas:", rechazadas)

Ingresos: $2,320.00
  planilla   $  900.00  (57%)
  alquiler   $  600.00  (38%)
  servicios  $   85.40  (5%)
Utilidad: $734.60
Rechazadas: ["id 4: monto inválido 'abc'", "id 6: tipo desconocido 'retiro'"]

import json
from pathlib import Path

RUTA = Path("stock.json")


def cargar():
    try:
        return json.loads(RUTA.read_text())
    except FileNotFoundError:
        return {}
    except json.JSONDecodeError:
        RUTA.rename("stock_danado.json")          # conservar evidencia
        return {}


def guardar(stock):
    RUTA.write_text(json.dumps(stock, indent=2))


def mover(stock, codigo, cantidad):
    """Suma (entrada) o resta (salida) stock; lanza ValueError si queda negativo."""
    nuevo = stock.get(codigo, 0) + cantidad
    if nuevo < 0:
        raise ValueError(f"{codigo}: no hay suficiente stock ({stock.get(codigo, 0)})")
    stock[codigo] = nuevo


# Primera ejecución: no hay archivo
if RUTA.exists():
    RUTA.unlink()
stock = cargar()
for codigo, cantidad in [("A01", 40), ("B07", 10), ("A01", -15), ("B07", -30)]:
    try:
        mover(stock, codigo, cantidad)
    except ValueError as error:
        print("Rechazado:", error)
guardar(stock)

# "Segunda ejecución": el estado se recupera desde el disco
print("Recuperado:", cargar())

# Archivo dañado: el programa no se cae
RUTA.write_text("{ esto no es JSON")
print("Tras daño:", cargar(), "| respaldo existe:", Path("stock_danado.json").exists())

Rechazado: B07: no hay suficiente stock (10)
Recuperado: {'A01': 25, 'B07': 10}
Tras daño: {} | respaldo existe: True

compras = [("Ana", "A01"), ("Luis", "B07"), ("Ana", "C12"), ("Eva", "A01"),
           ("Luis", "A01"), ("Ana", "A01"), ("Marta", "D03"), ("Eva", "B07")]

productos_por_cliente = {}
for cliente, producto in compras:
    productos_por_cliente.setdefault(cliente, set()).add(producto)

for cliente, productos in sorted(productos_por_cliente.items()):
    print(f"{cliente:<6} {sorted(productos)}")

# ¿Qué productos compró Ana que Eva no? (recomendación para Eva)
recomendar = productos_por_cliente["Ana"] - productos_por_cliente["Eva"]
print("Recomendar a Eva:", sorted(recomendar))

# Clientes que compraron A01 y B07 (combo)
combo = [c for c, ps in productos_por_cliente.items() if {"A01", "B07"} <= ps]
print("Compraron el combo A01 + B07:", sorted(combo))

Ana    ['A01', 'C12']
Eva    ['A01', 'B07']
Luis   ['A01', 'B07']
Marta  ['D03']
Recomendar a Eva: ['C12']
Compraron el combo A01 + B07: ['Eva', 'Luis']

Proyecto integrador · Fase 4

Semana 7 · Persistencia en disco y manejo de errores.

Preguntas de defensa

Rumbo al Control 3

El Control 3 es en la semana 8 (confirma el temario en Moodle). De esta semana, asegúrate de poder:

• Crear, leer, modificar y recorrer diccionarios, y usar get con valor por defecto.
• Aplicar el patrón “acumular por clave”.
• Usar conjuntos para únicos, intersección, unión y diferencia.
• Leer y escribir archivos de texto, CSV y JSON.
• Escribir try/except/else con excepciones específicas y lanzar las propias con raise.

Fuentes

• [PCC] Matthes, E. (2023). Python Crash Course, 3.ª ed. Caps. 6 y 10.
• Python Software Foundation. Tutorial — Errores y excepciones · json · csv.