Header Ads Widget

Ticker

6/recent/ticker-posts

Modelos en Django

 

Ahora que sabemos sobre el enrutamiento en Django y cómo las URL se asignan a las vistas y funciones de visualización que envían plantillas Html al usuario, ahora podemos aprender sobre los modelos en Django. Los modelos introducen el concepto de utilizar datos dinámicos de una base de datos para potenciar la interfaz del sitio web que el usuario ve e interactúa. Por ejemplo, en nuestra pequeña aplicación de blog, queremos almacenar una colección de publicaciones en la base de datos. Los modelos en Django son una clase que representa una tabla en una base de datos. Cada tipo de datos, como Publicaciones o Usuarios, está representado por su propio modelo. Un modelo se asigna a una sola tabla en la base de datos.


Crear un modelo de publicación

Uno de los archivos que se crearon cuando ejecutamos el comando python manage.py startapp posts es el archivo models.py . Django creó este archivo para nosotros para que podamos definir uno o más modelos en este archivo de Python.

archivo django modelspy

Para definir un modelo en este archivo, podemos agregar una clase Python.

posts / models.py

Django tiene muchos tipos de campos para modelosEn el código anterior utilizamos cuatro tipos de campos diferentes. Tenemos CharFieldSlugFieldTextField y DateTimeFieldCada campo definido en un modelo está asociado con un widget determinado que se mostrará en el área de administración o en la parte frontal del sitio web donde el usuario puede interactuar con él. El widget de formulario predeterminado para CharField es TextInput. El widget de formulario predeterminado para un TextField es un Textarea. El widget de formulario predeterminado para un DateTimeField es un único TextInput. El administrador usa dos widgets TextInput separados con atajos de JavaScript.


Migraciones de Django

El primer paso para trabajar con un modelo en Django es crear la clase Model en el archivo models.py. Dimos ese paso en la sección anterior. Las migraciones dan el paso de mapear la clase Model a una tabla en la base de datos. Antes de crear y ejecutar nuestra propia migración, debemos ver las otras migraciones que Django ya ha creado. Es posible que haya notado que cuando ejecuta el comando python manage.py runserver en su terminal, aparece un mensaje sobre las migraciones no aplicadas.

djangoblog $ python manage.py runserver
Observación de cambios de archivos con StatReloader
Realización de comprobaciones del sistema ...

La verificación del sistema no identificó problemas (0 silenciados).

Tiene 17 migración (es) sin aplicar. Es posible que su proyecto no funcione correctamente hasta que aplique las migraciones para las aplicaciones: administrador, autenticación, tipos de contenido, sesiones.
Ejecute 'python manage.py migrate' para aplicarlos.

Django versión 3.0.3, usando la configuración 'djangoblog.settings'
Iniciando el servidor de desarrollo en http://127.0.0.1:8000/
Salga del servidor con CTRL-BREAK.

Así que sigamos adelante y migremos las migraciones integradas primero ejecutando el comando python manage.py migrate .

djangoblog $ python manage.py migrar
Operaciones a realizar:
  Aplicar todas las migraciones: admin, auth, contenttypes, sesiones
Ejecutando migraciones:
  Aplicando contenttypes.0001_initial ... OK
  Aplicando auth.0001_initial ... OK
  Aplicando admin.0001_initial ... OK
  Aplicando admin.0002_logentry_remove_auto_add ... OK Aplicando admin.0003_logentry_add_action_flag_choices ... OK
  Aplicando contenttypes.0002_remove_content_type_name ... OK
  Aplicando auth.0002_alter_permission_name_max_length ... OK
  Aplicando auth.0003_alter_user_email_max_length ... OK
  Aplicando auth.0004_alter_user_username_opts ... OK
  Aplicando auth.0005_alter_user_last_login_null ... OK
  Aplicando auth.0006_require_contenttypes_0002 ... OK
  Aplicando auth.0007_alter_validators_add_error_messages ... OK
  Aplicando auth.0008_alter_user_username_max_length ... OK
  Aplicando auth.0009_alter_user_last_name_max_length ... OK
  Aplicando auth.0010_alter_group_name_max_length ... OK
  Aplicando auth.0011_update_proxy_permissions ... OK
  Aplicando sesiones.0001_initial ... OK

Para sus propios modelos, primero debe crear un archivo o archivos de migración. Un archivo de migración rastrea cualquier cambio que realice en un modelo. Por lo tanto, cada vez que actualice un modelo, también debe actualizar la migración. Veremos esto en acción a medida que avancemos, pero ahora comencemos a usar el comando python manage.py makemigrations .

