Nuestra primer aplicación en flask – Tutorial (Parte 2) – Modelo y Base de datos JSON

Nuestra primer aplicación 2 - Modelo y bases de datosBienvenidos a “Nuestra primer aplicación en flask [Tutorial – Parte 2]” en este post vamos a trabajar con el modelo y base de datos para comprender como se estructura el modelo de nuestra aplicación y aprenderemos a trabajar con bases de datos JSON que son y se manipulan de forma muy similar a los diccionarios en python.

Es importante destacar que intento seguir un orden para tu aprendizaje pero que para desarrollar una aplicación en Python que medianamente tenga sentido es necesario utilizar diferentes librerías y adquirir nuevos conceptos.

 

Primeramente, vamos a recordar donde habíamos quedado y como se encuentra estructurado nuestro proyecto a modo de repaso.

PREVIAMENTE EN PYTHONES.. - Repaso de la anterior lección

wey ya con las explicacionesRecordemos que al crear aplicaciones en Flask estaremos utilizando una arquitectura Modelo – Vista – Controlador comúnmente llamada por sus siglas MVC y en base a esta arquitectura hemos estructurado nuestro proyecto siendo conscientes de cada elemento y como se organiza dentro los directorios correspondientes. Si bien recordarás teníamos la carpeta principal a la que llamamos “Pruebas en Python” y dentro de ella generamos otras que son las que habitualmente usa nuestro framework Flask. Así también creamos los archivos “controlador.py” y “models.py” correspondientes al controlador y al modelo de nuestra futura base de datos. Repasemos la serie de pasos realizados:

  1. Creamos la carpeta de proyecto “Pruebas en Python
  2. Luego dentro de esta creamos las carpetas “templates“, “static“.
  3. Creamos los archivos correspondientes al controlador y modelo llamados “controlador.py” y “models.py
  4. Importamos Flask y producimos las rutas base en nuestro controlador. Además, agregamos bloque de código para iniciar nuestra aplicación en la dirección, puerto y modo preferido.
  5. Luego de eso, específicamente en el post anterior llamado “Nuestra primer aplicación en Flask – parte 1” definimos de que tratará nuestra primer aplicación, creamos las vistas en HTML dentro de la carpeta templates (index.html).
  6. Finalmente, añadimos código HTML en la vista index.html para producir una serie de tablas, donde también añadimos botones para realizar diversas acciones correspondientes a “Ver, Actualizar, Borrar y Añadir”.
  7. Y conectamos nuestra vista html al controlador dentro de la ruta de inicio de nuestra aplicación usando el objeto Request. Para que al cargar la página principal de nuestra aplicación se cargue el template “index.html

Entonces nuestro directorio de trabajo “Pruebas en Python” visto en forma de árbol se ve así:

Nuestra primer aplicación en flask - parte 2 - tree

 

Y a continuación veremos el código como lo habíamos dejado:

Código del archivo correspondiente al controlador – “controlador.py”:

from flask import Flask, request, render_template #Importamos clase Flask, objeto request de flask (librería)
app = Flask(__name__) #Creamos una app instanciando la clase Flask (automáticamente el nombre de la app)

#Rutas - (argumentos: Url) - Función

@app.route('/', methods = ['GET', 'POST']) #Decoramos con método de app que es una instancia de la clase Flask y argumentamos "slash"
def inicio(): #Definimos una función llamada Inicio
    if request.method == 'POST':
        pass
    else:
        return render_template('/index.html') #Retornornamos el template usando RENDER_TEMPLATE()

@app.route('/agradecimiento', methods = ['GET']) #Decoramos con método routes la próxima función argumentando la url "/agradecimiento"
def agradecer(): #Definimos una función llamada agradecer
    return 'Gracias pythones.net!' #Retorno de la función

#Iniciar app

if __name__ == '__main__': #Condicional de que si la aplicación ejecutada se coincide al nombre de la aplicación
    app.run('127.0.0.1', 5000, debug=True) #Método que inicia la app con la dirección, puertos y modo de argumentos

