📊 El Modelo + JSON CRUD | Tutorial Flask (Parte 3)

Bienvenidos a Aplicaciones Flask Web [Parte 3]: CRUD Completo. En esta tercera parte vamos a implementar todas las operaciones de gestión de datos (CRUD) en nuestro modelo para tenerlo 100% funcional y listo para conectar con el controlador.

En este post aprenderás a crear métodos para crear, leer, actualizar y borrar registros (CRUD) facilitando así la gestión de tu base de datos, que en este caso utilizamos JSON por la facilidad de trabajarla como si fuera un diccionario.

Aprendida esta estructura recuerda utilizarla siempre en tus aplicaciones sea que trabajen con bases de datos relacionales o no relacionales y por más pequeña que sea la aplicación o apenas se trate de leer un txt. Es importante incorporar estas prácticas de desarrollo.

En este post:

1. Aprenderás el concepto de gestión de datos CRUD.
2. Vamos a crear los métodos para crear, leer, actualizar y borrar los contactos de nuestra base de datos JSON.
3. Vamos a corroborar su funcionamiento ejecutando los métodos directamente desde el models.py.
4. Optimizaremos nuestro código para evitar repeticiones.

¿Qué es CRUD?

Ya hemos hablado anteriormente, pero a modo de repaso el concepto CRUD está estrictamente ligado a la gestión de datos y sus siglas hacen referencia en inglés a Create, Read, Update y Delete (Crear, Leer, Actualizar o modificar y Borrar) por lo que abocándonos a lo que nos compete en el post serán los métodos que vamos a definir para interactuar con nuestra base de datos en este caso JSON aunque es mayormente utilizado con bases de datos relacionales como MySQL, pero es conveniente ir aprendiendo a utilizarlo y aplicarlo cada vez que trabajemos con bases de datos.

Si quieres profundizar en el concepto, te recomiendo leer la definición de CRUD en Wikipedia y también nuestra guía sobre modelos de bases de datos relacionales vs NoSQL.

Aplicando el concepto CRUD en nuestro modelo

Para aplicar este concepto debemos definir los métodos correspondientes en nuestra clase y cada método trabajará de una forma determinada. Por ejemplo, el método «Crear» corresponderá a crear nuevos datos en la base de datos y en nuestro caso será «Crear una nueva persona» que será almacenada en la base de datos dentro de la lista que es el valor de la clave «Personas«.

Lo primero es la organización de los datos

🔑 CLAVE de IDENTIFICACIÓN (ID)

Me gustaría aclarar que «id» no es solo una clave de identificación de un usuario o «persona / contacto» en nuestro caso. Si no también una manera de diferenciar inequívocamente cada «registro / diccionario» que añadimos y no solamente es buena práctica, sino que utilizarla es obligatorio porque se define como un principio básico de la organización de datos, ya sea trabajes con bases de datos relacionales o no relacionales. Una base de datos sin identificadores únicos e irrepetibles de los registros, no es una base de datos, es un jodido desorden, no es información, son datos aislados y atómicos, regados. Si quieres leer un poco sobre esto lo puedes hacer aquí: Clave primaria (Wikipedia) y también puedes leer algunos post sobre bases de datos que he redactado como contenido complementario del módulo 3 de desarrollo en python.

Creando los métodos CRUD de nuestra clase Personas

Antes de meternos de lleno en el código, vamos a aclarar algo importante: el archivo models.py es el corazón de nuestra lógica de datos. Aquí es donde definimos cómo se estructuran los datos (la clase Persona) y cómo se gestionan (crear, leer, actualizar, eliminar). Es el archivo que conecta nuestra aplicación con la base de datos, en este caso nuestro archivo JSON.

En los posts anteriores ya creamos este archivo y lo dejamos preparado con la estructura básica. Ahora vamos a implementar los métodos que le darán vida. Vamos a comentar en bloques para organizar nuestro código y comprender lo que estamos haciendo:

📄 editando: models.py

#BLOQUE IMPORT
import os
import json

#BLOQUE APERTURA ARCHIVO JSON
THIS_FOLDER = os.path.dirname(os.path.abspath(__file__))
my_file = os.path.join(THIS_FOLDER + '/DB/' 'base_de_datos.json')