djangoblog $ python manage.py makemigrations
Migraciones para 'publicaciones':
  postsmigrations001_initial.py
    - Crear publicación modelo

Como podemos ver en el resultado, Django reconoció que habíamos definido un modelo de publicación. Django leyó ese archivo y su definición de modelo, luego creó un nuevo archivo de migraciones llamado 0001_initial.py para nosotros. ¡Muy genial!

generación de migración del modelo django

Esto significa que ahora una vez más tenemos migraciones sin aplicar. De hecho, si volvemos a ejecutar el servidor, ahora recibimos el mensaje de que tenemos 1 migración sin aplicar.

djangoblog $ python manage.py runserver
Observación de cambios de archivos con StatReloader
Realización de comprobaciones del sistema ...
La verificación del sistema no identificó problemas (0 silenciados).

Tiene 1 migración (es) sin aplicar. Es posible que su proyecto no funcione correctamente hasta que
aplicar las migraciones para la (s) aplicación (es): publicaciones.
Ejecute 'python manage.py migrate' para aplicarlos.

Django versión 3.0.3, usando la configuración 'djangoblog.settings'
Iniciando el servidor de desarrollo en http://127.0.0.1:8000/
Salga del servidor con CTRL-BREAK.

Podemos salir del servidor ahora y ejecutar el comando python manage.py migrate así.

djangoblog $ python manage.py migrar
Operaciones a realizar:
  Aplicar todas las migraciones: admin, auth, contenttypes, posts, sesiones
Ejecutando migraciones:
  Aplicando publicaciones.0001_initial ... OK

¡Excelente! Nuestro propio modelo de publicación personalizado ahora está migrado. Nuestro modelo de clase de Python ahora está asignado a una tabla en la base de datos. Ahora, cada vez que hacemos un nuevo modelo o cambiamos un modelo existente, debemos pasar por el mismo proceso. En otras palabras, primero debemos ejecutar python manage.py makemigrations , y luego debemos ejecutar python manage.py migrate .


El ORM de Django

El ORM de Django es una excelente manera de interactuar con nuestra base de datos. El mapeador relacional de objetos es lo que cierra la brecha entre el código y la base de datos. El ORM proporciona una funcionalidad completa de creación, lectura, actualización y eliminación a través del modelo que hemos definido. Podemos comenzar simplemente usando el shell interactivo en Django antes de colocar el código en nuestra aplicación.

El Shell de Django

Python en sí tiene un shell en el que simplemente puede escribir python y hacer clic en Enter para obtener un mensaje donde puede ingresar el código Python para ejecutar. Este no es ese caparazón y es una distinción bastante importante. Si desea usar el shell con Django, debe asegurarse de usar el comando de shell python manage.py desde la raíz del proyecto Django. Si intenta utilizar el shell de Python normal, encontrará errores al intentar interactuar con sus modelos. Entonces, cuando ejecute el shell de Django, verá algo como esto.

djangoblog $ python manage.py shell
Python 3.8.0 (etiquetas / v3.8.0: fa919fd, 14 de octubre de 2019, 19:21:23) [MSC v.1916 de 32 bits (Intel)] en win32
Escriba "ayuda", "derechos de autor", "créditos" o "licencia" para obtener más información.
(Consola interactiva)
>>>

Para comenzar a trabajar con el modelo que creamos, escriba lo siguiente.

>>> de posts.models import Post
>>> Publicar

Primero, importamos el modelo Post del archivo models.py que se encuentra en la aplicación de publicaciones. Luego, simplemente escribimos Publicar en la línea de comando y vemos que es una instancia de la clase de modelo Post. Dado que esta clase hereda de los modelos .Model en Django, esto significa que tenemos acceso a todo tipo de métodos para trabajar con la base de datos.

Insertar una publicación

Todavía no hay publicaciones en la base de datos, así que sigamos adelante e ingresemos una nueva publicación en la base de datos usando el ORM. Así es como se hace.

>>> publicar = Publicar ()
>>> post.title = '¡Un nuevo título!'
>>> post.save ()

Hay más campos para completar, pero solo queríamos echar un vistazo al método .save () para guardar algo en la base de datos.

Obtener todos los registros

Ahora que hay una publicación en la base de datos, deberíamos poder consultar la base de datos desde la terminal y ver un resultado. Probemos eso ahora.

