Loading JSON Data to Restore App State

Contenido del curso

Fundamentos de Clases y Objetos

Encapsulación y Comportamiento de Objetos

Implementar Protocolos con Métodos Especiales

Relaciones entre Clases y Polimorfismo

Diseño Avanzado y Patrones de Software

17
Loading JSON Data to Restore App State
Viendo ahora

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0011:43

Loading JSON Data to Restore App State

Curso de Python Orientado a Objetos

Clase 17 de 17

Clase 17 / 17

Recursos

Reading a JSON file to rebuild your application's state is the missing half of persistence in object oriented Python. You already know how to save; now you need a cargar_datos method that opens the file, parses it with json.load and recreates every instance your library needs to keep running.

How do I read a JSON file in Python with the right encoding?

The loading method lives in persistencia.py next to the saving method, and it only takes self because the data comes from a file, not from an instance.

You open the file in read mode using a context manager, keep the same encoding you used when writing, and then parse the content with json.load, which expects a file object.

python with open(self.archivo, "r", encoding="utf-8") as f: datos = json.load(f) print("Datos cargados:", datos)

When you run python main.py, the terminal prints a dictionary with the library nombre, usuarios and libros you saved earlier. That dictionary is the blueprint you will iterate over to rebuild objects.

What does json.load return in Python? It returns a Python dictionary (or list) built from the JSON file. Keys become strings, and nested structures map directly to dicts and lists.

How do I rebuild objects from a dictionary in Python?

The trick is to read one element, copy its exact shape, and use that shape as the recipe for instantiating your classes.

Start by recreating the library itself. Import the class at the top of persistencia.py and pass the saved name:

python from biblioteca import Biblioteca biblioteca = Biblioteca(datos["nombre"])

How do I recreate a list of books from JSON?

Print datos["libros"][0] once to inspect the shape, then loop over the list and instantiate LibroFisico with every key the constructor expects, including disponible, because a book may have been marked as unavailable before saving.

python from libros import LibroFisico for dato_libro in datos["libros"]: libro = LibroFisico( titulo=dato_libro["titulo"], autor=dato_libro["autor"], isbn=dato_libro["isbn"], disponible=dato_libro["disponible"], ) biblioteca.libros.append(libro)

Even if the class does not require disponible by default, you must pass it to keep the regenerated state identical to what you saved.

How do I distinguish a student from a professor when loading users?

Users mix two classes inside the same list, and the JSON does not carry an explicit tipo field. The practical workaround is to inspect the keys of each dictionary: a student has the carrera key, a professor does not.

python from usuarios import Estudiante, Profesor for dato_usuario in datos["usuarios"]: if "carrera" in dato_usuario: usuario = Estudiante( nombre=dato_usuario["nombre"], cedula=dato_usuario["cedula"], carrera=dato_usuario["carrera"], ) else: usuario = Profesor( nombre=dato_usuario["nombre"], cedula=dato_usuario["cedula"], ) biblioteca.usuarios.append(usuario)

Adding an explicit tipo field when saving would be a cleaner long term practice, but key inspection works perfectly for this project.

How do I wire cargar_datos into main.py?

The loading method must end with return biblioteca so the caller receives a fully populated object ready to use.

In main.py, replace the manual creation of the library, users and books with a single call to the persistence layer, and move the save call to the end so every change is written to disk:

Delete the hardcoded professor, library, users and example data.
Assign biblioteca = persistencia.cargar_datos() at the start.
Call persistencia.guardar_datos(biblioteca) after the program logic runs.

When you execute python main.py, the application reads biblioteca.json, rebuilds every instance and shows the available books. If you edit the JSON file directly and add a new book, it appears in the app on the next run.

Why use "r" instead of "w" in open()? "r" opens the file in read only mode, which is what json.load needs. "w" would erase the file before reading.

What's next after building this Python OOP project?

The project runs, but it is not bulletproof. The most obvious gap is error handling: what happens if biblioteca.json does not exist when cargar_datos runs? Your code will crash with a FileNotFoundError.

Your challenge is to add error handling wherever the application can fail, especially around file reading and JSON parsing. Try try/except blocks for FileNotFoundError and json.JSONDecodeError, and decide whether to create an empty library or stop execution.

Finish your version before checking the final commit in the repository. Then keep practicing, contribute to open source, and continue the Python path. ¿Qué parte de tu proyecto vas a blindar primero con manejo de errores?

Paola Alapizco

Hace un año•editado

Hola a todos! 👋🏼

A continuación les dejo mi granito de arena al proyecto del curso, con tres modificaciones clave en las clases Libro, Estudiante, Profesor y Persistencia.

Guardado de usuarios por Estudiante y Profesor.
Definición de classmethods para recrear instancias de libros y usuarios.
Recrear biblioteca implementando los clasmethods e identificación de tipos de usuarios.

1️⃣ Identificar tipo de usuario en persistencia.py

En en ejemplo que vimos en la clase, el profesor utiliza el atributo “carrera” para distinguir el tipo de usuario.

Pero, ¿Cómo distinguir entre un usuario de tipo Profesor y uno de tipo Estudiante sin utilizar alguno de los atributos de una de las clases?.

📌 Los objetos en Python tienen una propiedad especial llamada__class__ que nos permite acceder a la variable __name__ la cuál corresponde al nombre de de la clase a la que pertenece un objeto.

Por ejemplo:

usuario1 = Profesor(nombre="Luis Martinez", cedula="123456")
print(usuario.__class__.__name__)
# Output: Profesor

usuario2 = Estudiante(nombre="Paola", cedula="123456", carrera="Sistemas")
print(usuario.__class__.__name__)
# Output: Estudiante

Al aplicarlo dentro del método de guardar_datos debemos cambiar el list comprehension donde iteramos a los usuarios:

def guardar_datos(self, biblioteca):
        datos = {
            "nombre": biblioteca.nombre,
            # Cada usuario estara contenido dentro de una llave con el nombre de su respectiva clase.
            "usuarios": [{ usuario.__class__.__name__: usuario.__dict__ } for usuario in biblioteca.usuarios,
            "libros": [libro.__dict__ for libro in biblioteca.libros],
            "fecha_guardado": datetime.now().isoformat(),
        }
        with open(self.archivo, "w", encoding="utf-8") as f:
            json.dump(datos, f, indent=4, ensure_ascii=False)

Al guardar el archivo JSON, obtendremos la siguiente estructura para usuarios:

"usuarios": [
        {
            "Profesor": {
                "nombre": "Luis Martinez",
                "cedula": "123456",
                "libros_prestados": [],
                "limite_libros": null
            }
        },
        {
            "Estudiante": {
                "nombre": "Paola",
                "cedula": "123456",
                "libros_prestados": [],
                "carrera": "Sistemas",
                "limite_libros": 3
            }
        }

2️⃣ Implementación del decorador @classmethod para la reconstrucción de libros y usuarios.

En el ejemplo de la clase, se reconstruye la biblioteca creando cada uno de los libros y usuarios a partir de instancias directas de sus respectivas clases (LibroFisico, Estudiante y Profesor), sin embargo al hacerlo de esta forma estaríamos perdiendo información de cada instancia, por ejemplo:

Usuarios (Estudiante y Profesor): Libros que tenia prestados cada usuario.
Libros: Contador de las veces que ha sido prestado cada libro.

Este ejercicio es el ejemplo perfecto para implementar los conocimientos adquiridos en la clase #15. Implementaremos un @classmethod para recrear cada instancia sin perder información previa de cada objeto.

Libro

class Libro:
    def __init__(self, titulo, autor, isbn, disponible=True):
        self.titulo = titulo
        self.autor = autor
        self.isbn = isbn
        self.disponible = disponible
        self.__veces_prestado = 0

    @classmethod
    def recrear(cls,  titulo, autor, isbn, disponible, veces_prestado):
        libro = cls(titulo=titulo, autor=autor,isbn=isbn, disponible=disponible)
        libro.__veces_prestado = veces_prestado
        return libro
        
   # ...

recrear tiene como argumentos, veces_prestado, así cuando se crea la instancia de cls (Libro/LibroFisico, dependiendo de la clase que ejecute el método) también modifica el valor de dicho argumento, recreando un objeto con las mismas propiedades que habíamos guardado en el archivo biblioteca.json.

Estudiante

class Estudiante(Usuario):
    def __init__(self, nombre, cedula, carrera):
        super().__init__(nombre, cedula)
        self.carrera = carrera
        self.limite_libros = 3

    @classmethod
    def recrear(cls, nombre, cedula,carrera, libros_prestados):
        estudiante = cls(nombre=nombre, cedula=cedula, carrera=carrera)
        estudiante.libros_prestados = libros_prestados
        return estudiante
    # ...

Profesor

class Profesor(Usuario):
    def __init__(self, nombre, cedula):
        super().__init__(nombre, cedula)
        self.limite_libros = None

    @classmethod
    def recrear(cls, nombre, cedula, libros_prestados):
        preofesor = cls(nombre=nombre, cedula=cedula)
        preofesor.libros_prestados = libros_prestados
        return preofesor
    # ...

En las clases Estudiante y Profesor lo que cambia es el tributo carrera, por eso opté por definir el classmethod recrear en cada una de las clases que heredan de Usuario.

3️⃣ Recrear la biblioteca

Una vez hecha la modificación en la forma de guardar a los usuarios en el archivo biblioteca.json y haber definido un classmethod en cada una de las clases, es hora de implementarlos, el método cargar_datos quedaría de la siguiente forma:

class Persistencia:
		# ....
		
    def cargar_datos(self):
        with open(self.archivo, "r", encoding="utf-8") as f:
            datos = json.load(f)

        # datos: {'titulo': 'Cien Años de Soledad', 'autor': 'Gabriel García Márquez', 'isbn': '9780307474728', 'disponible': True, '_Libro__veces_prestado': 0}

        biblioteca = Biblioteca(datos["nombre"])
        for dato_libro in datos["libros"]:
            libro = LibroFisico.recrear(
                titulo=dato_libro["titulo"],
                autor=dato_libro["autor"],
                isbn=dato_libro["isbn"],
                disponible=dato_libro["disponible"],
                veces_prestado=dato_libro["_Libro__veces_prestado"]
            )
            biblioteca.libros.append(libro)

        # datos: {'Profesor': {'nombre': 'Felipe', 'cedula': '123123123', 'libros_prestados': ['La Metamorfosis'], 'limite_libros': None}}
        # datos: {'Estudiante': {'nombre': 'Ana María López', 'cedula': '1001234567', 'libros_prestados': [], 'carrera': 'Ingeniería de Sistemas', 'limite_libros': 3}}
        for dato_usuario in datos["usuarios"]:
            tipo_usuario, info_usuario = list(dato_usuario.items())[0]
            
            if tipo_usuario == "Estudiante":
                usuario = Estudiante.recrear(
                    nombre=info_usuario["nombre"],
                    cedula=info_usuario["cedula"],
                    carrera=info_usuario["carrera"],
                    libros_prestados=info_usuario["libros_prestados"]
                )
            else:
                usuario = Profesor.recrear(
                    nombre=info_usuario["nombre"], 
                    cedula=info_usuario["cedula"],
                    libros_prestados=info_usuario["libros_prestados"]
                )
            biblioteca.usuarios.append(usuario)
        return biblioteca