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.
classPublisher(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.
¿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:
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()
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.
Hola Javier, gracias por tu aporte. claro, usamos diferentes ejemplos para que también empieces a tener la habilidad de context switching, además porque para las relaciones entre objetos es más simple con el caso de uso de Libros.
Creo que me parece interesante como pues se empieza a añadir nuevas clases es un caso "bobo" pero siento que es similar a un caso en la vida real explicado de manera recursiva
Me encanto el hack que mostraste para hacer interactiva la consola, muy buena esa funcionalidad
Todos estos tips son muy útiles a la hora de desarrollar.
Si sabes otros tips como estos por favor compartelos en la sección de aportes
Aquí comparto la pagina
seria mejor crear un directorio models y dentro por cada modelo tener un archivo separado con el nombre de cada uno?
Esto sería bueno si vamos a tener muchos modelos en la misma app, mi recomendación es tratar de mantener las apps con pocos modelos y más bien crear muchas apps para serparar la lógica y poder usar por ejemplo el sistema de permisos de manera más granular.
Dar permisos a ciertas apps y ciertos modelos por ejemplo
si, generalmente en proyectos grandes asi se hace, mas por que los modelos tienen muchos metodos que pueden usarse para hacer acciones antes de guardar, despues de guardar o limpiar datos
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
seria bueno tambien que eplicara en el ejemplo, para que poner el :verbose_name= siento que es de utilidad
En el transcurso del curso vamos explicando, pero te adelanto:
El verbose_name en Django se utiliza para definir un nombre legible y descriptivo para un campo de modelo que se muestra en la interfaz administrativa y en otros lugares donde se presenta el modelo.
📚 Nombre de la clase
Creación y gestión de relaciones entre modelos en Django
🎯 Idea principal
Django permite relacionar modelos entre sí para representar relaciones entre datos dentro de la base de datos. Estas relaciones reflejan cómo diferentes entidades del sistema se conectan entre sí, como usuarios, publicaciones o productos. El ORM de Django permite definir estas relaciones directamente en los modelos y gestionarlas de forma sencilla desde el código.
⚡ Síntesis en 10 segundos
Los Model pueden relacionarse entre sí.
Las relaciones representan conexiones entre datos.
Django permite definir relaciones directamente en los modelos.
El ORM gestiona estas relaciones automáticamente.
Permite estructurar sistemas de datos más complejos.
🔑 Puntos clave
Relaciones entre modelos
Permiten conectar diferentes entidades dentro de una aplicación.
Model como representación de datos
Cada modelo representa una entidad del sistema.
Relaciones en la base de datos
Las relaciones reflejan cómo una entidad depende o se conecta con otra.
Gestión automática con ORM
Django gestiona las relaciones y permite acceder a los datos relacionados fácilmente.
Diseño de estructura de datos
Las relaciones ayudan a organizar la información de forma más lógica y estructurada.
🧠 Conceptos importantes
Entidad
Objeto o concepto del sistema representado por un modelo.
Relación de datos
Conexión entre dos entidades dentro de la base de datos.
Integridad de datos
Garantía de que las relaciones entre datos se mantienen correctamente.
Modelo relacional
Estructura de base de datos basada en tablas relacionadas entre sí.
ORM
Capa que permite trabajar con relaciones de datos usando objetos de Python.
🧩 Modelo mental de la clase
Sistema necesita representar entidades relacionadas
↓
Se crean Model
↓
Se definen relaciones entre esos modelos
↓
La base de datos crea conexiones entre tablas
↓
La aplicación puede consultar datos relacionados fácilmente
Este flujo muestra cómo Django organiza estructuras de datos complejas.
🚀 Acciones inmediatas
Analizar qué entidades existen en una aplicación (usuarios, productos, etc.).
Definir modelos que representen esas entidades.
Establecer relaciones entre los modelos cuando exista dependencia de datos.
Explorar cómo acceder a datos relacionados mediante el ORM.
💼 Aplicación profesional
Las relaciones entre modelos permiten construir sistemas reales como:
redes sociales (usuarios y publicaciones)
ecommerce (productos y categorías)
plataformas educativas (cursos y estudiantes)
sistemas empresariales con múltiples entidades relacionadas
Estas relaciones son esenciales para estructurar correctamente la información del sistema.
🔥 Errores comunes
Diseñar modelos sin pensar en cómo se relacionan los datos.
Crear relaciones innecesarias que complican la base de datos.
No considerar cómo las relaciones afectan consultas y rendimiento.
Confundir relaciones de datos con lógica de negocio.
📝 Reflexión estratégica
El diseño de relaciones entre modelos es uno de los aspectos más importantes del desarrollo backend. La forma en que se conectan los datos define la estructura del sistema y afecta directamente su escalabilidad y mantenimiento.
Comprender cómo modelar relaciones correctamente permite construir aplicaciones que representan de forma clara y eficiente el mundo real dentro del sistema.
Si creeé mis clases en models.py, hago el makemigrations, despues el migrate, y en la shell me doy cuenta que escribí mal los nombres de algunos atributos de mi clase en models, debo corregir y volver a hacer el makemigrations y posterior el migrate?
por ejemplo, puse titlle, pero continué en la shell e igual inserte el dato con titlle. ahora que me arrepiento, si cambio esos atributos o campos en models, entonces se pierden los insertados en la bd?
Intente hacer interactiva mi consola con ipython y comenzo a congelarse mucho imposible trabajar aparte no autocompleta
Puede que tu equipo no tenga muy buena memoria o algun otro recurso y por eso se bloquee.
SI crees que si tienes buenos recursos podrias probar actualizando tu SO
Que pasa cuando tengo una aplicacion de verdad? Con al menos 50 modelos distintos? Como se estructura el proyecto?
Si en la tabla publisher ya he guardado varios datos como determino a que dato debe hacer referencia ??
La relación entre un libro y un publisher se establece mediante una foreign key en el modelo del libro. Utilizando el ID único del publisher al crear un libro, puedes referenciar a ese dato específico de la tabla publisher.
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
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;
Now coming back to the dbshell and repeating the past query we can verify the deletion
ufff migración de notas de obsidian male sal
Me encantaría poder editar el comentario! 🙃
Así era la vida en twitter cuando no se podía pagar :D
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
Ejemplo desde la shell para un registro de ejemplo:
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.
from django.db import models
from django.contrib.auth.models import User
classProfile(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.
classAuthor(models.Model):  name = models.CharField(max\_length=100)  def \_\_str\_\_(self):  return self.nameclassBook(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.
classStudent(models.Model):  name = models.CharField(max\_length=100)  def \_\_str\_\_(self):  return self.nameclassCourse(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:
classBook(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:
\# 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:
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.