# Funciones auxiliares
def leer_json():
    with open (my_file, "r") as f:
        datos = json.load(f)
        f.close()
        return datos

def modificar_json():
    with open (my_file, "w") as modid:
        json.dump(datos, modid, indent=4)
        modid.close()

#LEEMOS EL ARCHIVO
datos = leer_json()


#CLASE PERSONA
class Persona(object):
    def __init__(self, id, nombre, apellido, apodo, telefono, direccion):
        self.id = id
        self.nombre = nombre
        self.apellido = apellido
        self.apodo = apodo
        self.telefono = telefono
        self.direccion = direccion

    # Método CREATE - Pendiente de implementar
    def crear_contacto():
        pass
    
    # Método READ - Pendiente de implementar
    def leer_contacto():
        pass

    # Método UPDATE - Pendiente de implementar
    def actualizar_contacto():
        pass

    # Método DELETE - Pendiente de implementar
    def eliminar_contacto():
        pass

Vamos ahora a entender el primer gran problema que tenemos que resolver: cómo generar IDs únicos que no se repitan al reiniciar la aplicación.

⚠️ El problema con los modelos JSON: IDs duplicados al reiniciar la aplicación

Imagina que tienes tres contactos guardados con IDs 1, 2 y 3. Todo funciona perfecto. Cierras la aplicación, la abres de nuevo y… ¡sorpresa! El próximo contacto que creas recibe el ID 1 de nuevo. ¿El resultado? Dos contactos diferentes con el mismo ID. Un caos total. 🫣

Esto pasa porque el contador de IDs vive en la memoria RAM mientras el programa está corriendo. Cuando cierras la app, la memoria se libera y el contador vuelve a cero. Al reiniciar, el contador empieza desde 0 otra vez, pero los datos guardados en el JSON ya tienen IDs usados. ¡Colisión asegurada!

Para solucionar esto, necesitamos un ID auto-incremental persistente, es decir, un contador que no se reinicie al cerrar la aplicación. La solución es sencilla: guardar el contador en el propio archivo JSON, junto con los datos. Así, al abrir la app, leemos el último ID usado y continuamos desde ahí.

Y lo mejor: lo vamos a hacer sin librerías externas, solo con Python puro, para que entiendas exactamente cómo funciona. Una vez que domines esto, trabajar con bases de datos como SQLite, MySQL o MongoDB será mucho más fácil.

Ahora que entendemos el problema y por qué necesitamos una solución, vamos a ver cómo implementar un ID auto-incremental en Python sin librerías.

¿Cómo crear una id auto-incremental en Python sin librerías?

Antes de recurrir a librerías externas o a sistemas de bases de datos complejos, es fundamental entender cómo funciona la generación de identificadores únicos a nivel de código. Hacerlo sin librerías no solo es posible, sino que te ayuda a comprender el concepto de variable de clase y el ciclo de vida de los objetos en Python.

La ventaja de este enfoque es que no dependes de nada externo: tu código es autónomo, ligero y fácil de entender. Además, es la base de muchos sistemas de identificación que después usan bases de datos reales. Una vez que entiendes esto, pasar a un id generado por SQLite, MySQL o MongoDB es pan comido.

El mecanismo es muy sencillo y consta de tres pasos:

1. Creamos una variable de clase (contador_id) que actuará como contador global para todas las instancias de la clase.
2. En el método constructor __init__ eliminamos el parámetro id porque el ID se asignará automáticamente, no lo recibiremos desde fuera.
3. Dentro de __init__, asignamos al atributo self.id el valor actual de Persona.contador_id y luego incrementamos esa variable de clase en 1 para que el próximo objeto tenga un ID distinto.

Es importante destacar que contador_id es compartida por todas las instancias de la clase, por eso la definimos fuera de __init__ y la referenciamos con Persona.contador_id. De esta forma, cada nuevo objeto recibe un número único y secuencial.

Si quieres repasar los fundamentos de la Programación Orientada a Objetos en Python, te recomiendo nuestra guía completa de Clases en Python y también la documentación oficial de Python sobre clases.

