Fundamentos de Django

1

Entornos Virtuales y Configuración de Django en Python

2

Instalación y configuración de Django con pip y django-admin

3

Arquitectura MBT en Frameworks Web: Model, View y Template

4

Modelo, Vista y Plantilla en Django: Creación y Conexión Básica

La M en el Patrón: Modelo

5

Modelos y Migraciones en Django ORM

Manejo Avanzado de Modelos y Bases de Datos

6

Migraciones en Django: Creación de Tablas en la Base de Datos

7

Creación y Gestión de Campos en Tablas de Django ORM

8

Modificación y Eliminación de Datos en Base de Datos con Python

Relaciones y Asociaciones entre Modelos

9

Relaciones de Tablas Uno a Muchos con Django

10

Relaciones de Muchos a Muchos en Modelos de Base de Datos

11

Relaciones 1 a 1 en Django: Creación y Gestión de Perfiles de Autor

12

Uso de Managers en Django para Consultas de Base de Datos

Configuración de URLs y Vistas Avanzadas

13

URLs Dinámicas en Django: Creación y Gestión Eficiente

14

Vistas en Django: Funciones vs Clases y su Implementación

La T en el Patrón: Plantillas o Templates

15

Templates y Tags en Django: Creación de Aplicaciones Web

Desarrollo de Aplicaciones en Django

16

Configuración de Proyecto Django: Entorno, Extensiones y Repositorio

17

Creación de Modelos de Producto en Django para Cafeterías

18

Instalación y uso de Pillow para campos de imagen en Django

19

Creación y Gestión de Formularios con Django

20

Creación de Plantillas con Django y Tailwind CSS

21

Administración de Modelos en Django: Configuración y Uso de Django Admin

22

Creación de Login y Registro de Usuarios en Django

23

Creación de una Aplicación de Pedidos en Django

24

Detalle de Orden y Personalización de Vistas en Django

25

Corrección de errores en MyOrderView para autenticación de usuario

26

Crear y configurar vistas para agregar productos a una orden en Django

Django Rest Framework

27

Creación de APIs con Django REST Framework

Despliegue de aplicaciones Django

28

Configuración de Bases de Datos con Django y AWS RDS

29

Uso de Django Environ para Manejar Credenciales Seguras

30

Testing de Aplicaciones Django con Unit Tests

31

Despliegue de Proyectos Django en AWS: Configuración y Mejora de Código

32

Despliegue de Aplicaciones con AWS Elastic Beanstalk y Django

No tienes acceso a esta clase

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

Curso de Django

Curso de Django

Luis Martínez

Luis Martínez

Relaciones de Tablas Uno a Muchos con Django

9/32
Recursos

Aprender a relacionar tablas es fundamental para manejar datos interconectados en Django

¿Cómo crear la clase Publisher?

Para iniciar, creamos la clase Publisher que hereda de models.Model. Incluimos atributos como name y address utilizando models.TextField con un max_length de 200, un valor que puedes ajustar según tus necesidades de datos.

class Publisher(models.Model):
    name = models.TextField(max_length=200)
    address = models.TextField(max_length=200)

    def __str__(self):
        return self.name

¿Cómo definir la clase Book?

La clase Book también hereda de models.Model y contiene atributos como title, publication_date y publisher. Utilizamos models.DateField para manejar fechas y establecemos una relación con Publisher usando models.ForeignKey.

class Book(models.Model):
    title = models.TextField(max_length=200)
    publication_date = models.DateField()
    publisher = models.ForeignKey(Publisher, on_delete=models.CASCADE)

    def __str__(self):
        return self.title

¿Cómo relacionar Book con Publisher usando ForeignKey?

La relación se establece con models.ForeignKey, donde especificamos el modelo relacionado (Publisher) y el comportamiento al eliminar (on_delete=models.CASCADE). Esto asegura que si un editor se elimina, también se eliminarán sus libros.

¿Cómo aplicar migraciones?

Para aplicar estos cambios a la base de datos, creamos y aplicamos las migraciones con los comandos:

python manage.py makemigrations
python manage.py migrate

¿Cómo usar la shell interactiva?

Para facilitar la interacción con la base de datos, instalamos ipython con:

pip install ipython

Esto mejora la experiencia en la shell permitiendo autocompletar y otras funcionalidades útiles.

¿Cómo crear y guardar registros en la shell?

