De list[dict] a tabla

import csv

with open("libros_catalogo.csv", encoding="utf-8", newline="") as f:
    por_filas = list(csv.DictReader(f))

# 1. Orientado a FILAS: una lista de diccionarios. Es lo que devuelve
#    DictReader y lo que viaja en un JSON de una API.
print("orientado a filas: una lista de", len(por_filas), "diccionarios")
print("  por_filas[0] ->", por_filas[0])
print("  un libro entero se lee de una:", por_filas[0]["titulo"])

# 2. Orientado a COLUMNAS: un diccionario de listas. Es como guarda los
#    datos pandas, y por eso hay operaciones que le salen gratis.
por_columnas = {c: [fila[c] for fila in por_filas] for c in por_filas[0]}
print()
print("orientado a columnas: un dict de", len(por_columnas), "listas")
for columna, valores in por_columnas.items():
    print(f"  {columna:<8} {len(valores):>3} valores  {valores[:2]}")

print()
print("Cada forma hace facil una cosa distinta:")
print("  el libro 5 completo   ->", por_filas[4]["titulo"])
print("  todos los anios       ->", por_columnas["anio"][:6], "...")

print()
# Con la lista de dicts, mirar una columna cuesta recorrer todo.
anios = [fila["anio"] for fila in por_filas]
print("sacar una columna de la forma por filas cuesta un recorrido:")
print("  [fila['anio'] for fila in por_filas] ->", anios[:6], "...")
print("sacarla de la forma por columnas es un acceso:")
print("  por_columnas['anio'] -> lo mismo, sin recorrer nada")

print()
print("Y al reves: reconstruir la fila 5 desde las columnas obliga a")
print("visitar las 5 listas.")
fila5 = {c: por_columnas[c][4] for c in por_columnas}
print("  ", fila5)
print("  ¿coincide con por_filas[4]?", fila5 == por_filas[4])

print()
print("Ninguna de las dos es 'la correcta'. pandas elige la segunda porque")
print("casi todo lo que hace un analisis es una operacion por columna:")
print("promediar, contar distintos, convertir tipos, filtrar por un valor.")

import csv

with open("asistencia_sesiones.csv", encoding="utf-8", newline="") as f:
    ancho = list(csv.DictReader(f))

print("FORMA ANCHA, que es como viene el archivo:")
print("  columnas:", len(ancho[0]), "| filas:", len(ancho))
print("  ", list(ancho[0])[:5], "...")
for fila in ancho[:2]:
    valores = [fila[c] for c in fila if c.startswith("sesion")]
    print(f"   {fila['legajo']}  {fila['estudiante']:<18} {valores}")

print()
print("Comoda para leer de un vistazo, y con un problema: las 12 columnas")
print("de sesion son la MISMA variable medida 12 veces. El numero de sesion")
print("esta en el NOMBRE de la columna, no en un dato.")
print()
print("Por eso 'la asistencia de la sesion 7' obliga a nombrar la columna a")
print("mano, y '¿cuantas sesiones hubo?' se contesta contando columnas.")

# La forma larga pone esa variable donde corresponde: en una columna.
largo = []
for fila in ancho:
    for columna, valor in fila.items():
        if columna.startswith("sesion"):
            largo.append({
                "legajo": fila["legajo"],
                "estudiante": fila["estudiante"],
                "sesion": int(columna.split("_")[1]),
                "estado": valor,
            })

print()
print("FORMA LARGA, la misma informacion:")
print("  columnas:", len(largo[0]), "| filas:", len(largo),
      f"= {len(ancho)} estudiantes x 12 sesiones")
for registro in largo[:4]:
    print("  ", registro)

print()
print("Ahora las tres preguntas se contestan sin tocar nombres de columna:")
print("  sesiones distintas :", len({r['sesion'] for r in largo}))
print("  registros de la 7  :", sum(1 for r in largo if r["sesion"] == 7))
print("  presentes totales  :", sum(1 for r in largo if r["estado"] == "P"))

print()
print("Las tres reglas de los datos ordenados:")
print("  1. cada VARIABLE es una columna")
print("  2. cada OBSERVACION es una fila")
print("  3. cada tipo de unidad observada, su propia tabla")
print()
print("La forma ancha se lee mejor; la larga se procesa mejor. En la unidad")
print("6, melt() y pivot_table() son exactamente este ida y vuelta.")

import collections
import csv

NULOS = {"", "-", "N/A", "NaN", "null"}


def clasificar(texto):
    """Que clase de dato parece este texto."""
    crudo = texto.strip()
    if crudo in NULOS:
        return "ausente"
    try:
        int(crudo)
        return "entero"
    except ValueError:
        pass
    try:
        float(crudo)
        return "decimal"
    except ValueError:
        return "texto"