📄 editando: models.py

class Persona(object):
    contador_id = 0  # Variable de clase compartida por todas las instancias
    
    def __init__(self, nombre, apellido, apodo, telefono, direccion):
        self.id = Persona.contador_id  # Asignamos el ID actual
        Persona.contador_id += 1       # Incrementamos para el próximo objeto
        self.nombre = nombre
        self.apellido = apellido
        self.apodo = apodo
        self.telefono = telefono
        self.direccion = direccion

💡 Curiosidad: Este mismo patrón de «variable de clase como contador» se usa en muchos frameworks para generar IDs temporales o números de ticket. Es una técnica sencilla pero muy poderosa cuando entiendes cómo funciona la memoria y el ciclo de vida de los objetos.

Método Create – crear_contacto()

El método Create nos permitirá crear personas o registros de contactos en nuestra aplicación y almacenarlos en nuestra futura base de datos JSON.

Este método es el punto de entrada para guardar nuevos datos. Recibe como argumentos el nombre, apellido, etc., y se encarga de:

1. Crear una instancia de la clase Persona.
2. Convertirla en diccionario usando __dict__.
3. Añadirla a la lista de personas en memoria.
4. Guardar los cambios en el archivo JSON.

Vamos a verlo en código:

📄 editando: models.py

# MÉTODO CREATE - Crear nuevo contacto
def crear_contacto(self):
    # 1. Creamos nueva instancia como diccionario usando __dict__
    nueva_persona = Persona(
        self.nombre,
        self.apellido,
        self.apodo,
        self.telefono, 
        self.direccion).__dict__
    
    # 2. Añadimos a la lista de Personas en memoria
    datos['Personas'].append(nueva_persona)
    
    # 3. Guardamos los cambios en el archivo JSON
    with open (my_file, "w") as fr:
        json.dump(datos, fr, indent =4)
        fr.close()

Ahora vamos a resolver ese problema. La clave está en guardar el contador dentro del propio JSON. De esta forma, al reiniciar la app, el contador se recupera desde el archivo y los IDs nunca se repiten.

¿Cómo evitar que nuestro id se repita luego de reiniciar la app?

Primero recuerda que debes crear la base de datos en tu proyecto «DB/base_de_datos.json«

Para solucionar este problema, creamos dentro de la misma base de datos JSON otra clave que contenga el valor de la id actual:

Archivo /DB/base_de_datos.json:

{
    "Personas": [
        {
            "id": 1,
            "nombre": "Mariano",
            "apellido": "Laca",
            "apodo": "Pyromaniac",
            "telefono": "34343434",
            "direccion": "pythones.net"
        }
    ],
    "Configuraciones":[
        {"contador_id_db" : 1}
    ]
}

Y modificamos en nuestro modelo la clase para usar este valor persistente:

📄 editando: models.py

class Persona(object):
    # Contador ID leído desde JSON (persistente entre sesiones)
    contador_id = datos["Configuraciones"][0]["contador_id_db"]
    
    def __init__(self, nombre, apellido, apodo, telefono, direccion):
        print("El contador está en: ", Persona.contador_id)
        self.id = Persona.contador_id
        self.nombre = nombre
        self.apellido = apellido
        self.apodo = apodo
        self.telefono = telefono
        self.direccion = direccion

    def crear_contacto(self):    
        # 1. Incrementamos el contador en la base de datos (JSON)
        datos["Configuraciones"][0]["contador_id_db"] += 1
        
        # 2. Guardamos el nuevo contador en el JSON
        with open (my_file, "w") as modid:
            json.dump(datos, modid, indent=4)
            modid.close()
        
        print("El contador está ahora en: ", datos["Configuraciones"][0]["contador_id_db"])
        # 3. Actualizamos contador en memoria
        Persona.contador_id += 1
        
        # 4. Creamos y guardamos la nueva persona
        nueva_persona = Persona(
            self.nombre,
            self.apellido,
            self.apodo,
            self.telefono, 
            self.direccion).__dict__
            
        datos['Personas'].append(nueva_persona)
        
        with open (my_file, "w") as fr:
            json.dump(datos, fr, indent =4)
            fr.close()