>>> Publicar.objetos.todos ()
]>

Efectivamente, vemos que hay un resultado en QuerySet, y esa es la publicación que acabamos de guardar.

Obteniendo el primer registro

Solo tenemos un registro en la base de datos, pero para obtener explícitamente solo el primer registro, podemos hacerlo con esta sintaxis.

>>> Publicar.objetos.todos () [0]

Como puede ver, esto devuelve una instancia de una publicación, no un QuerySet. Yendo más allá, incluso podemos profundizar en campos específicos de la tabla usando esta sintaxis.

>>> Post.objects.all () [0] .title
'¡Un nuevo título!'

Así que esto es bastante bueno, hemos creado un modelo, ingresamos un nuevo modelo en la base de datos y recuperamos ese modelo de la base de datos, todo usando el ORM de Django. No necesitábamos escribir manualmente ningún SQL, Django manejó todo eso por nosotros.

Definición de una función __str__

Para hacer que nuestros modelos sean un poco más fáciles de usar, podemos agregar una nueva función que determinará cómo se verá una publicación tanto en la sección de administración como en el shell. Por lo tanto, esta función genera la versión de cadena de la publicación no como un objeto, sino como el título de la instancia.

Intentemos trabajar con el modelo de publicación una vez más en el shell interactivo.

>>> de posts.models import Post
>>> Publicar.objetos.todos ()
]>

¡Con buena pinta! Ahora, cuando buscamos todas las publicaciones usando Post.objects.all () , vemos el título justo en el conjunto de consultas. Si tuviéramos más publicaciones en la base de datos, también veríamos esos títulos. De hecho, podemos agregar otra publicación con un título diferente y luego realizar la misma consulta para ver el resultado.

>>> publicar = Publicar ()
>>> post.title = '¡Segunda publicación!'
>>> post.save ()
>>> Publicar.objetos.todos ()
, ]>

Interactuar con modelos mediante el administrador

Hemos aprendido cómo configurar el área de administración de Django, así que vamos a habilitarlo también en este proyecto. Recuerde que los pasos para hacer esto implican primero crear un superusuario con el archivo manage.py con el comando python manage.py createduperuser .

djangoblog $ python manage.py crea superusuario
Nombre de usuario (déjelo en blanco para usar 'myusername'): admin
Dirección de correo electrónico: admin@example.com
Contraseña:
Contraseña de nuevo):
Error: no se permiten contraseñas en blanco.
Contraseña:
Contraseña de nuevo):
Superusuario creado correctamente.

Una vez que haya creado un superusuario, continúe y visite la dirección http://127.0.0.1:8000/admin en un navegador web. Esto reenvía a http://127.0.0.1:8000/admin/login/?next=/admin/ y proporciona la opción de inicio de sesión que vemos aquí. No olvide ejecutar python manage.py runserver después de crear el superusuario.

inicio de sesión de administrador de django

Una vez que proporcione las credenciales que necesita, verá que ha iniciado sesión.

superusuario de django conectado

Hacer que las aplicaciones sean visibles en el administrador

Cuando inicie sesión por primera vez en el área de administración de Django, solo verá la capacidad de trabajar con grupos y usuarios. Para decirle a Django que queremos que la aplicación Publicaciones aparezca en el área de administración, podemos registrar nuestro modelo en el archivo admin.py de la aplicación. Así es como se hace.

El código resaltado arriba es lo que necesitamos agregar manualmente a admin.py. La primera línea resaltada importa el modelo de publicación para que podamos usarlo. Luego, en la segunda línea resaltada, todo lo que tenemos que hacer es registrar este modelo para que aparezca en la interfaz de administración. Efectivamente, podemos visitar la interfaz de administración nuevamente y ahora tenemos la capacidad de interactuar con el modelo de publicación.

registrar la aplicación modelo para el administrador Django

También habíamos configurado el __str__método en el modelo Post. Este método cambia la representación de cadena de un objeto de publicación para usar el título de la publicación, en lugar del valor predeterminado no descriptivo de algo como Objeto . Es por eso que ahora vemos el título de cada publicación en la interfaz de administración.

__str__ en el administrador Django

Ahora es fácil interactuar con el modelo de publicación utilizando la interfaz de administración en Django.

post modelo django

Solo para sonrisas y práctica, podemos volver atrás y probar consultando la base de datos usando el ORM de Django una vez más.

