Fundamentos de Django
¿Qué es Django?
¿Cómo instalar Django?
Entendiendo la arquitectura de Django
Qué es el patrón MVT (Model, View y Template)
La M en el Patrón: Modelo
Introducción a Modelos y Bases de Datos
Manejo Avanzado de Modelos y Bases de Datos
Gestión de Modelos y Bases de Datos en Django con SQLite
Inserción de Datos con Django
Actualización y Eliminación de Datos en Django
Relaciones y Asociaciones entre Modelos
Creación y Gestión de Relaciones entre Modelos en Django
Relaciones Muchos a Muchos (N:N) en Django
Relaciones Uno a Uno (1:1) en Django
Queries y Filtros en Django: Optimización y Estrategias Avanzadas
Configuración de URLs y Vistas Avanzadas
Gestión de URLs en Django: Configuración, Rutas y Mejores Prácticas
Vistas Basadas en Clases en Django
La T en el Patrón: Plantillas o Templates
Personalización de Interfaz con Plantillas en Django
Desarrollo de Aplicaciones en Django
Configuración del Proyectos en Django
Creación del Modelo para la Aplicación 'Products' en Django
Cómo Crear Migraciones de Datos en Django
Creación de la Aplicación 'Products' con Formularios en Django
Integracion de TailwindCSS en Django
Django Admin
Manejo de Sesiones en Django
Manejo de Órdenes en CoffeShop
Manejo de Pedidos en CoffeShop
Mixings en vistas basadas en clases
Agregar productos a la orden
Django Rest Framework
Django REST Framework
Despliegue de aplicaciones Django
Configurar PostgreSQL en AWS con Django
Variables de entorno en Django
¿Cómo usar Unit Testing en Django?
Debugging en Django
Desplegar aplicaciones de Django en AWS
You don't have access to this class
Keep learning! Join and start boosting your career
If you already have an account,
Resources
How are models defined in Django?
Models in Django are used to store data. We will create a class called Cart, which inherits from models.Model. This class will have a title field of type models.TextField, with a max_length defined to limit the amount of text it can accept.
from django.db import modelsclass Cart(models.Model):title = models.TextField(max_length=255)How are views defined in Django?
Views in Django are responsible for fetching data and returning it to the template. A view is defined as a method that receives a request and returns a response. We will use render to pass the request and the template to the view.
from django.shortcuts import renderdef myView(request):car_list = [{'title': 'BMW'}, {'title': 'Mazda'}] context = {'car_list': car_list} return render(request, 'myFirstApp/carlist.html', context)How are templates created and used in Django?
Templates are HTML files that receive data from views. For Django to recognize them, we create a folder called templates inside our application and then another one with the name of the application. Inside, we create the carlist.html file.
<html><head> <title>CarList</title></head></head><body><body> <h1>CarList</h1> <ul>{% for car in car_list %} <li>{{ car.title }}</li>{% endfor %} </ul></body></html> </html>How to register applications in Django?
In order for Django to recognize our new application, we need to add it to the INSTALLED_APPS list in the settings.py file.
INSTALLED_APPS = [ ... ' myFirstApp', ]How to configure URLs in Django?
We create an urls.py file in our application and define the path for our view. Then, we include this configuration in the main urls.py file of the project.
from django.urls import pathfrom.views import myView urlpatterns = [ path('carlist/', myView, name='carlist'), ]from django.contrib import adminfrom django.urls import path, include urlpatterns = [ path('admin/', admin.site.urls), path('myFirstApp/', include('myFirstApp.urls')), ] ]How are views and templates connected in Django?
We pass the data from the view to the template using a context. In the template, we use Django tags to iterate over the data and display it.
{% for car in car_list %} - {{ car.title }}
{% endfor %}
Contributions 29
Questions 3
Sort by:
Cómo critica constructiva, no me gusta que enseñan algo **sin tener en cuenta las buenas prácticas**, esto pasa en varios cursos, y eso es un doliente para aquellas personas que **están aprendiendo** desde 0 (y para las personas que tenemos experiencia y queremos aprender algo nuevo también). Cosas como por ejemplo **encapsular los modelos** en una carpeta y crear un archivo para cada uno, son cosas que deberían tocar en esta clase. Y no dejarlo pasar para más adelante (si es que lo menciona). O como manejar los rutas independientemente por cada app para luego llamarlas en las rutas del proyecto 🫤
Mi aporte. se que se estan preguntando por que el profesor creo una carpeta template y dentro creo otra con el mismo nombre de la app my\_first\_project para guardar los archivos html o plantillas.
En Django, la estructura del proyecto y la ubicación de los archivos de plantilla (`templates`) siguen ciertas convenciones para asegurar que el framework pueda encontrar y renderizar correctamente los archivos HTML
Cada aplicación en Django puede tener sus propias plantillas y, para mantener el código organizado y evitar conflictos de nombres, se recomienda seguir esta estructura:
myproject/
**myapp/**
templates/
myapp/
template1.html
template2.html
views.py
models.py
...
Espero sea de ayuda para los que estan empezando.
buenas, tengo una sugerencia sobre esta parte, podrian profundizar un poco mas en algunos conceptos claves que es necesario conocer, como por ejemplo, que la acción de poder tener condicionales y bucles dentro de nuestro html es proporcionado por el motor de plantillas Jinja.
Hola Platzi
Que extensiones recomiendas instalar para aprovechar al máximo Django??
Super bien explicado
Tengo una pregunta, ¿cuales son los casos de uso donde brilla Django respecto a otros frameworks?. Por ejemplo todo el tema del templating es muy fácil de hacer también con fastAPI y no tiene esta curva de aprendizaje un poco compleja respecto a la estructura de archivos y carpetas, tu vas armando tu propia estructura con las necesidades que tu proyecto vaya teniendo.
Varios cursos de Django y siempre van a lo mismo, por favor traten de profundizar más.
Ejecutar comando
1. ```js
pyton manage.py startapp my_first_app
```
2. en el archivo models.py
```js
class Carro(models.Model):
title = models.TextField(max_length=255)
```
1. en el archivo views.py
```js
def myView(request):
car_list = [{'title': 'BMW'}, {'title': 'Mazda'}]
context = {'car_list': car_list}
return render(request, 'my_first_app/car_list.html', context)
```
1. en el archivo settings.py
en INSTALLED\_APPS agregar
'my\_first\_app',
1. Crear carpeta dentro de my\_first\_app llamada template/ my\_first\_app' y crear archivo car\_list.html
```js
<head>
<title>Car List</title>
<head>
<body>
Lista de Carros
{% for car in car_list %}
- {{ car.title }}
-
{% endfor %}
</body>
</html>
```
1. Registrar en el archive urls.py
```js
from my_first_app.views import myView
```
```js
path('car-list',myView),
```7. ejecutar comando
```js
python manage.py runserv
``` python manage.py runserv
-
</body>
</html>
```
1. Registrar en el archive urls.py
```js
from my_first_app.views import myView
```
```js
path('car-list',myView),
```7. ejecutar comando
```js
python manage.py runserv
``` python manage.py runserv
Los modelos son una abstracción de lo que será la tabla en una base de datos.
No es necesario saber bases de datos, pero es un "nice to have"
el modelo recibiría las peticiones y las entrega al template.
Entre los "campos" del modelo hay características propias de las bases de datos. (el tamaño del contenido, el tipo, etc)
Por otro lado a "my\_first\_app" usualmente le pongo de nombre "core" pues es el eje de lo que hago y a esa misma "altura" de carpetas creo una capeta de **tempaltes** y ahí dentro van ordenados los templates.
En el settings.py agrego:
`TEMPLATES = [ `
`{ `
`'BACKEND': `
`... `
`'DIRS': [os.path.join(BASE_DIR, 'templates')]`
`...`
Es necesario importar os antes de agregar esta línea
Hola alguno sabe cual es la extensión de for para que se auto complete? y quede así:
{% for in %} {& end %}
El patrón MVT (Model-View-Template) es un patrón de arquitectura utilizado en el desarrollo de aplicaciones web, particularmente en el marco de trabajo Django para Python. Es similar al patrón MVC (Model-View-Controller) pero tiene algunas diferencias clave. Aquí se describe cada componente:
1\. \*\*Model (Modelo):\*\*
\- Es la capa que maneja la lógica de negocio y la interacción con la base de datos. Define la estructura de los datos, los comportamientos y las relaciones entre los datos.
\- En Django, los modelos se definen como clases de Python que heredan de `django.db.models.Model`. Cada clase representa una tabla en la base de datos, y los atributos de la clase representan las columnas de esa tabla.
2\. \*\*View (Vista):\*\*
\- En MVT, la vista es responsable de la lógica de la aplicación y de procesar las solicitudes del usuario. Interactúa con el modelo para obtener los datos necesarios y selecciona la plantilla adecuada para renderizar la respuesta.
\- En Django, una vista se define como una función o clase que recibe una solicitud web y devuelve una respuesta web. Las vistas pueden manejar diferentes tipos de solicitudes (GET, POST, etc.) y realizar acciones como consultar la base de datos, procesar formularios, y mucho más.
3\. \*\*Template (Plantilla):\*\*
\- Las plantillas son la capa de presentación que se utiliza para renderizar la interfaz de usuario. Es donde se define la estructura HTML, junto con cualquier lógica de presentación, para mostrar los datos al usuario.
\- En Django, las plantillas son archivos HTML que pueden contener un lenguaje de plantillas específico (Django Template Language) para insertar datos dinámicos, realizar iteraciones, y condicionales dentro del HTML.
\### Diferencias con MVC:
\- En MVC, el controlador es el que maneja la lógica de la aplicación, mientras que en MVT, esta responsabilidad recae sobre la vista.
\- En MVC, la vista solo se encarga de la presentación, mientras que en MVT, la plantilla (Template) cumple este rol.
\### Ejemplo de Flujo en Django:
1\. \*\*Solicitud\*\*: El usuario hace una solicitud a la aplicación web.
2\. \*\*Vista\*\*: La vista correspondiente maneja la solicitud, interactúa con el modelo para obtener los datos necesarios.
3\. \*\*Modelo\*\*: Si es necesario, se consulta el modelo para obtener o modificar datos.
4\. \*\*Plantilla\*\*: La vista selecciona una plantilla y pasa los datos obtenidos del modelo a la plantilla.
5\. \*\*Respuesta\*\*: La plantilla genera la respuesta en HTML que se envía de vuelta al usuario.
Estructura básica de un proyecto django
`mi_proyecto/`
`├── manage.py # Script de gestión para interactuar con el proyecto (runserver, migrations, etc.)`
`├── mi_proyecto/ # Carpeta del proyecto principal`
`│ ├── __init__.py # Indica que esta carpeta es un paquete Python`
`│ ├── asgi.py # Configuración de ASGI para el proyecto`
`│ ├── settings.py # Configuración del proyecto (bases de datos, apps instaladas, etc.)`
`│ ├── urls.py # Rutas principales del proyecto`
`│ ├── wsgi.py # Configuración de WSGI para el proyecto`
`├── app1/ # Una aplicación dentro del proyecto`
`│ ├── migrations/ # Carpeta para archivos de migración de bases de datos`
`│ │ └── __init__.py # Indica que esta carpeta es un paquete Python`
`│ ├── __init__.py # Indica que esta carpeta es un paquete Python`
`│ ├── admin.py # Registro de modelos en el administrador`
`│ ├── apps.py # Configuración de la aplicación`
`│ ├── models.py # Definición de modelos (tablas de la base de datos)`
`│ ├── tests.py # Pruebas unitarias para la aplicación`
`│ ├── views.py # Lógica de las vistas de la aplicación`
`│ ├── urls.py # (opcional) Rutas específicas de la aplicación`
`│ ├── templates/ # Plantillas HTML específicas de la aplicación`
`│ └── static/ # Archivos estáticos (CSS, JS, imágenes)`
¿Cómo generaste el for de manera automática dentro del HTML?
Y a lo intente y no me sale, quisiera saber si es una extensión o algo estoy haciendo mal :(.
Es fundamental explicar por qué existe una carpeta adicional dentro del proyecto con el mismo nombre. Aunque en un primer vistazo pueda parecer innecesaria, esta estructura ofrece **grandes beneficios en proyectos grandes** y facilita el trabajo en equipo, especialmente cuando varios desarrolladores están involucrados.
A medida que un proyecto crece, comenzamos a agregar **archivos adicionales**: documentación, manuales técnicos y de usuario, archivos de configuración, scripts y otros recursos. Tener una carpeta adicional que contiene únicamente el **código fuente del proyecto** ayuda a mantener una clara separación entre el código y estos archivos externos.
Para los principiantes, esta separación puede no parecer tan relevante. Sin embargo, cuando trabajas en proyectos de mayor envergadura, te das cuenta de la importancia de una estructura ordenada. Con el tiempo, agradecerás tener una organización que permita un acceso rápido al código sin interferencias, y a la vez, facilita que otros archivos del proyecto estén organizados y accesibles para todo el equip
Dejo una lista JSON para que la usen como lista de autos:
```js
car_list = [
{"title": "BMW"},
{"title": "Mazda"},
{"title": "Toyota"},
{"title": "Honda"},
{"title": "Ford"},
{"title": "Mercedes-Benz"},
{"title": "Audi"},
{"title": "Volkswagen"},
{"title": "Nissan"},
{"title": "Chevrolet"}
]
```
Luis, de verdad está una elegancia el curso, con esos efectos en el backgraound, las dinámicas, y mostrarnos los posibles errores que pueden pasar durante el desarrollo y mostrarlos, y como se pueden solucionar.
Sería genial que sigan haciendo cursos de esta manera ya que muchas veces en otros cursos, el error le pasa es a uno solo y no al profesor jaja, y uno es buscando por todo lado como solucionar, y se pierde mucho tiempo cuando estás desde 0.
Muchas gracias por mostrar los errores y el como solucionarlos ayuda un montón. Saludos
Muy buen contenido, aunque debo mencionar que existe un bug al reproducir el video, en cualquier momento pareciera reiniciarse y se congela con la imagen inicial y posteriormente sigue el video con el contenido normal, esto en lapsos de 2 segundos.
Nunca había hecho un MVC tan rapido, por lo general en otros lenguajes de programación esto es un parto. Me encanta la simplicidad de Python.
**Resumen hasta ahora:**
Hola, una pregunta.
En mi VSC cuando escribo for en el html no me carga las llaves de forma automática, y si trato de escribirlas manualmente no se ejecutan.
para los que no entiendes en django models.Model es como se trabajan las tablas es decir la clase Car sera lo que en sql es la tabla car y title = model.TextField() vendira siendo una columna que recibe texto en mi caso lo cambie por models.CharField(max\_length=250) por que textfield no tiene limite maximo definido
Una aplicación en Django es un módulo que organiza una parte específica de tu proyecto web. Utiliza el patrón MVT (Model-View-Template) para estructurar el código. Cada aplicación puede tener sus propios modelos (que representan datos), vistas (que procesan la lógica y gestionan las solicitudes) y templates (que manejan la presentación). La creación de aplicaciones permite una mejor organización del código y la reutilización en diferentes proyectos. En Django, puedes crear una aplicación usando el comando `startapp`. Esto facilita la división de la lógica dentro de tu proyecto.
Es necesario que my\_first\_app este dentro de my\_first\_project? o se puede utilizar otra estructura
Me hubiera gustado que explicaran el contenido de los archivos que están dentro del proyecto para entender mejor todas las variables y poder curiosear más adelante.
Hasta el momento este curso está muy bueno. El profesor explica muy bien, estoy emocionado por crear el proyecto de curso Coffe shop. :)
Hola, tengo una pregunta, me aparece django.db subrayado como si tuviese un problema, ya ajusté la ruta del interpreter pero el error persiste
Muchas veces un proyecto se puede integrar de varias Apps, cuando se presentan esos casos me gusta usar más el método de importación de
" Add an import: from my\_app import views 2. Add a URL to urlpatterns: path('', views.home, name='home')"
Así puedo tener acceso a todas las vistas usando el views.metodoenviews
cuando es una landing page con un solo form me gusto el que aprendi en este curso.
Como observación, en este video no se muestra porque en el template HTML se marca en color amarillo las secuencias de Django.
si tienes dudas en VSC instala la extensión Django Templates y en tu HTML cambias el formato. esquina inferior derecha "muy pequeño" pero lo cambias de HTML a Django Templates
Hola! Estoy confundido con las indicaciones sobre el archivo **urls.py para definir las rutas de las vistas**:
El resumen de la clase habla de crear un archivo con el mismo nombre dentro de la **app**
Sin embargo, en la clase solo utilizamos el que viene preconstruido en el **proyecto** ...
El curso debe ser muy bueno. Pero la verdad nunca me había frustrado tanto en un curso intentando seguir en paralelo las instrucciones y que a mi no den resultado. Me tocó suspender y recurrir a Youtube a tratar de enteder mejor la parte introductoria de los entornos y las instrucciones. Cuando me alinee volveré.
Want to see more contributions, questions and answers from the community?