Con este enfoque, el ID nunca se repite, incluso si reinicias la aplicación cien veces. El contador siempre se recupera desde el JSON, y se incrementa cada vez que creas un nuevo contacto. ¡Problema resuelto! 🎉

Método Update – actualizar_contacto()

El método Update debe permitirnos cambiar o modificar valores dentro de la base de datos JSON.

¿Cómo funciona? Busca el contacto por su ID, encuentra su posición en la lista, modifica el atributo que le indiquemos y guarda los cambios. Fíjate que no necesitamos actualizar toda la persona, solo el campo que queremos modificar.

📄 editando: models.py

# MÉTODO UPDATE - Modificar contacto existente
def actualizar_contacto(id, atr, nuevo_valor):
    for persona in datos["Personas"]:
        if persona["id"] == id:
            print ("Encontrado: ", persona)
            
            # Obtenemos el índice
            indice = datos["Personas"].index(persona)
            
            # Modificamos el valor del atributo especificado
            datos["Personas"][indice][atr] = nuevo_valor
            
            print ("Nuevo valor: ", datos["Personas"][indice][atr])
            
            # Guardamos los cambios en el archivo JSON
            with open (my_file, "w") as modificar:
                json.dump(datos, modificar, indent =4)
                modificar.close()

Método Read – leer_contacto()

El Método leer_contacto() debe devolvernos el diccionario del contacto que buscamos.

Este método tiene un detalle muy interesante: puede devolver un contacto específico o TODOS los contactos. Si pasamos 'all' como valor, recorre toda la lista y devuelve todo. Si pasamos un valor específico (ej: nombre=»Mariano»), devuelve solo las coincidencias.

📄 editando: models.py

# MÉTODO READ - Buscar y listar contactos
def leer_contacto(atr, valor):
    encontradas = {} # Diccionario para resultados
    
    for persona in datos["Personas"]:
        if persona[atr] == valor or valor == 'all':
            # Obtenemos el índice
            indice = datos["Personas"].index(persona)
            # Guardamos en el diccionario
            encontradas[indice] = persona
    
    return encontradas

Método Delete – eliminar_contacto()

El método para eliminar registros:

Este método busca el contacto por ID, lo elimina de la lista y guarda los cambios. Una vez eliminado, el ID no se reutiliza, lo cual es una buena práctica para mantener la integridad histórica de los datos.

📄 editando: models.py

# MÉTODO DELETE - Eliminar contacto
def eliminar_contacto(id):
    for persona in datos["Personas"]:
        if persona["id"] == id:
            print ("Se va a borrar: ", persona)
            
            # Obtenemos el índice
            indice = datos["Personas"].index(persona)
            
            # Eliminamos usando pop() con el índice
            datos["Personas"].pop(indice)
            
            # Guardamos los cambios en el JSON
            with open (my_file, "w") as eliminar:
                json.dump(datos, eliminar, indent =4)
                eliminar.close()

Mejorando el código – Funciones de lectura y escritura JSON

Hasta ahora, en cada método hemos estado repitiendo el mismo código para abrir y cerrar el archivo JSON. Esto funciona, pero no es muy eficiente ni elegante. Si mañana decides cambiar la ruta del archivo o la estructura, tendrías que modificar cada método uno por uno. ¡Un dolor de cabeza!

La solución es sencilla: crear funciones auxiliares que encapsulen la lógica de lectura y escritura del JSON. Así, si algo cambia, solo tienes que modificar estas dos funciones y el resto del código sigue funcionando perfectamente.

Podemos simplificar mucho el código creando funciones auxiliares para evitar repetir el código de apertura/cierre de archivos:

📄 editando: models.py

# ================================================
# FUNCIONES AUXILIARES PARA MANEJO DE JSON
# ================================================

# -- Función Leer archivo JSON
def leer_json():
    with open (my_file, "r") as f:
        datos = json.load(f)
        f.close()
        return datos

# -- Función modificar JSON
def modificar_json():
    with open (my_file, "w") as modid:
        json.dump(datos, modid, indent=4)
        modid.close()