Como ves, el código de nuestro controlador se encuentra comentado y es importante destacar dentro de él los 3 bloques de código:

  1. El bloque “import” donde importamos las características y elementos necesarios para el funcionamiento de nuestra aplicación.
  2. Bloque “Rutas” donde generamos las rutas de nuestra aplicación y definimos las funciones a ejecutar al momento de visitar las URL que estamos pasando como argumento, así como también el tipo de solicitud (GET/POST) permitida.
  3. Finalmente, el bloque “Iniciar App” donde mediante un condicional ordenamos la ejecución y especificamos la dirección url, el puerto y el modo en que se habrá de ejecutar nuestra aplicación; en este caso en el modo de depuración “Debug“.

Veamos ahora nuestra vista para la url principal (“/”) que especificamos en el controlador dentro de un condicional utilizando Request.

Código correspondiente a la vista “templates/index.html”:

<!DOCTYPE html>
<html lang="es"> <!--Cambiamos a español-->
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Mi primer App en Flask</title> <!--Modificamos el Título-->
</head>
<body><!--Aquí comienza el cuerpo de nuestro HTML-->

    <h1 style = "text-align:center">Directorio Telefónico - Mi primer aplicación en Flask</h1> <!--Titulo principal centrado-->
    <br>

    <div>    <!--Creamos un div contenedor-->
        <div style="width: 60%; float:left; text-align:center;">    <!--Creamos el div de la izquierda-->
            <h2>Datos completos de la persona</h2>  <!--Titulo-->
            <table border = "1" style = "width: 100%;"> <!--Creamos la tabla con borde-->
                <tr><!--Creamos una fila-->
                    <td>Nombre</td> <!--Dentro de la fila las columnas-->
                    <td>Apellido</td>
                    <td>Apodo</td>
                    <td>Teléfono</td>
                    <td>Dirección</td>

                </tr>
                <tr><!--creamos otra fila-->
                    <td></td> <!--Aquí se cargarán los datos correspondientes-->
                    <td></td>
                    <td></td>
                    <td></td>
                    <td></td>
                </tr>
            </table>    <!--Fin de la tabla-->
        </div>  <!--Cierre del div de la izquierda-->

        <div style="width: 20%; float:right; margin-right: 10%; text-align:center;"> <!--Div de la derecha-->
            <h2>Personas</h2> <!--Titulo-->
            <table border = "1" style = "width: 100%;"><!--Tabla de la derecha-->
                <tr><!--Fila-->
                    <td></td><!--Columna que mostrará el nombre y apellido-->
                    <td><button name = "ver">Ver</button></td><!--Columna que mostrará el botón Ver-->
                    <td><button name = "editar">Editar</button></td><!--Columna que mostrará el botón Editar-->
                    <td><button name = "eliminar">Eliminar</button></td><!--Columna que mostrará el botón Eliminar-->
                </tr>
                <tr>
                    <td><button name = "agregar">Agregar</button></td><!--Columna que mostrará el botón Agregar-->
                </tr>
            </table>
        </div>
    </div>
</body>
</html>

 

Bueno, eso es todo, ya estamos al día. Ahora es momento de continuar y el paso que sigue es crear el modelo y base de datos para nuestra aplicación.

 

Usaremos un diccionario como base de datos
Recuerda que dijimos que utilizaríamos un diccionario como base de datos para evitar enseñarte ahora bases de datos, ya que se alargaría mucho el post. Pero posteriormente aprenderemos a emplear dos tipos de bases de datos.

 

Modelo y base de datos JSON en nuestra aplicación Flask

Como primer paso antes de comenzar a trabajar con los datos es preciso organizarnos y tener un conocimiento previo de los datos con los que vamos a trabajar para tener una idea de como estructurar nuestra base de datos; es decir, en este caso nuestro diccionario.

Claramente, podemos ver en nuestra vista hemos definido los siguientes campos dentro de la tabla donde mostraremos los datos completos. “Nombre, Apellido, Apodo, Teléfono, Dirección” y en la otra tabla (la que tenemos a la izquierda que ocupa menos espacio) hemos definido que se mostrarán todas las personas de nuestra base de datos y se nos permitirá realizar las siguientes acciones: “Ver, Añadir, Actualizar y Eliminar“.

Si pensamos como Desarrolladores con conocimientos en bases de datos, debemos tener en cuenta que en algún futuro algún usuario de nuestra aplicación, otro desarrollador o nosotros mismos podríamos querer añadir algún nuevo campo. Por ejemplo, una Foto de perfil del contacto y pues claro, si simplemente creamos la base de datos primero y luego el modelo al momento de añadir un nuevo Campo o Registro, tendremos que modificar la base de datos y también el modelo.

Algo similar sucedería si tenemos que mover nuestra aplicación a otro servidor o queremos cambiar nuestra base de datos de un diccionario a una base de datos relacional MySql. En el segundo caso, tendríamos que reformar el modelo y copiar los antiguos datos a la nueva base de datos.

La cosa es que los programadores debemos suponer todo en torno de automatizar procesos y poder a futuro facilitar el mantenimiento de aquellas aplicaciones que desarrollamos. Por lo que la mejor opción es:

Crear un modelo y desarrollar un script que permita crear una base de datos a partir del modelo.

Venga vamos, que si ya has trabajado con diccionarios no debería ser muy dificil crear un script en python que se encargue de crear este diccionario y trabajar con esos datos.

También cabe destacar que podríamos crear el diccionario incluso dentro del mismo controlador o dentro del modelo. O saltarnos el modelo y trabajar directamente con un diccionario en un archivo aparte. Pero, ¿estaríamos respetando la arquitectura MVC?. Pues no, y a futuro podría originar mucho dolor de cabeza si se nos solicitara modificar algunos de los aspectos antes mencionados relacionados con los datos. Así que vamos a hacerlo de la forma correcta:

Utilizar una base de datos JSON en nuestra aplicación

En otro post he hablado mucho sobre bases de datos, sobre todo teoría y la parte más importante a destacar es que existen dos tipos de bases de datos; las relacionales y las no relacionales. Si quieres leer un poco acerca de las diferencias puedes hacerlo aquí: Bases de datos modelo no relacional

 

Ejemplo JSON Wikipedia
Ejemplo de una base de datos JSON (Wikipedia)

Un diccionario podríamos considerarlo una base de datos no relacional, de hecho las bases de datos no relaciones JSON  (JavaScript Object Notation – Notación de Objetos de JavaScript) son básicamente diccionarios, que se almacenan con el formato “Key:Value” (par Clave:Valor) y donde a veces podemos encontrar diccionarios anidados, es decir diccionarios dentro de otros diccionarios; e incluso listas o tuplas como Key o Values.

 

Nosotros para utilizar este tipo de bases de datos simplemente podemos hacerlo dentro de un archivo de Python creando un diccionario, o bien podemos crear un archivo JSON y dentro establecer los diccionarios que serán nuestra base de datos. Pero lo haremos desde el modelo ¿Te animas?

modelo y base de datos json en flask - mi primer aplicación en flaskVenga! Dentro de la carpeta principal de tu proyecto, en mi caso “Pruebas en Python” crea un directorio llamado “DB“.

Dentro de este directorio estará el archivo JSON que contendrá diccionarios como base de datos.

¿Cómo lo haremos?

Lo primero que vamos a crear en nuestro modelo es una clase que se llamará Personas y contendrá como atributos los datos que necesitamos almacenar “Nombre, Apellido, Apodo, Teléfono, Dirección” y cada instancia de esta clase, es decir, cada vez que creemos un objeto a partir de ella deberá crearnos un diccionario. De esta forma crearemos un diccionario por cada entidad, digamos, por cada persona.

Así si yo añado a “Daniel Vallejos” a mi base de datos, este será un diccionario dentro de otro diccionario más grande llamado Personas{}. Y este diccionario donde se añade a Daniel Vallejos tendrá un numero de Id que lo identifica frente a los demás, y luego sus datos.

¿Cómo se estructura el modelo y la base de datos?

Así que basicamente nuestro modelo debe poder:

  1. Alojar una clase Personas con los atributos deseados “Id, Nombre, Apellido, Apodo, Teléfono, Dirección“.
  2. Permitirnos exportar esos datos a una base de datos JSON como diccionario anidado y tambíen leerlos, modificarlos o borrarlos. (CRUD)

Nuestra base de datos JSON contendrá un diccionario llamado “Personas” que dentro contendrá otros diccionarios; cada uno de estos diccionarios corresponderá a una persona y será creado a partir de la clase Persona de nuestro modelo!. Así nuestro modelo podrá crear nuevos diccionarios dentro del diccionario “Personas”, también podrá listar datos (mostrarlos), modificarlos y eliminarlos.

Entonces, si nuestro modelo cumple con el concepto CRUD (Create, Read, Update y Delete) lo único que tendremos que hacer desde el controlador es llamar al método correspondiente de la clase Persona alojada en nuestro modelo. Y solo con esto el modelo debe poder escarbar en la base de datos JSON y devolver un resultado a nuestro controlador para que este lo muestre al usuario en la vista. ¿Comprendes?. Sino lo harás pronto, ya verás!

 

modelo y bases de datos json
El diagrama de modelo y bases de datos más horrible del mundo!

Si te fijas en el diagrama dentro del modelo tienes la clase “Persona” a partir de la cual se creará un objeto diccionario que se almacenará dentro del JSON a su vez dentro del diccionario mayor “Personas“. Y si continúas mirando el modelo verás el método “ver_personas” que recibe de parámetro la “id“, pues este podría ser un método que permita buscar una persona dentro del diccionario “Personas” del JSON según su valor de “id” y mostrarla en la vista.. ¿Va tomando sentido para tí?. Pues para mí si, mucho! 😛

 

muajajajaVas a usar Diccionarios, Clases, Métodos y además vas a aprender a crear e iterar archivos en una sola lección!.

Te voy a sacar el desarrollador de adentro aunque sea a golpes de teclado!

Vamos, vamos poniéndole ganas! muajaja

Lo primero será crear e importar esta base de datos JSON para poder trabajar con ella, sino, ni modo!

 

Crear e importar el archivo JSON

Así que como primer paso crea el archivo “base_de_datos.json” dentro de la carpeta o directorio “DB” de nuestro proyecto y añade el diccionario llamado “Personas” como te muestro más abajo.

Archivo “DB/base_de_datos.json

{
  "Personas": [

    {"test" : 1},
    {"test" : 2}

  ]


}

base de datos json + explicaciónFíjate comenzamos abriendo con llaves lo que indica que se trata de un archivo JSON y dentro de esas llaves colocamos simplemente un par <Clave>:<Valor>. En este caso la Clave “Personas” que obtiene como Valor una lista, que dentro contiene más diccionarios, en el caso del ejemplo dos diccionarios con la Clave “test” y el valor “1 y 2” respectivamente.

Estos valores los hemos añadido simplemente para comprobar que podemos acceder a estos datos, posteriormente los vamos a borrar.

 

Importar la base de datos JSON al modelo para comprobar el acceso

Vamos a conectar ahora nuestra base de datos al modelo para comprobar que tenemos acceso y vamos a ver como acceder a los “datos” de test que colocamos. De esta forma sabremos claramente como posicionarnos en cada diccionario dentro de Personas y acceder a sus respectivos Pares de Clave : Valor.

Yo imagino a partir de ahora a cada diccionario dentro de la lista personas como un casillero que comienza a enumerarse por el indice “0” . Debemos aprender a acceder a uno de ellos y luego a cada clave o valor que se aloje dentro de ellas. Porque, tendremos dentro de cada diccionario o “casillero” varias claves y valores como “id” : 3, “nombre” : “Alguien”, etc.

Es importante mantener una buena identación y orden en nuestro JSON para evitar confusiones posteriores sobre todo si recién comenzamos a trabajar este tipo de datos.

Lo primero será importar nuestro archivo “.json” y buscar una librería que nos facilite esta tarea añadiendo soporte para JSON. Pero esta librería debemos importarla dentro de nuestro modelo:

Código de “modelo.py

#BLOQUE IMPORT
import json

Ahora debemos intentar acceder a nuestro archivo JSON aplicando un poco de la teoría que hemos aprendido en la lección sobre apertura, lectura y escritura de archivos en python. Pero como este post es sobre modelo y bases de datos voy a pedirte que le des un repaso rápido porque no voy a explayarme demasiado aquí sobre estos conceptos.

Vamos a probar abrir nuestro archivo JSON desde nuestro models.py con el código que aprendimos anteriormente:

# BLOQUE IMPORT
import json

#BLOQUE CONEXIÓN CON BASE DE DATOS JSON
with open ("./DB/base_de_datos.json", "r") as f: #->Abrimos y almacenamos en "f"
    print(f.read()) #-> Imprimos usando el método read() del objeto f

Si probamos a ejecutar “models.py” en la terminal inmediatamente se mostrará el contenido de nuestro archivo JSON tal cual está allí, es decir, se mostrará el código, fíjate:

modelo y base de datos JSON accediendo al archivo

Logramos acceder con éxito a nuestro archivo. Obviamente debemos especificar en que carpeta se encuentra al momento de utilizar la función open(). En mi experiencia personal he tenido problemas al momento de subir una aplicación a un servidor con el tema de los “path’s” o directorios configurados por defecto. Por ejemplo en algunos casos el interprete no logra ubicar el archivo, ya sea por conflictos con nombres de directorios o a veces porque no se le da la gana, les juro he pasado horas renegando con ese tema y he encontrado la solución, que aquí os dejo:

En caso de errores con directorios al abrir archivo
En caso de error pueden usar la librería “os” para detectar y auto-completar la ruta completa del archivo en el sistema.. Fíjate mi código:

#BLOQUE IMPORT
import os
import json

#BLOQUE APERTURA ARCHIVO JSON
THIS_FOLDER = os.path.dirname(os.path.abspath(__file__)) #-> Detectamos el directorio de este archivo ".py" que contiene este código.
my_file = os.path.join(THIS_FOLDER + '/DB/' 'base_de_datos.json') #-> A ese directorio le sumamos el del archivo. La ruta total se almacena en my_file

#Aquí "os" detecta el directorio donde se ejecuta nuestro archivo python es decir en este caso "models.py" y a partir de allí almacena esta ruta en THIS_FOLDER. Luego ya sabiendo que la ruta es donde está "models.py" bastará agregarle el directorio DB y finalmente indicar el nombre de archivo.

# --> Conexión, apertura e imprimir archivo
with open (my_file, "r") as f: #->Abrimos pasando como arg la variable my_file que contiene ruta completa
    print(f.read()) #-> Imprimos usando el método read() del objeto f

Lo dejo..La verdad creo que este código generará menos problemas, también podemos usar algún condicional para buscar el archivo en caso de que no sea encontrado o no se logre acceder a él, así como crearlo en caso de no existir. Pero eso ya “lo dejo a tu criterio”.

En mi caso usaré el segundo código que he posteado aquí por las dudas.. Bien ahora solo estamos imprimiendo el “contenido” de nuestra base de datos y eso no sirve para nada.. Lo que nosotros queremos es poder acceder a los datos. Así que vamos a intentar leer el contenido del primer diccionario dentro de la lista que es valor de “Personas”. Lo que sería “test:1”

¿Cómo acceder a un dato de la base de datos JSON desde el modelo?

Nuestra base de datos se basa en diccionarios, así que lo que tenemos que hacer simplemente es “cargar” nuestro archivo json y leer los diccionarios que se encuentran dentro pasando un numero de index (porque es una lista) y el nombre de la “Clave” de la cual queremos obtener los datos.

¿Cómo cargamos un archivo JSON?

En vez de leerlo con ese asqueroso f.read(), usamos json.load().

meme dinosaurio fEsto nos permitirá abrir un JSON pero no pasando la ruta del archivo he!. Debes pasarle como argumento la variable “f” porque allí almacenamos cuando lo abrimos. ¿Recuerdas que usamos whit open () as “f. “ASSS FFF”

  1. El contenido de nuestro JSON se almacena en “f“.
  2. Luego dentro de una variable llamada “datos” metemos el resultado de json.load(f)
  3. Esa variable datos es ahora un diccionario cuya CLAVE es “Personas” y cuyos VALORES son los demás dicionarios. Así que ya te imaginas como sigue..
  4. Accedemos igualmente que lo haríamos con diccionarios. Fíjate el código que he usado:
#BLOQUE IMPORT
import os
import json

#BLOQUE APERTURA ARCHIVO JSON
THIS_FOLDER = os.path.dirname(os.path.abspath(__file__)) #-> Detectamos el directorio de este archivo ".py" que contiene este código.
my_file = os.path.join(THIS_FOLDER + '/DB/' 'base_de_datos.json') #-> A ese directorio le sumamos el del archivo. La ruta total se almacena en my_file
#Aquí "os" detecta el directorio donde se ejecuta nuestro archivo python es decir en este caso "models.py" y a partir de allí almacena esta ruta en THIS_FOLDER. Luego ya sabiendo que la ruta es donde está "models.py" bastará agregarle el directorio DB y finalmente indicar el nombre de archivo.

# --> Cargar archivo JSON   
with open (my_file, "r") as f: #->Abrimos pasando como arg la variable my_file que contiene ruta completa Y ALMACENAMOS EN "f"
    datos = json.load(f) #-> Almacenamos en la variable "datos" la interpreteación de nuestro JSON que está almacenado en "f"

#Ahora datos es un diccionario.Así que probamos imprimir el valor de la clave "Personas":

print(datos['Personas'])

Fíjate el resultado:

modelo y bases de datos json

 

Como ves nos imprime los diccionarios que se encuentran dentro de la lista que la clave “Personas” toma como valor.

Lo importante es darnos cuenta que cada uno de esos diccionarios que nos muestre será entonces el registro de cada persona almacenada en nuestra base de datos JSON.

Ahora que ya sabemos como acceder a el contenido de la lista nos faltará acceder a la clave de determinado diccionario.

Sabemos que estos diccionarios son elementos de una lista, por tanto se organizarán por “index” por lo que el primero será index : 0.

Por ende para evitar usar un bucle for o cualquier otro método nos conviene almacenar directamente los diccionarios que se encuentran dentro de la lista en una variable que llamaré (datos_personas), concediéndonos así un acceso más rápido a los datos, fíjate y no uses bucles for:

#Ahora datos es un diccionario.
#Almacenamos los diccionarios en una sola variable:
datos_personas = datos['Personas']
#Ahora "Personas" almacena los diccionarios.
#Así que nos basta con indicar el index y el nombre de CLAVE PARA IMPRIMIR UN VALOR
print(datos_personas[0]['test'])

 

accederFíjate solo con eso, ya nos organizamos para poder mostrar el dato que deseemos. Solo nos bastará llamar a la variable “datos_personas” que contiene una lista de diccionarios, por lo que primero indicamos el numero de index al cual queremos acceder, lo que será un diccionario, y finalmente la clave del diccionario de la cual queremos mostrar el valor!

 

 

Así que nuestro código organizado queda así:

#BLOQUE IMPORT
import os
import json

#BLOQUE APERTURA ARCHIVO JSON
THIS_FOLDER = os.path.dirname(os.path.abspath(__file__)) #-> Detectamos el directorio de este archivo ".py" que contiene este código.
my_file = os.path.join(THIS_FOLDER + '/DB/' 'base_de_datos.json') #-> A ese directorio le sumamos el del archivo. La ruta total se almacena en my_file
#Aquí "os" detecta el directorio donde se ejecuta nuestro archivo python es decir en este caso "models.py" y a partir de allí almacena esta ruta en THIS_FOLDER. Luego ya sabiendo que la ruta es donde está "models.py" bastará agregarle el directorio DB y finalmente indicar el nombre de archivo.

# --> Cargar archivo JSON   
with open (my_file, "r") as f: #->Abrimos pasando como arg la variable my_file que contiene ruta completa Y ALMACENAMOS EN "f"
    datos = json.load(f) #-> Almacenamos en la variable "datos" la interpreteación de nuestro JSON que está almacenado en "f"


#Ahora datos es un diccionario.
#Almacenamos los diccionarios en una sola variable:
datos_personas = datos['Personas']
#Ahora "datos_personas" almacena los diccionarios.
#Así que nos basta con indicar el index de la lista correspondiente y el nombre de CLAVE PARA IMPRIMIR UN VALOR
print(datos_personas[0]['test'])

Resultado: 1

Bueno, ya sabemos acceder a los datos y nos será fácil entonces modificarlos, borrarlos, etc. Ya podemos trabajar muy comodamente simplemente aplicando la teoría que aprendimos para acceder a Listas y Diccionarios!

Ahora debemos diseñar el modelo, crear una clase Persona para poder añadir nuevas personas y los métodos para poderlas ver, modificar y eliminar!.

Vamos a ello!!

Creando el modelo

Ya conocemos los datos que vamos a utilizar. Así que vamos a crear la clase “Persona” dentro del modelo, esta clase será la que modele los datos en la base de datos y dispondrá de los métodos encargados de mostrar, agregar, modificar y eliminar elementos.

Un aspecto importante a tener en cuenta además de los datos antes mencionados “Nombre, Apellido, Apodo, Teléfono, Dirección” es que debemos incluir una Clave única que diferencie un elemento de otro. Así cada persona tendra su clave única y en el caso que dos personas tengan el mismo nombre, o incluso todos los mismos datos no causarán inconsistencia en nuestra base de datos. Aquí no parece tan importante porque se trata de una aplicación muy simple y estamos utilizando una base de datos no relacional (JSON). Pero en otros casos o quizás en el caso que necesitemos exportar los datos en un futuro resulta muy importante y una buena práctica añadir un “id” o Clave única.

Así que añadiendo la clase “Persona” nuestro modelo.py queda así:

#BLOQUE IMPORT
import os
import json

#BLOQUE APERTURA ARCHIVO JSON
THIS_FOLDER = os.path.dirname(os.path.abspath(__file__)) #-> Detectamos el directorio de este archivo ".py" que contiene este código.
my_file = os.path.join(THIS_FOLDER + '/DB/' 'base_de_datos.json') #-> A ese directorio le sumamos el del archivo. La ruta total se almacena en my_file
#Aquí "os" detecta el directorio donde se ejecuta nuestro archivo python es decir en este caso "models.py" y a partir de allí almacena esta ruta en THIS_FOLDER. Luego ya sabiendo que la ruta es donde está "models.py" bastará agregarle el directorio DB y finalmente indicar el nombre de archivo.

# --> Cargar archivo JSON   
with open (my_file, "r") as f: #->Abrimos pasando como arg la variable my_file que contiene ruta completa Y ALMACENAMOS EN "f"
    datos = json.load(f) #-> Almacenamos en la variable "datos" la interpreteación de nuestro JSON que está almacenado en "f"


