13_modelos_de_django.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[![imagenes/pythonista.png](imagenes/pythonista.png)](https://pythonista.io)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Modelos de *Django*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**ADVERTENCIAS:** \n",
    "\n",
    "* Para poder realizar exitosamente los ejercicios de esta notebook, es necesario haber seguido al pie de la letra y en orden sucesivo las instrucciones de todas las notebooks previas.\n",
    "* Para facilitar la ejecución de los ejercicios se utuilizará la base de datos *SQLite* que viene configurada por defecto para el proyecto ```tutorial```."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Los modelos de *Django*.\n",
    "\n",
    "Los modelos de *Django* son los componentes relacionados con la estructura de los datos de una organización para un proceso, proyecto o aplicación específica.\n",
    "\n",
    "Como su nombre lo indica, los modelo se utilizan para describir los estados y actividades de los actores dentro de un proceso.\n",
    "\n",
    "*Django* permite crear objetos cuyo estado es mapeado en una base de datos mediante el uso de clases especiales con las siguientes características:\n",
    " \n",
    "* Cada clase corresponde al menos a una tabla, y por lo general solo  a una, en una base de datos relacional.\n",
    "* La clase puede mapear un atributo a una columna de una tabla.\n",
    "* Los objetos instanciados de estas clases son mapeados con un registro de la tabla en la que cada campo corresponde a un atributo mapeado del objeto.\n",
    "\n",
    "La referencia completa sobre modelos  puede ser consultada en:\n",
    "\n",
    "https://docs.djangoproject.com/en/3.0/topics/db/models/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## La clase ```django.db.models.Model```.\n",
    "\n",
    "La clase ```django.db.models.Model``` es la clase base que hereda a los modelos que se definirán en una aplicación de *Django*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from django.db.models import Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(Model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funcionamiento del mapeo entre los modelos y las bases de datos.\n",
    "\n",
    "Un modelo es una clase que hereda a ```django.db.models.Model```. El modelo es entonces ligado a una tabla en una base de datos.\n",
    "\n",
    "Es posible definir atributos de clase que corresponderán a una columna de la tabla del modelo.\n",
    "\n",
    "Los objetos instanciados del modelo pueden relacionarse a un registro en la tabla del modelo y cada atributo del objeto sería un campo del registro correspondiente.\n",
    "\n",
    "Un modelo se define de la siguiente forma:\n",
    "\n",
    "```\n",
    "from django.db.models import Model\n",
    "...\n",
    "...\n",
    "class <Modelo>(Model):\n",
    "    <atributo 1>(<tipo de campo>, <kwargs>)\n",
    "    <atributo 2>(<tipo de campo>, <kwargs>)\n",
    "    ...\n",
    "    ...\n",
    "    <atributo n>(<tipo de campo>, <kwargs>)\n",
    "    \n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Asignación de una tabla de la base de datos a un modelo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tipos de campos del ORM de *Django*.\n",
    "\n",
    "*Django* tiene la capacidad de extender los tipos de datos de Python así como los de cada gestor de bases de datos mendiante el uso de su propio gestor de modelos de objetos relacional, también conocido como *ORM* por sus siglas en inglés.\n",
    "\n",
    "Lo anterior permite definir una extensa variedad de tipos de datos que optimiza el desarrollo de aplicaciones de forma transparente e independiente de la naturaleza del gestor de base de datos datos.\n",
    "\n",
    "Es posible consultar los tipos de datos definidos por *Django* desde la siguiente liga:\n",
    "\n",
    "https://docs.djangoproject.com/en/2.2/ref/models/fields/#field-types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Opciones de los campos.\n",
    "\n",
    "Además del tipo de datos, es posible definir algunas opciones que permiten a los campos tener caracterísdticas especiales.\n",
    "\n",
    "Es posible consultar las opciones definidos por *Django* desde la siguiente liga:\n",
    "\n",
    "https://docs.djangoproject.com/en/2.2/ref/models/fields/#field-options"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Los archivos ```models.py```.\n",
    "\n",
    "Estos archivos son los indicados por *Django* para la definición de modelos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejemplo:**\n",
    "\n",
    "* El archivo ```tutorial/main/models.py``` aún no cuenta con alguna definición de modelos y contendría algo similar a lo siguiente:\n",
    "\n",
    "```\n",
    "from django.db import models\n",
    "\n",
    "# Create your models here.\n",
    "\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pycat tutorial/main/models.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Definición de un modelo ilustrativo.\n",
    "\n",
    "El archivo ```src/13/models.py``` contiene el siguiente código, el cual define a la clase ```Alumno```, la cual es subclase de ```django.db.models.Model```.\n",
    "\n",
    "La clase ```Alumno``` cuenta con los atributos:\n",
    "\n",
    "* ```numero_de_cuenta```, el cual es un entero positivo que debe de ser único en la tabla.\n",
    "* ```nombre```, el cual es una cadena de 50 caracteres como máximo.\n",
    "* ```primer_apellido```, el cual es una cadena de 50 caracteres como máximo.\n",
    "* ```segundo_apellido```, el cual es una cadena de 50 caracteres como máximo.\n",
    "* ```carrera```, el cual es una cadena de 20 caracteres como máximo.\n",
    "* ```promedio```, el cual es un número de tipo flotante.\n",
    "* ```al_corriente```, el cual es un booleano."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "``` python\n",
    "from django.db import models\n",
    "\n",
    "class Alumno(models.Model):\n",
    "    numero_de_cuenta = models.PositiveIntegerField(unique=True)\n",
    "    nombre = models.CharField(max_length=50)\n",
    "    primer_apellido = models.CharField(max_length=50)\n",
    "    segundo_apellido = models.CharField(max_length=50)\n",
    "    carrera = models.CharField(max_length=25)\n",
    "    promedio = models.FloatField()\n",
    "    al_corriente = models.BoolField()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* La siguiente celda sutituirá al script ```tutorial/main/models.py``` con el script ```src/13/models.py```."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Para las plataformas GNU/linux y MacOS X."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!cp src/13/models.py tutorial/main/models.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Para la plataforma Windows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!copy src\\13\\models.py tutorial\\main\\models.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* La siguiente celda mostrará el resultado de la sustitución en el script ```tutorial/main/models.py```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pycat tutorial/main/models.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inclusión de modelos en la configuración.\n",
    "\n",
    "Para que un archivo ```models.py``` pueda ser incluido por *Django*, es necesario indicar su localización en la lista ```INSTALLED_APPS``` del script ```settings.py``` correspondiente como si se tratara de un módulo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejemplo:**\n",
    "El script ```src/13/settings.py``` incluye la cadena ```'main'``` en la lista ```INSTALLED_APPS``` de la siguiente forma:\n",
    "\n",
    "``` python\n",
    "INSTALLED_APPS = [\n",
    "    'django.contrib.admin',\n",
    "    'django.contrib.auth',\n",
    "    'django.contrib.contenttypes',\n",
    "    'django.contrib.sessions',\n",
    "    'django.contrib.messages',\n",
    "    'django.contrib.staticfiles',\n",
    "    'main',\n",
    "]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* La siguiente celda sustituye al archivo ```tutorial/tutorial/settings.py``` con el archivo ```src/13/settings.py```."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Para las plataformas GNU/Linux y MacOS X."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!cp src/13/settings.py tutorial/tutorial/settings.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Para las plataformas Windows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!copy src\\13\\settings.py tutorial\\tutorial\\settings.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* La siguiente celda mostrará el resultado de la sustitución en el script ```tutorial/tutorial/settings.py```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pycat tutorial/tutorial/settings.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## El subcomando ```makemigrations```.\n",
    "\n",
    "El subcomando ```makemigrations``` de ```manage.py``` permite conciliar las estructuras de los modelos definidos con la estructura de tablas de la base de datos de *Django*.\n",
    "\n",
    "\n",
    "```\n",
    "./manage.py makemigrations\n",
    "```\n",
    "o\n",
    "```\n",
    "python manage.py makemigrations\n",
    "```\n",
    "\n",
    "Este comando creará diversos archivos de Python en el subdirectorio ```migrations``` de la aplicación.\n",
    "\n",
    "Una vez conciliadas, los cambios se apicarán meniante ```manage.py migrate```."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejemplo:**\n",
    "\n",
    "Se realizará la conciliación del modelo definido en la aplicación ```main``` en el proyecto ```tutorial```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%cd tutorial"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "!python manage.py makemigrations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "!python manage.py migrate --database=default"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Aún cuando se realizó la conciliación, *Django* no crea una nueva tabla, ya que antes debe de crearse al menos una instancia del modelo ```Alumno``` definido en ```tutorial/main/models.py```."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Consulta de la base de datos *SQLite*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext sql"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%sql sqlite:///tutorial/db.sqlite3 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "%%sql sqlite:///tutorial/db.sqlite3\n",
    "SELECT * FROM main_alumno"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: center\"><a rel=\"license\" href=\"http://creativecommons.org/licenses/by/4.0/\"><img alt=\"Licencia Creative Commons\" style=\"border-width:0\" src=\"https://i.creativecommons.org/l/by/4.0/80x15.png\" /></a><br />Esta obra está bajo una <a rel=\"license\" href=\"http://creativecommons.org/licenses/by/4.0/\">Licencia Creative Commons Atribución 4.0 Internacional</a>.</p>\n",
    "<p style=\"text-align: center\">&copy; José Luis Chiquete Valdivieso. 2020.</p>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}