# Cargamos los datos iniciales
datos = leer_json()

Fíjate en la diferencia: antes cada método tenía su propio with open... y ahora simplemente llamamos a leer_json() o modificar_json(). Mucho más limpio, mucho más fácil de mantener.

Nuestro models.py optimizado queda así:

📄 editando: models.py

#BLOQUE IMPORT
import os
import json

#BLOQUE APERTURA ARCHIVO JSON
THIS_FOLDER = os.path.dirname(os.path.abspath(__file__))
my_file = os.path.join(THIS_FOLDER + '/DB/' 'base_de_datos.json')

# Funciones auxiliares
def leer_json():
    with open (my_file, "r") as f:
        datos = json.load(f)
        f.close()
        return datos

def modificar_json():
    with open (my_file, "w") as modid:
        json.dump(datos, modid, indent=4)
        modid.close()

datos = leer_json()

# CLASE PERSONA CON CRUD COMPLETO
class Persona(object):
    contador_id = datos["Configuraciones"][0]["contador_id_db"]

    def __init__(self, nombre, apellido, apodo, telefono, direccion):
        print("El contador está en: ", Persona.contador_id)
        self.id = Persona.contador_id
        self.nombre = nombre
        self.apellido = apellido
        self.apodo = apodo
        self.telefono = telefono
        self.direccion = direccion

    # CREATE
    def crear_contacto(self):
        datos["Configuraciones"][0]["contador_id_db"] += 1
        modificar_json()
        print("El contador está ahora en: ", datos["Configuraciones"][0]["contador_id_db"])
        Persona.contador_id += 1
        
        nueva_persona = Persona(
            self.nombre,
            self.apellido,
            self.apodo,
            self.telefono, 
            self.direccion).__dict__
            
        datos['Personas'].append(nueva_persona)
        modificar_json()

    # READ
    def leer_contacto(atr, valor):
        encontradas = {}
        for persona in datos["Personas"]:
            if persona[atr] == valor or valor == 'all':
                indice = datos["Personas"].index(persona)
                encontradas[indice] = persona
        return encontradas

    # UPDATE
    def actualizar_contacto(id, atr, nuevo_valor):
        for persona in datos["Personas"]:
            if persona["id"] == id:
                indice = datos["Personas"].index(persona)
                datos["Personas"][indice][atr] = nuevo_valor
                modificar_json()

    # DELETE
    def eliminar_contacto(id):
        for persona in datos["Personas"]:
            if persona["id"] == id:
                indice = datos["Personas"].index(persona)
                datos["Personas"].pop(indice)
                modificar_json()

Mucho mejor! ¿No?. ¿Se te ocurre otra forma de organizar y reducir aún más el código?. La idea de estas funciones auxiliares es que si mañana decides cambiar la ruta del JSON o migrar a una base de datos real, solo tienes que modificar estas dos funciones y el resto del código no se entera. Eso es lo que llamamos buen diseño de software. 😉

📚 Resumen rápido de lo aprendido en la Parte 3

• CRUD es el acrónimo de Create, Read, Update, Delete – las cuatro operaciones básicas para gestionar datos en cualquier aplicación.
• Hemos implementado cada uno de estos métodos en nuestra clase Persona dentro de models.py, trabajando con una base de datos JSON.
• Hemos solucionado el problema del ID persistente guardando el contador en el propio archivo JSON, para que no se reinicie al cerrar la aplicación.
• Hemos optimizado el código creando funciones auxiliares leer_json() y modificar_json() que evitan repetir la lógica de apertura/cierre de archivos.
• Con esto, nuestro modelo está listo para ser conectado al controlador y a las vistas, lo que haremos en la Parte 4.

Si quieres profundizar más en el manejo de JSON en Python, te recomiendo la documentación oficial de Python sobre JSON y también nuestro post sobre Diccionarios en Python.

Esto ha sido todo, nos vemos en la siguiente entrada para conectar el modelo al controlador y finalmente realizar las vistas!. Venga que ya falta poco para terminar nuestra primer aplicación.

📅 Última actualización: agosto 2, 2026