Dentro de la shell, primero creamos un Publisher y luego un Book relacionado.

from myapp.models import Publisher, Book

publisher = Publisher(name="Editorial Example", address="123 Main St")
publisher.save()

book = Book(title="Two Scoops of Django", publication_date="2024-07-17", publisher=publisher)
book.save()

Aportes 12

Preguntas 3

Ordenar por:

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

Excelente las explicaciones de cada clase, en esta me hubiese gustado que el ejemplo se basara en el modelo Car creado previamente, para continuar con el contexto de los "carros", es decir, para llevar una secuencia lógica del dominio del problema, por que en esta clase hablan de Libros y Editores, que creo no tiene mucho que ver con los Carros.
Me encanto el hack que mostraste para hacer interactiva la consola, muy buena esa funcionalidad
Aquí comparto la pagina <https://docs.djangoproject.com/en/5.0/ref/models/fields/#field-types>
De la documentación (https://docs.djangoproject.com/en/5.0/ref/models/fields/#django.db.models.TextField) es importante notar que `max_length` en un `TextField` solamente restringe la longitud del texto en un widget generado de este modelo; esta restricción no se aplica en el modelo en sí ni en la base de datos. Para hacer esto último se debe usar `CharField` en su lugar.
tipos de datos mas comunes de Django <https://www.freecodecamp.org/news/common-django-model-fields-and-their-use-cases/>
seria bueno tambien que eplicara en el ejemplo, para que poner el :*verbose\_name*= siento que es de utilidad
En caso de que existan varios registros en una tabla y el que se quiera borrar sea uno especifico, el comando a utilizar es: `DELETE FROM my_first_app_carro WHERE id = 2`
Okay, this new object that you've just instantiated is accessible from the **shell** \#### We can modify its fields values right there: *remember, the **save()** method needs to be applied to created objects* ```js car1.title= 'Audi' car1.save() ```car1.title= 'Audi' car1.save() . Then enter the **python manage.py dbshell** once again (new terminal tab) to query the tables and verify changes ```js sqlite> select * from my_first_app_car; ``` *don't forget the `;`* ```txt 1|Audi|2024|yellow ``` \#### We can as well delete it, again from the **python manage.py shell** ```js >>> car1.title 'Audi' >>> car1.delete() (1, {'my_first_app.Car': 1}) ``` **delete()** will always return a **tuple** with 2 fields (n°ofObjectsAffected, {the type of object}) Now coming back to the dbshell and repeating the past query we can verify the deletion
Django también tiene una interfaz gráfica por defecto en el admin para crear, actualizar y eliminar registros en las db's, les recomiendo que lo busquen y jueguen un poco con él, les puede ahorrar mucho tiempo si lo que están desarrollando no tiene una ui aún.
Brillante clase combinando SQL con Python. Muy buenos los hacks.
![]()**Relación uno a muchos**![]() Tenemos 2 clases, una depende de la otra. Publisher es un campo de Book así que ahí existe la relación ![](https://static.platzi.com/media/user_upload/image-b37b0bc2-8059-4036-9d29-6b0dfeef04e4.jpg) Ejemplo desde la shell para un registro de ejemplo: ![]()![](https://static.platzi.com/media/user_upload/image-42b0917b-fba4-43bb-ae9d-83e5ed1c8d87.jpg)
En Django, las relaciones entre modelos permiten que los datos en diferentes tablas de la base de datos se conecten entre sí. Django ofrece tres tipos principales de relaciones: \*\*One-to-One (uno a uno)\*\*, \*\*One-to-Many (uno a muchos)\*\*, y \*\*Many-to-Many (muchos a muchos)\*\*. A continuación, te explico cómo crear y gestionar estas relaciones en Django. \### 1. \*\*One-to-One Relationship (Uno a Uno)\*\* Una relación uno a uno significa que cada fila en la primera tabla está relacionada con una y solo una fila en la segunda tabla, y viceversa. En Django, se usa `OneToOneField` para definir esta relación. \#### Ejemplo: Usuario y Perfil Supongamos que tienes un modelo `User` y un modelo `Profile`, donde cada usuario tiene exactamente un perfil y cada perfil está asociado a un único usuario. ```python from django.db import models from django.contrib.auth.models import User class Profile(models.Model): user = models.OneToOneField(User, on\_delete=models.CASCADE) bio = models.TextField() website = models.URLField() def \_\_str\_\_(self): return self.user.username ``` \- `on\_delete=models.CASCADE`: Si se elimina el usuario, el perfil también se eliminará automáticamente. \#### Acceso a Datos Relacionados: \- Acceder al perfil desde el usuario: ```python user = User.objects.get(username='john') profile = user.profile # Accede al perfil relacionado ``` \- Acceder al usuario desde el perfil: ```python profile = Profile.objects.get(user=user) user = profile.user # Accede al usuario relacionado ``` \### 2. \*\*One-to-Many Relationship (Uno a Muchos)\*\* Una relación uno a muchos significa que una fila en la primera tabla puede estar relacionada con muchas filas en la segunda tabla, pero cada fila en la segunda tabla está relacionada con una única fila en la primera tabla. En Django, se usa `ForeignKey` para definir esta relación. \#### Ejemplo: Autor y Libro Supongamos que tienes un modelo `Author` y un modelo `Book`, donde un autor puede escribir muchos libros, pero cada libro tiene un solo autor. ```python class Author(models.Model): name = models.CharField(max\_length=100) def \_\_str\_\_(self): return self.name class Book(models.Model): title = models.CharField(max\_length=200) author = models.ForeignKey(Author, on\_delete=models.CASCADE) def \_\_str\_\_(self): return self.title ``` \- `on\_delete=models.CASCADE`: Si se elimina un autor, todos sus libros asociados también se eliminarán. \#### Acceso a Datos Relacionados: \- Acceder a los libros de un autor: ```python author = Author.objects.get(name='J.K. Rowling') books = author.book\_set.all() # Accede a todos los libros relacionados con el autor ``` \- Acceder al autor de un libro: ```python book = Book.objects.get(title='Harry Potter') author = book.author # Accede al autor relacionado ``` \### 3. \*\*Many-to-Many Relationship (Muchos a Muchos)\*\* Una relación muchos a muchos significa que una fila en la primera tabla puede estar relacionada con muchas filas en la segunda tabla y viceversa. En Django, se usa `ManyToManyField` para definir esta relación. \#### Ejemplo: Estudiantes y Cursos Supongamos que tienes un modelo `Student` y un modelo `Course`, donde un estudiante puede inscribirse en muchos cursos, y un curso puede tener muchos estudiantes. ```python class Student(models.Model): name = models.CharField(max\_length=100) def \_\_str\_\_(self): return self.name class Course(models.Model): title = models.CharField(max\_length=200) students = models.ManyToManyField(Student) def \_\_str\_\_(self): return self.title ``` \#### Acceso a Datos Relacionados: \- Acceder a los cursos de un estudiante: ```python student = Student.objects.get(name='Alice') courses = student.course\_set.all() # Accede a todos los cursos en los que está inscrito el estudiante ``` \- Acceder a los estudiantes de un curso: ```python course = Course.objects.get(title='Math 101') students = course.students.all() # Accede a todos los estudiantes inscritos en el curso ``` \### 4. \*\*Personalización y Uso de Relaciones\*\* \#### Relación Inversa Django automáticamente crea relaciones inversas que te permiten acceder al modelo relacionado desde el otro lado de la relación. Puedes personalizar estas relaciones inversas usando el parámetro `related\_name`: ```python class Book(models.Model): title = models.CharField(max\_length=200) author = models.ForeignKey(Author, on\_delete=models.CASCADE, related\_name='books') \# Ahora puedes acceder a los libros de un autor usando author.books en lugar de author.book\_set. ``` \#### Filtrado y Consultas Avanzadas Puedes realizar consultas avanzadas en relaciones usando filtros: ```python \# Obtener todos los libros escritos por un autor específico books\_by\_author = Book.objects.filter(author\_\_name='J.K. Rowling') \# Obtener todos los estudiantes inscritos en un curso específico students\_in\_course = Student.objects.filter(course\_\_title='Math 101') ``` \### 5. \*\*Migraciones\*\* Cada vez que creas o modificas relaciones entre modelos, debes generar y aplicar migraciones para que los cambios se reflejen en la base de datos: ```bash python manage.py makemigrations python manage.py migrate ``` \### Conclusión Django facilita la creación y gestión de relaciones entre modelos, permitiéndote construir estructuras de datos complejas con facilidad. Dependiendo del tipo de relación que necesites (uno a uno, uno a muchos, o muchos a muchos), Django te ofrece herramientas flexibles para definir y manipular estas relaciones.