La persistencia de datos en Python te permite que una aplicación recuerde su estado entre ejecuciones. Aquí verás cómo serializar objetos a JSON, escribirlos en un archivo y preparar todo para, más adelante, reconstruirlos al cargar. Con una clase central, Persistencia, lograrás guardar nombre, usuarios, libros y una fecha de guardado para auditar cambios.
¿Cómo implementar persistencia de datos con JSON en Python?
La idea clave: convertir objetos Python a formato JSON serializable, escribirlos en un archivo y, en una fase posterior, cargarlos para reconstruir el estado. Es vital manejar errores y validar datos para evitar inconsistencias.
Serializa estructuras a JSON para almacenamiento seguro.
Usa archivos .json para persistir entre ejecuciones.
Prioriza validación y manejo de errores.
¿Qué estructura mínima necesita la clase Persistencia?
Crea un archivo persistencia.py y define una clase que reciba el nombre del archivo. Por defecto, será biblioteca.json. Así centralizas el acceso al almacenamiento.
Constructor con valor por defecto: biblioteca.json.
Un único punto de entrada para guardar datos.
¿Cómo escribir el archivo con with open y json.dump?
El context managerwith garantiza que el archivo se cierre correctamente. El modo "w" (write) escribe desde cero y el encoding "utf-8" asegura caracteres como eñes y tildes.
ensure_ascii=False conserva caracteres en español.
¿Cómo guardar usuarios, libros y fecha de guardado?
Además del nombre, es útil persistir las listas de usuarios y libros. Para colecciones de objetos, conviene convertir cada elemento a diccionario, por ejemplo con dict().
¿Cómo convertir objetos a diccionarios con dict?
Aprovecha una lista comprimida para transformar cada elemento de biblioteca.usuarios y biblioteca.libros.
datos ={"nombre": biblioteca.nombre,"usuarios":[dict(usuario)for usuario in biblioteca.usuarios],"libros":[dict(libro)for libro in biblioteca.libros],}
Lista comprimida para recorrer colecciones.
Conversión con dict() para serializar a JSON.
¿Cómo registrar la fecha de guardado?
Agregar una marca de tiempo te permite saber cuándo se persistió el estado, útil para auditoría y recargas futuras.
# Ejemplo conceptual según lo explicado:# from DateTime import DateTime# datos["fecha_guardado"] = DateTime.now().ISOFormat()
Campo fecha_guardado para trazabilidad.
Sello temporal en ISO format con now.
¿Qué errores y buenas prácticas debes considerar?
Mantén consistencia en nombres de atributos y el idioma del código. Un error típico fue usar biblioteca.name cuando el atributo real era biblioteca.nombre. Evita mezclar idiomas en variables; si eliges español, sé consistente, aunque se recomienda inglés en proyectos reales para evitar tildes en identificadores.
Verifica atributos: biblioteca.nombre en lugar de name.
Usa UTF-8 y ensure_ascii=False para textos en español.
Valida datos y maneja errores al serializar y escribir.
Comprueba resultados: tras ejecutar, se genera biblioteca.json con el contenido esperado.
Ejemplos prácticos: cambio de nombre "Platzi Biblioteca" a "B2" y verificación en el .json.
¿Te gustaría que incluyamos la carga desde JSON para reconstruir el estado en tu sistema de biblioteca? Deja tus dudas o casos y continuamos la conversación.
Hola profes, tuve un problema con la prueba del video, me salieron relaciones que no estaban, les dejo evidencia. Intenté hacer scroll y nada. También probé relacionando con las que tenía ahí y tampoco me dejó.
Probé de nuevo y tuve estas parejas.
Voy a llevarme esto al equipo que los implementó para que puedan corregirlos!
Gracias por reportarlo.
Camilo gracias por el feedback, lo estamos revisando 🦾
🧩Persistencia de Datos con JSON en Python
🎯 1. Concepto esencial: ¿qué es la persistencia?
La persistencia permite que tu aplicación recuerde su estado cada vez que se ejecuta.
🔸 Qué implica:
Transformar objetos de Python → JSON
Guardar ese JSON en un archivo
Cargarlo luego para reconstruir el estado previo
Validar y manejar errores para evitar datos corruptos
📌 Idea resumen:
👉 "Serializa, guarda, valida y luego reconstruye."
🧱 2. Clase principal: Persistencia
📌 Propósito:
Un único punto central para leer y guardar la información de tu sistema.
🔧 Estructura base:
class Persistencia:
def __init__(self, archivo="biblioteca.json"):
self.archivo = archivo
🎒 Lo que aporta:
Archivo por defecto: biblioteca.json
Organización limpia
Acceso controlado al almacenamiento
📤 3. Guardar datos de forma segura
🧰 Herramienta clave: with open
Garantiza:
Cierre automático del archivo
Escritura segura
Menos errores
with open(self.archivo, "w", encoding="utf-8") as f:
json.dump(datos, f, indent=2, ensure_ascii=False)
🔍 Parámetros importantes:
"w" → escribir desde cero
utf-8 → soporta tildes y ñ
indent=2 → JSON legible
ensure_ascii=False → no escapa caracteres españoles
📚 4. ¿Qué información guardar?
🎒 Elementos recomendados:
nombre de la biblioteca
lista de usuarios
lista de libros
fecha de guardado (opcional pero muy útil)
🔄 Conversión de objetos → diccionarios
📌 JSON solo acepta tipos básicos, así que debes convertir objetos:
datos = {
"nombre": biblioteca.nombre,
"usuarios": [dict(usuario) for usuario in biblioteca.usuarios],
"libros": [dict(libro) for libro in biblioteca.libros],
📌 Sencillo, pero poderoso para seguir la evolución del estado.
Implementación de Carga desde JSON
Para reconstruir el estado del sistema de biblioteca desde un archivo JSON, necesitas implementar:
1. Métodos from\_dict en las clases (Factory Methods)
En [Usuario](usuarios.py) - Clase base:
@classmethoddeffrom_dict(cls, data:dict)->"Usuario":"""Reconstruye un Usuario desde un diccionario""" usuario = cls(data["_nombre"], data["_cedula"]) usuario.libros_prestados = data.get("libros_prestados",[])return usuario
En [Estudiante](usuarios.py):
@classmethoddeffrom_dict(cls, data:dict)->"Estudiante":"""Reconstruye un Estudiante desde un diccionario""" estudiante = cls( data["_nombre"], data["_cedula"], data.get("carrera","Ingeniería")) estudiante.libros_prestados = data.get("libros_prestados",[])return estudiante
En [Profesor](usuarios.py):
@classmethoddeffrom_dict(cls, data:dict)->"Profesor":"""Reconstruye un Profesor desde un diccionario""" profesor = cls(data["_nombre"], data["_cedula"]) profesor.libros_prestados = data.get("libros_prestados",[])return profesor
En [Libro](libros.py):
@classmethoddeffrom_dict(cls, data:dict)->"Libro":"""Reconstruye un Libro desde un diccionario""" libro = cls( titulo=data["_titulo"], autor=data["_autor"], isbn=data["_isbn"], disponible=data.get("_disponible",True), paginas=data.get("_paginas"), es_nuevo=data.get("_es_nuevo",False))# Restaurar veces_prestado usando el setterif"_Libro__veces_prestado"in data: libro._Libro__veces_prestado = data["_Libro__veces_prestado"]return libro
2. Método cargar\_datos en [Persistencia](persistencia.py):
defcargar_datos(self)->dict:"""Carga los datos desde el archivo JSON"""try:withopen(self.archivo,"r", encoding="utf-8")as f:return json.load(f)except FileNotFoundError:returnNoneexcept json.JSONDecodeError:print(f"Error: El archivo {self.archivo} no contiene JSON válido")returnNone
3. Función de reconstrucción en [main.py](main.py) o [biblioteca.py](biblioteca.py):
from usuarios import Usuario, Estudiante, Profesor
from libros import Libro
defreconstruir_biblioteca(datos:dict)-> Biblioteca:"""Reconstruye una Biblioteca desde un diccionario""" biblioteca = Biblioteca(datos["nombre"])# Reconstruir usuarios según su tipofor user_data in datos.get("usuarios",[]): tipo = user_data.get("tipo","Usuario")if tipo =="Estudiante": usuario = Estudiante.from_dict(user_data)elif tipo =="Profesor": usuario = Profesor.from_dict(user_data)else: usuario = Usuario.from_dict(user_data) biblioteca.usuarios.append(usuario)# Reconstruir librosfor libro_data in datos.get("libros",[]): libro = Libro.from_dict(libro_data) biblioteca.libros.append(libro)return biblioteca
4. Uso en [main.py](main.py):
from persistencia import Persistencia
persistencia = Persistencia()# Intentar cargar datos existentesdatos_cargados = persistencia.cargar_datos()if datos_cargados: biblioteca = reconstruir_biblioteca(datos_cargados)print(f"Biblioteca cargada: {biblioteca.nombre}")else:# Crear biblioteca nueva si no hay datos biblioteca = Biblioteca("Biblioteca Perfecta") biblioteca.usuarios =[profesor]+ data_estudiantes
biblioteca.libros = data_libros
# ... resto del programa ...# Al finalizar, guardar cambiospersistencia.guardar_datos(biblioteca)
Nota Importante sobre \_\_dict\_\_
El uso de \_\_dict\_\_ en [persistencia.py](persistencia.py) guarda los atributos internos con prefijos como \_nombre y \_Libro\_\_veces\_prestado (name mangling). Por eso los métodos from\_dict deben acceder a estas claves específicas.
Para una solución más limpia, considera implementar los métodos \_\_iter\_\_ o to\_dict() mencionados anteriormente, lo que te daría control total sobre las claves del JSON.
Para aplicar los conceptos hice otro metodo estatico que tambien guarde los libros disponibles y los prestados:
class Persistencia:
def __init__(self, filename):
self.filename = filename
"""El context manager with garantiza que el archivo se cierre correctamente.
El modo "w" (write) escribe desde cero y el encoding "utf-8" asegura caracteres como eñes y tildes."""
def guardar_datos(self, biblioteca):
datos = {}
datos["libros"] = [libro.titulo for libro in biblioteca.libros]
datos["usuarios"] = [usuario.nombre for usuario in biblioteca.usuarios]
with open(self.filename, "w", encoding="utf-8") as f:
