Creando modelos en Django

- Andrés Cruz

In english
Creando modelos en Django

En esta entrada vamos a ver cómo podemos crear un modelo en Django; ya en anteriores entradas tratamos como podemos crear la conexión a la base de datos de un proyecto en Django con MySQL, ahora vamos aprovechar esa conexión para poder hacer vistas y templates más interesantes y no simplemente un hola mundo o una impresión de texto o visas estáticas como vimos anteriormente.

Esta entrada proporciona un uso bastante general para los django-models; de tal manera, que vas a conocer para qué sirven y para qué más los podemos emplear, por ejemplo, para las migraciones y tablas en la base de datos mediante Django.

¿Qué es un modelo?

Recordemos que un modelo simplemente es una de las capas de nuestro MVC, (MTV en Django) con el cual trabajamos con los datos, las consultas, búsquedas, inserciones y cualquier operación a la base de datos en general sobre una tabla.

Por lo tanto, es el mecanismo que tenemos para conectarnos a nuestra base de datos y realizar cualquier tipo de operación en la misma.

Los modelos y el archivo único de la aplicación en Django

Para crear un modelo, obviamente necesitamos tener un proyecto y aplicación en Django cosa que ya hicimos anteriormente, en la aplicación llamada:

firstProject

Tenemos un archivo llamado models.py que esta completamente vacío; como puedes deducir por el nombre del archivo, sirve para almacenar o definir TODOS los modelos de esta aplicación, por lo tanto si vienes de PHP como yo, esto te puede chocar un poco ya que en frameworks populares como CodeIgniter o Laravel, nosotros definimos un modelo por clase, es decir, en un modelo solamente tenemos almacenados una clase y listo; pero en Django, específicamente en Python esto no es así y esto es muy bueno.

Una ventaja enorme que tenemos al crear clases como modelos o formularios en Django es que podemos definir todas las estructuras es decir, las clases en un solo archivo, por lo tanto podemos tener un gran control sobre cada una de las capas o subcapas de nuestro proyecto.

Y esto se debe a la gran modularización y organización al momento de importar una clase, función o variable desde Python.

Crear un modelo en Django

Finalmente vamos a crear un modelo; un modelo simplemente es una clase en Python que define atributos en donde cada atributo es generalmente un campo de nuestro objeto que esto más adelante se va a traducir como una columna en base de datos, pero ya llegaremos a esto.

Tipos de campos

Tenemos múltiples tipos de campos que podemos emplear, para tipo texto, números, booleanos archivos, imágenes  y un largo etc:

Puedes ver más en la documentación oficial

Así que, finalmente vamos a crear un modelo por ejemplo uno que creamos en nuestro gran curso sobre Django que luzca de la siguiente manera:

class Comment(models.Model):
    text = models.TextField()
    date_posted = models.DateTimeField(auto_now_add=True)
    element = models.ForeignKey(Element, related_name='comments', on_delete=models.CASCADE, NULL=True)
 
    def __str__(self):
        return 'Comentario #{}'.format(self.id)

Explicación del código anterior

Entonces, tenemos una propiedad para el texto del comentario y una fecha, así de simple; pero como puedes ver, le podemos definir también atributos en los campos, que dependiendo del tipo de campo podemos definir unos u otros atributos u opciones, como es en caso de auto_now_add que recibe un booleano para indicar que apenas creemos este registro en la base de datos tome la fecha actual del sistema.

Como puedes ver, simplemente tenemos que especificar el tipo campo con la función correspondiente, por ejemplo TextField para un campo abierto de texto, o un campo DateTimeField para un campo de fecha, especificamos el nombre de la columna que sería el mismo nombre del atributo y listo.

Y con esto creamos nuestro primer modelo en Django; en las próximas entradas veremos qué más podemos hacer con este nuevo elemento en Django.

También especificamos el tipo de relación que en este caso es de tipo cascade.

Los modelos son la fuente única y definitiva de información sobre sus datos. Contiene los campos y comportamientos esenciales de los datos que está almacenando (la lógica de negocios). Generalmente, cada modelo se asigna a una sola tabla de base de datos y es una de las capas de nuestro MTV.

Y, en definitiva, son la capa que permite acceder a la base de datos y es la única entrada a la misma; cada aplicación en Django puede tener cero o más modelos, todos ellos viven dentro del archivo llamado models.py que se encuentra definido en cada aplicación.

Un modelo no es más que una clase, en donde, dicha clase va a ser reflejado en la base de datos a una tabla; es decir, una clase modelo (entiéndase una clase que está definida dentro del archivos models.py) va a corresponder a una tabla en la base de datos.

Importante señalar que, para crear las tablas correspondientes en la base de datos, es necesario ejecutar un comando, pero eso lo veremos luego.

Crear modelos

Los modelos forman parte de las aplicaciones en Django; dentro del archivo llamado models.py tal cual indica su nombre, podemos definir todos los modelos que se van a usar en la aplicación u otras aplicaciones mediante las importaciones.

Esto último, lo puedes constatar en la descripción de los models.py

# Crea tus modelos aquí.

Caso práctico

Dentro de la aplicación que creamos anteriormente, vamos a crear las siguientes clases:

elements/models.py

from django.db import models

# Create your models here.

class Category(models.Model):
    title = models.CharField(max_length=255)
    slug = models.SlugField(max_length=255)

    def __str__(self):
        return self.title

class Type(models.Model):
    title = models.CharField(max_length=255)
    slug = models.SlugField(max_length=255)

    def __str__(self):
        return self.title

class Element(models.Model):
    title = models.CharField(max_length=255)
    slug = models.SlugField(max_length=255,blank=True)
    description = models.TextField()
    price = models.DecimalField(max_digits=10,decimal_places=2, default=6.10) # 12345678.10
    category = models.ForeignKey(Category, on_delete=models.CASCADE)
    created = models.DateTimeField(auto_now_add=True)
    updated = models.DateTimeField(auto_now=True)
    type = models.ForeignKey(Type, on_delete=models.CASCADE)

Explicación del código anterior

Aquí ya puedes empezar a ver las maravillas de Python; sintaxis limpia, expresiva y seguramente ya entiendas al menos en buena medida qué es lo que estamos definiendo.

Lo primero que hacemos es importar la clase Model de Django:

from django.db import models
***
models.Model

Luego, creamos clases que hereda de la importación anterior:

class Category(models.Model):
   ***
class Type(models.Model):
   ***
class Element(models.Model):
   ***

Dotando a dichas clases de ciertas características que iremos viendo poco a poco, que en este caso muy particular sería para manejar los modelos, incluyendo las conexiones a la base de datos y mapeo de dichas clases a la base de datos mediante las migraciones.

Luego, cada una de las propiedades anteriores definida en dicha clase, conforman la estructura de la entidad que queremos crear; en este caso categorías, tipos y elementos.

Aquí en este archivo elements/models.py, creamos tres modelos diferentes, dos de ellos son simples y son para la categoría y el tipo y el tercero es un poco más elaborado cuya intención es que pueda registrar publicaciones; publicaciones que pueden ser un post, curso o cualquier otra tipificación que quieras usar; el término de "element" se usa en el libro para colocar un nombre neutro para cada uno de estos tipos o clasificaciones.

Vamos a desfragmentar la clase de Element; entendiendo sus columnas, entenderás el de las otras dos clases y definiciones similares:

  • Con models.CharField(max_length=255) para la propiedad title, definimos un campo de tipo texto (CharField) el cual permite almacenar caracteres, con un atributo para limitar el tamaño máximo de 255 caracteres (max_length).
  • Con models.SlugField(max_length=255,blank=True) para la propiedad slug, definimos un campo de tipo SlugField, el cual permite almacenar solamente, letras, números y guiones que es ideal para manejar las URLs limpias o slug. 
    • Con el blank indicamos que puede almacenar valores en blanco.
  • Con models.DecimalField(max_digits=10,decimal_places=2, default=6.10) para la propiedad price, indicamos un campo de tipo de decimal de una longitud de 10 dígitos como máximo y dos partes decimales con un valor por defecto de 6.10.
  • Con models.ForeignKey(<Relacion>, on_delete=models.CASCADE) Crearemos una relación foránea de tipo en cascada, con la categoría y tipo.
  • Para models.TextField() para la propiedad description, definimos un campo de tipo texto; esto es ideal para guardar grandes cantidades de texto.
  • Para los campos de fecha para created y updated que representan las fechas de creación y actualización de registros respectivamente, indicamos el campo de tipo DateTimeField que con el atributo de auto_now_add indicamos que puede establezca una fecha al generar el objeto y con el auto_now indicamos qué al guardar el objeto, coloque la fecha actual.

El porqué de esta estructura se debe a una publicación de cualquier tipo en el mundo real, si quieres crear una publicación, los elementos básicos son un título y contenido; generalmente le indicamos un resumen o descripción, y por supuestos unas fechas de controles son siempre bienvenidas; finalmente, al tener muchos posts de diversos tipos, le agregamos clasificaciones como indicamos anteriormente.

A la final, es importante que te familiarices con los tipos de columnas y atributos para emplear los que más de adapten a tus necesidades:

https://docs.djangoproject.com/en/dev/ref/models/fields/#field-types

Andrés Cruz

Desarrollo con Laravel, Django, Flask, CodeIgniter, HTML5, CSS3, MySQL, JavaScript, Vue, Android, iOS, Flutter

Andrés Cruz en Udemy

Acepto recibir anuncios de interes sobre este Blog.