with open("clientes_crudos.csv", encoding="utf-8", newline="") as f:
    filas = list(csv.DictReader(f))

print(f"clientes_crudos.csv: {len(filas)} filas\n")
print(f"{'columna':<12} {'clases':<40} homogenea")
print("-" * 62)
for columna in filas[0]:
    clases = collections.Counter(clasificar(x[columna]) for x in filas)
    utiles = {c for c in clases if c != "ausente"}
    resumen = ", ".join(f"{c}:{n}" for c, n in sorted(clases.items()))
    print(f"{columna:<12} {resumen:<40} {'si' if len(utiles) == 1 else 'NO'}")

print()
print("La columna edad tiene enteros Y texto. Eso no es un detalle de")
print("formato: significa que la columna NO tiene un tipo, y por lo tanto")
print("no se le puede pedir un promedio.")

edades = [x["edad"] for x in filas]
sospechosos = [v for v in edades if clasificar(v) == "texto"]
print()
print("los valores de texto en edad:",
      dict(collections.Counter(sospechosos)))

print()
print("Y esta es la consecuencia concreta:")
numericas = [int(v) for v in edades if clasificar(v) == "entero"]
print("  edades que si son numero:", len(numericas), "de", len(edades))
print("  promedio sobre esas     :", round(sum(numericas) / len(numericas), 2))
print("  ordenar la columna como texto pondria '9' despues de '85':",
      sorted({"9", "85", "100"}))

print()
print("Una tabla es una lista de filas MAS la promesa de que cada columna")
print("tiene un solo tipo. El archivo trae lo primero; lo segundo hay que")
print("conseguirlo, y es todo el trabajo de la unidad 5.")

import csv
import json

# Un CSV siempre da filas con las mismas claves: la cabecera las fija.
with open("libros_catalogo.csv", encoding="utf-8", newline="") as f:
    del_csv = list(csv.DictReader(f))
claves_csv = {tuple(sorted(fila)) for fila in del_csv}
print("desde un CSV: formas distintas de fila ->", len(claves_csv))
print("  siempre las mismas 5 claves, porque la cabecera manda.")

# Un JSON no promete nada de eso: cada objeto trae lo que quiso traer.
with open("usuarios_perfiles.json", encoding="utf-8") as f:
    del_json = json.load(f)["usuarios"]

formas = {}
for usuario in del_json:
    llave = tuple(sorted((usuario.get("preferencias") or {})))
    formas.setdefault(llave, []).append(usuario["id"])

print()
print("desde un JSON: formas distintas de 'preferencias' ->", len(formas))
for llave, ids in sorted(formas.items(), key=lambda t: -len(t[1])):
    print(f"   {len(ids):>2} usuarios  claves {list(llave)}  ids {ids}")

print()
print("Para armar una TABLA hay que decidir tres cosas que el archivo no dice:")
print()
print("1. Que columnas hay. La union de las claves, o la interseccion.")
todas, comunes = set(), None
for usuario in del_json:
    claves = set((usuario.get("preferencias") or {}))
    todas |= claves
    comunes = claves if comunes is None else comunes & claves
print("   union       :", sorted(todas), "-> 3 columnas, con huecos")
print("   interseccion:", sorted(comunes), "-> 0 columnas, sin huecos")
print("   La union con huecos es lo que hace pandas, y casi siempre es")
print("   lo que se quiere: perder columnas es peor que tener NaN.")

print()
print("2. Que valor va donde no habia clave. NO es lo mismo que un null")
print("   que si vino en el archivo, y la tabla los va a mostrar igual.")

print()
print("3. En que orden van las filas. Una lista tiene orden; un conjunto")
print("   de registros, no. Si el orden importa, hay que declararlo.")

print()
tabla = []
for usuario in del_json:
    prefs = usuario.get("preferencias") or {}
    tabla.append({"id": usuario["id"],
                  **{c: prefs.get(c, "") for c in sorted(todas)}})
print("la tabla resultante, primeras 4 filas:")
print(f"   {'id':>3} {'idioma':<8} {'notificaciones':<15} tema")
for fila in tabla[:4]:
    print(f"   {fila['id']:>3} {fila['idioma']:<8} "
          f"{str(fila['notificaciones']):<15} {fila['tema']}")
print("   ...")
for fila in tabla[11:13]:
    print(f"   {fila['id']:>3} {fila['idioma']:<8} "
          f"{str(fila['notificaciones']):<15} {fila['tema']}")
print()
print("El usuario 12 no traia 'idioma' y el 13 no traia 'preferencias':")
print("los dos quedan con la celda vacia, y la tabla ya no distingue")
print("cual de los dos casos era. Esa perdida es una decision, no un bug.")