Fundamentos de Django

1

¿Qué es Django?

2

¿Cómo instalar Django?

3

Entendiendo la arquitectura de Django

4

Qué es el patrón MVT (Model, View y Template)

La M en el Patrón: Modelo

5

Introducción a Modelos y Bases de Datos

Manejo Avanzado de Modelos y Bases de Datos

6

Gestión de Modelos y Bases de Datos en Django con SQLite

7

Inserción de Datos con Django

8

Actualización y Eliminación de Datos en Django

Relaciones y Asociaciones entre Modelos

9

Creación y Gestión de Relaciones entre Modelos en Django

10

Relaciones Muchos a Muchos (N:N) en Django

11

Relaciones Uno a Uno (1:1) en Django

12

Queries y Filtros en Django: Optimización y Estrategias Avanzadas

Configuración de URLs y Vistas Avanzadas

13

Gestión de URLs en Django: Configuración, Rutas y Mejores Prácticas

14

Vistas Basadas en Clases en Django

La T en el Patrón: Plantillas o Templates

15

Personalización de Interfaz con Plantillas en Django

Desarrollo de Aplicaciones en Django

16

Configuración del Proyectos en Django

17

Creación del Modelo para la Aplicación 'Products' en Django

18

Cómo Crear Migraciones de Datos en Django

19

Creación de la Aplicación 'Products' con Formularios en Django

20

Integracion de TailwindCSS en Django

21

Django Admin

22

Manejo de Sesiones en Django

23

Manejo de Órdenes en CoffeShop

24

Manejo de Pedidos en CoffeShop

25

Mixings en vistas basadas en clases

26

Agregar productos a la orden

Django Rest Framework

27

Django REST Framework

Despliegue de aplicaciones Django

28

Configurar PostgreSQL en AWS con Django

29

Variables de entorno en Django

30

¿Cómo usar Unit Testing en Django?

31

Debugging en Django

32

Desplegar aplicaciones de Django en AWS

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Convierte tus certificados en títulos universitarios en USA

Antes: $249

Currency
$209

Paga en 4 cuotas sin intereses

Paga en 4 cuotas sin intereses
Suscríbete

Termina en:

19 Días
8 Hrs
19 Min
25 Seg
Curso de Django

Curso de Django

Luis Martínez

Luis Martínez

Qué es el patrón MVT (Model, View y Template)

4/32
Recursos

¿Cómo se definen los modelos en Django?

Los modelos en Django se utilizan para guardar datos. Crearemos una clase llamada Carro, que hereda de models.Model. Esta clase tendrá un campo title de tipo models.TextField, con un max_length definido para limitar la cantidad de texto que puede aceptar.

from django.db import models

class Carro(models.Model):
    title = models.TextField(max_length=255)

¿Cómo se definen las vistas en Django?

Las vistas en Django se encargan de buscar datos y devolverlos al template. Una vista se define como un método que recibe un request y retorna una response. Usaremos render para pasar el request y el template a la vista.

from django.shortcuts import render

def myView(request):
    car_list = [{'title': 'BMW'}, {'title': 'Mazda'}]
    context = {'car_list': car_list}
    return render(request, 'myFirstApp/carlist.html', context)

¿Cómo se crean y utilizan los templates en Django?

Los templates son archivos HTML que reciben datos de las vistas. Para que Django los reconozca, creamos una carpeta llamada templates dentro de nuestra aplicación y luego otra con el nombre de la aplicación. Dentro, creamos el archivo carlist.html.


<html>
<head>
    <title>Car Listtitle>
head>
<body>
    <h1>Lista de Carrosh1>
    <ul>
    {% for car in car_list %}
        <li>{{ car.title }}li>
    {% endfor %}
    ul>
body>
html>

¿Cómo se registran las aplicaciones en Django?

Para que Django reconozca nuestra nueva aplicación, debemos agregarla a la lista INSTALLED_APPS en el archivo settings.py.

INSTALLED_APPS = [
    ...
    'myFirstApp',
]

¿Cómo se configuran las URLs en Django?

Creamos un archivo urls.py en nuestra aplicación y definimos la ruta para nuestra vista. Luego, incluimos esta configuración en el archivo urls.py principal del proyecto.

from django.urls import path
from .views import myView

urlpatterns = [
    path('carlist/', myView, name='carlist'),
]
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('myFirstApp/', include('myFirstApp.urls')),
]

¿Cómo se conectan las vistas y templates en Django?

Pasamos los datos desde la vista al template usando un contexto. En el template, usamos etiquetas Django para iterar sobre los datos y mostrarlos.

    {% for car in car_list %}
  • {{ car.title }}
  • {% endfor %}

Aportes 21

Preguntas 2

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

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.
Super bien explicado
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

Hola Platzi Que extensiones recomiendas instalar para aprovechar al máximo Django??
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
¿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 :(.
Varios cursos de Django y siempre van a lo mismo, por favor traten de profundizar más.
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.
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
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
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.
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.
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é.