djangoblog $ python manage.py shell
Python 3.8.0 (etiquetas / v3.8.0: fa919fd, 14 de octubre de 2019, 19:21:23) [MSC v.1916 de 32 bits (Intel)] en win32
Escriba "ayuda", "derechos de autor", "créditos" o "licencia" para obtener más información.
(Consola interactiva)
>>> de posts.models import Post
>>> post1 = Post.objects.all () [0]
>>> post1.title
'¡Un nuevo título!'
>>> post1.slug
'un-nuevo-título'
>>> post1.body
'Esta es la primera publicación en el sistema de blogs de Django. Podríamos haber agregado los campos slug y body usando el shell interactivo, pero este es un ejemplo de cómo interactuar con su modelo usando la interfaz de administración de Django. '
>>> post2 = Post.objects.all () [1]
>>> post2.title
¡Segundo puesto!
>>> post2.slug
'segundo puesto'
>>> post2.body
Esta es la segunda publicación del sistema de blogs en Django. Fue creado usando el modelo Post. Hay todo tipo de cosas que podríamos agregar a esta publicación, pero, por desgracia, aquí está.

Obtener todos los modelos y enviar a la plantilla

En este momento, si visitamos la URL base de la aplicación de publicaciones en http: // localhost: 8000 / posts /, todavía estamos viendo el marcador de posición vacío Html. Esto es bueno, tenemos el enrutamiento de URL configurado correctamente y nuestra vista está representando correctamente una plantilla para mostrar. Sin embargo, se trata de datos estáticos. Ahora tenemos algunos datos dinámicos en la base de datos gracias a nuestro modelo Post. Así que agreguemos la capacidad de buscar todos los registros usando Django ORM, y luego pasemos esas publicaciones a la plantilla para su visualización. Para comenzar este proceso, necesitamos editar el archivo views.py en la aplicación de publicaciones.

posts / views.py

Hay tres líneas de código resaltadas arriba, expliquemos qué hace cada línea una a la vez.

  • La primera línea de código resaltada importa el modelo Post en este archivo para que podamos hacer uso de él.
  • La segunda línea de código resaltada usa el ORM de Django para buscar todos los registros de publicaciones en la base de datos y al mismo tiempo ordenarlos por fecha. Esto asegura que las publicaciones estén en orden cuando las mostramos.
  • La tercera línea de código resaltada está ahí para enfatizar cómo pasamos datos de una vista a una plantilla en Django. El diccionario que incluimos como argumento para la función render () es cómo pasamos los datos de la vista a la plantilla.

Aprovechando las etiquetas de plantilla en Django

Ahora que estamos pasando algunos datos dinámicos a nuestro archivo de plantilla de Django, podemos hacer uso de etiquetas de plantilla en Django para representar estos datos dinámicos en el archivo de plantilla. Recuerde que hay dos tipos de etiquetas de plantilla en Django. Tenemos las {% %}etiquetas para nuestras estructuras de control y las {{ }}etiquetas para generar datos en la plantilla.

posts / templates / posts / post_list.html

Ahora vemos nuestras publicaciones al visitar http: // localhost: 8000 / posts / URL en lugar de la página estática.

página de índice para la aplicación de publicaciones

Agregar un método de modelo personalizado

Podemos agregar métodos a la clase Model para proporcionar una funcionalidad específica. Un ejemplo podría ser agregar una función snippet () que muestre solo los primeros 70 caracteres del texto del cuerpo. Luego, en un momento posterior, podemos agregar una página de detalles a la que se puede vincular cada publicación para ver el texto completo.

posts / models.py
Podemos modificar el modelo de Post así.

posts / templates / posts / post_list.html
Luego, en la plantilla, podemos generar el título, el fragmento y el slug.

El resultado es un cuerpo de texto abreviado que solo muestra los primeros 70 caracteres. ¡Muy genial!

método de modelo personalizado de django


Resumen de modelos en Django

Un modelo en Django es una única fuente de información sobre los datos de su aplicación. Contiene todos los campos esenciales y comportamientos asociados de los datos que está almacenando. En general, cada modelo se asigna a una sola tabla de base de datos. Cada modelo es una clase de Python que subclasifica django.db.models.Model. Cada atributo del modelo representa un campo de base de datos. Una vez que haya configurado sus modelos correctamente, Django le ofrece una API de acceso a la base de datos generada automáticamente utilizando la tecnología Object Relational Mapper.


Publicar un comentario

0 Comentarios