#Ahora datos es un diccionario.
#Almacenamos los diccionarios en una sola variable:
datos_personas = datos['Personas']
#Ahora "datos_personas" almacena los diccionarios.
#Así que nos basta con indicar el index y el nombre de CLAVE PARA IMPRIMIR UN VALOR
#print(datos_personas[0]['test'])

#BLOQUE CLASE PERSONA Y CRUD

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

 

A partir de aquí recordarás que instanciando un nuevo objeto de la clase Persona tendrá estos atributos y que debes pasarlos al momento de crear dicha instancia.

Lo que tenemos que hacer ahora es que al momento de crear un objeto de la clase “Persona” este tenga la forma de un diccionario!

Y eso lo hacemos de la siguiente manera usando __dict__:

#Ejemplo creamos la instancia "persona_test" con mis datos y usamos "__dict__" para convertirlo en diccionario
 
persona_test = Persona(0, "Mariano", "Laca", "Pyromaniac", "34343434", "pythones.net").__dict__

print(persona_test)

Y listo!. Solo nos faltaría añadir estos datos a nuestra base de datos JSON. Claro que esto es puro ejemplo y palabrería.

Código completo de nuestro models.py hasta ahora:

#BLOQUE IMPORT
import os
import json

#BLOQUE APERTURA ARCHIVO JSON
THIS_FOLDER = os.path.dirname(os.path.abspath(__file__)) #-> Detectamos el directorio de este archivo ".py" que contiene este código.
my_file = os.path.join(THIS_FOLDER + '/DB/' 'base_de_datos.json') #-> A ese directorio le sumamos el del archivo. La ruta total se almacena en my_file
#Aquí "os" detecta el directorio donde se ejecuta nuestro archivo python es decir en este caso "models.py" y a partir de allí almacena esta ruta en THIS_FOLDER. Luego ya sabiendo que la ruta es donde está "models.py" bastará agregarle el directorio DB y finalmente indicar el nombre de archivo.

# --> Cargar archivo JSON   
with open (my_file, "r") as f: #->Abrimos pasando como arg la variable my_file que contiene ruta completa Y ALMACENAMOS EN "f"
    datos = json.load(f) #-> Almacenamos en la variable "datos" la interpreteación de nuestro JSON que está almacenado en "f"


#Ahora datos es un diccionario.
#Almacenamos los diccionarios en una sola variable:
datos_personas = datos['Personas']
#Ahora "datos_personas" almacena los diccionarios.
#Así que nos basta con indicar el index y el nombre de CLAVE PARA IMPRIMIR UN VALOR
#print(datos_personas[0]['test'])

#BLOQUE CLASE PERSONA Y CRUD


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

persona_test = Persona(0, "Mariano", "Laca", "Pyromaniac", "34343434", "pythones.net").__dict__
print(persona_test)

Resultado:

{‘id’: 0, ‘nombre’: ‘Mariano’, ‘apellido’: ‘Laca’, ‘apodo’: ‘Pyromaniac’, ‘telefono’: ‘34343434’, ‘direccion’: ‘pythones.net’}

En la siguiente lección vamos a crear los métodos CRUD (Create, Read, Update, Delete) para que nuestro modelo pueda comenzar a trabajar en nuestra base de datos y finalmente conectaremos los 3 elementos que conforman la arquitectura MVC de nuestro proyecto.


 

 

Continúa leyendo!
Entrada anterior! Siguiente entrada!
Compartir es agradecer! :)

Hey no te vayas sin dejarme un comentario!

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.

Aprende a programar de manera profesional!

¿Todavía sin obtener una retribución justa de tu aprendizaje?

Curso de Python Udemy

Convierteté en un verdadero Jedy de Python y comienza a desarrollar aplicaciones de forma profesional obteniendo un certificado de Udemy!. Pasate por la sección de Cursos Premium y realiza los mejores cursos con certificación válida a nivel internacional por apenas unos dolares!