JSON con el módulo json

import json

with open("usuarios_perfiles.json", encoding="utf-8") as f:
    datos = json.load(f)

print("la raiz es un", type(datos).__name__, "con claves", list(datos))

usuarios = datos["usuarios"]
print("usuarios:", len(usuarios))

primero = usuarios[0]
print()
print("un usuario:")
for clave, valor in primero.items():
    print(f"  {clave:<14} {type(valor).__name__:<5} {valor!r:.46}")

print()
print("Los tipos ya vienen convertidos, a diferencia del CSV:")
print("  edad     ->", type(primero["edad"]).__name__, primero["edad"])
print("  activo   ->", type(primero["activo"]).__name__, primero["activo"])

print()
print("Y se navega como cualquier dict o lista de Python:")
print("  preferencias['tema'] ->", primero["preferencias"]["tema"])
print("  habilidades[0]       ->", primero["habilidades"][0])
print("  cuantas habilidades  ->", len(primero["habilidades"]))

print()
print("Correspondencia de tipos JSON -> Python:")
muestra = json.loads('{"a": 1, "b": 2.5, "c": "texto", "d": true,'
                     ' "e": null, "f": [1, 2], "g": {"h": 1}}')
for clave, valor in muestra.items():
    print(f"  {clave} -> {type(valor).__name__}")
print("  ojo: null se convierte en None, no en '' ni en 0.")

import datetime
import json

registro = {
    "titulo": "Programación en Ñandú",
    "anio": 2026,
    "precio": 57.24,
    "agotado": False,
    "autor": None,
    "temas": ["búsqueda", "árboles"],
}

print("por defecto, ensure_ascii=True escapa todo lo no ASCII:")
print(" ", json.dumps(registro))

print()
print("con ensure_ascii=False el archivo queda legible:")
print(" ", json.dumps(registro, ensure_ascii=False))

print()
print("y con indent= queda legible para una persona:")
print(json.dumps(registro, ensure_ascii=False, indent=2))

print()
print("Las dos formas se leen igual: el escape es JSON valido.")
print("  vuelven iguales ->",
      json.loads(json.dumps(registro)) == json.loads(
          json.dumps(registro, ensure_ascii=False)))

print()
print("JSON tiene menos tipos que Python. Ida y vuelta no siempre vuelve:")
mixto = {"tupla": (1, 2), 10: "clave numerica"}
ida = json.dumps(mixto)
print("  antes :", mixto)
print("  ida   :", ida)
print("  vuelta:", json.loads(ida))
print("  la tupla volvio como list y la clave 10 como '10'.")

print()
print("Y hay tipos que directamente no puede escribir:")
for valor in (datetime.date(2026, 8, 28), {1, 2, 3}, 3 + 4j):
    try:
        json.dumps(valor)
    except TypeError as error:
        print(f"  {type(valor).__name__:<8} -> TypeError: {error}")

print()
# default= recibe lo que json no sabe convertir y devuelve algo que si.
print("default= resuelve el caso de las fechas:")
con_fecha = {"alta": datetime.date(2026, 8, 28)}
print(" ", json.dumps(con_fecha, default=str))
print("  ...pero al leerlo de vuelta es un str: la fecha hay que")
print("  reconstruirla a mano. JSON no tiene tipo fecha.")

import json

with open("usuarios_perfiles.json", encoding="utf-8") as f:
    usuarios = json.load(f)["usuarios"]

# En un CSV todas las filas tienen las mismas columnas. En JSON cada
# objeto trae las claves que quiso traer, y hay que mirar nivel por nivel.
arriba = set()
for usuario in usuarios:
    arriba |= set(usuario)
print("nivel de arriba:", sorted(arriba))
print("   todos los", len(usuarios), "usuarios traen las 6 ->",
      all(set(u) == arriba for u in usuarios))

adentro = set()
for usuario in usuarios:
    adentro |= set(usuario["preferencias"] or {})
print()
print("nivel de adentro (preferencias):", sorted(adentro))
for usuario in usuarios:
    faltan = sorted(adentro - set(usuario["preferencias"] or {}))
    if faltan:
        print("   id", usuario["id"], "-> le faltan", faltan,
              "|", usuario["preferencias"])

print()
print("Y los null sueltos, que no son lo mismo que una clave ausente:")
for usuario in usuarios:
    for clave, valor in usuario.items():
        if valor is None:
            print("   id", usuario["id"], "->", clave, "= None")

print()
print("La diferencia importa porque get() con default no cubre el null:")
u3 = next(u for u in usuarios if u["id"] == 3)
print("  'edad' in u3        ->", "edad" in u3)
print("  u3.get('edad', 0)   ->", u3.get("edad", 0), "  <- el default NO se usa")
print("  u3.get('telefono',0)->", u3.get("telefono", 0), "  <- aca si")

print()
print("Por eso navegar anidado a lo bruto se rompe con el usuario 13:")
try:
    for usuario in usuarios:
        usuario["preferencias"]["tema"]
except TypeError as error:
    print("   TypeError:", error)

print()
print("La forma que aguanta las dos situaciones:")
for usuario in usuarios:
    tema = (usuario.get("preferencias") or {}).get("tema", "(sin definir)")
    if tema == "(sin definir)" or usuario["id"] <= 2:
        print("   id", usuario["id"], "->", tema)

print()
edades = [u["edad"] for u in usuarios if isinstance(u.get("edad"), int)]
print("edades usables:", len(edades), "de", len(usuarios),
      "| promedio:", round(sum(edades) / len(edades), 1))

import json

# 1. json.loads lee de una cadena; json.load, de un archivo abierto.
#    Es la unica diferencia, y la "s" es de "string".
print("loads sobre una cadena:", json.loads('{"a": 1}'))

print()
print("Los errores de sintaxis dicen linea y columna:")
malos = [
    ('{"a": 1,}', "coma de mas al final"),
    ("{'a': 1}", "comillas simples: JSON exige dobles"),
    ('{"a": 1, "a": 2}', "clave repetida (esto NO falla)"),
    ('{"a": NaN}', "NaN (Python lo acepta, otros lenguajes no)"),
    ("", "archivo vacio"),
]
for texto, comentario in malos:
    try:
        valor = json.loads(texto)
        print(f"  {texto!r:<20} -> ok: {valor!r}   ({comentario})")
    except json.JSONDecodeError as error:
        print(f"  {texto!r:<20} -> {error.msg}: linea {error.lineno},"
              f" columna {error.colno}   ({comentario})")

print()
print("La clave repetida gana la ultima y no avisa nunca. Y NaN e Infinity")
print("los acepta Python pero no son JSON estandar: escribirlos produce un")
print("archivo que otros lenguajes rechazan.")

print()
# 2. Un JSON valido puede traer, adentro, texto sin estructurar. El
#    parseo entonces tiene DOS etapas, y la segunda es tuya.
with open("servidor_acceso_log.json", encoding="utf-8") as f:
    log = json.load(f)

print("claves del log:", list(log))
print("lineas:", len(log["lineas"]))
print("el JSON esta perfecto, pero cada elemento es una cadena cruda:")
for linea in log["lineas"][:3]:
    print("  ", repr(linea))

print()
partidas = [x.split() for x in log["lineas"]]
largos = {}
for campos in partidas:
    largos[len(campos)] = largos.get(len(campos), 0) + 1
print("campos por linea:", largos)
print("json.load no valida NADA de eso: para el, son cadenas y listo.")
print("Esa segunda etapa de parseo es el tema de la leccion 1.5.")