Si quieren asignar una instancia que sea diferente a la primera, pueden usar el get() para hacerlo escribiendo el parametro de busqueda, en este caso, el ID.
author2 = Author.objects.get(id = 2)
Explorar la relación uno a uno en Django puede parecer complejo, pero es fundamental para construir aplicaciones sólidas.
¿Cómo se crea una clase en Django?
Para empezar, imaginemos que tenemos una clase Profile que contiene información pública del autor. Este perfil incluirá:
Aquí está el código inicial para la clase Profile:
class Profile(models.Model): website = models.URLField(max_length=200) biography = models.TextField(max_length=500) author = models.OneToOneField(Author, on_delete=models.CASCADE)
¿Cómo se maneja la relación uno a uno?
Para relacionar el perfil con el autor, utilizamos OneToOneField. Esto asegura que cada autor tenga un solo perfil y viceversa. Además, agregamos el parámetro on_delete=models.CASCADE para que si se elimina un autor, también se elimine su perfil.
¿Cómo se crean y se sincronizan las migraciones?
python manage.py make migrations.python manage.py migrate.¿Cómo verificamos la creación de un perfil en la consola de Django?
python manage.py shell.from myapp.models import Author, Profile.author = Author.objects.first().profile = Profile.objects.create( website="http://example.com", biography="Lorem Ipsum", author=author )
¿Cómo verificar los datos en la base de datos?
Usamos comandos SQL para verificar los datos:
SELECT * FROM myapp_profile WHERE author_id = 1;
¿Qué ocurre cuando se elimina un autor?
Si un autor se borra, su perfil también se eliminará gracias a on_delete=models.CASCADE.
Explorar la relación uno a uno en Django puede parecer complejo, pero es fundamental para construir aplicaciones sólidas.
Para empezar, imaginemos que tenemos una clase Profile que contiene información pública del autor. Este perfil incluirá:
Aquí está el código inicial para la clase Profile:
class Profile(models.Model):
website = models.URLField(max_length=200)
biography = models.TextField(max_length=500)
author = models.OneToOneField(Author, on_delete=models.CASCADE)
Para relacionar el perfil con el autor, utilizamos OneToOneField. Esto asegura que cada autor tenga un solo perfil y viceversa. Además, agregamos el parámetro on_delete=models.CASCADE para que si se elimina un autor, también se elimine su perfil.
python manage.py make migrations.python manage.py migrate.python manage.py shell.from myapp.models import Author, Profile.author = Author.objects.first().profile = Profile.objects.create(
website="http://example.com",
biography="Lorem Ipsum",
author=author
)
Usamos comandos SQL para verificar los datos:
SELECT * FROM myapp_profile WHERE author_id = 1;
Si un autor se borra, su perfil también se eliminará gracias a on_delete=models.CASCADE.
Si quieren asignar una instancia que sea diferente a la primera, pueden usar el get() para hacerlo escribiendo el parametro de busqueda, en este caso, el ID.
author2 = Author.objects.get(id = 2)
Cuando la linea de consola queda muy abajo, el icono que muestra al profe interfiere con lo que se escribe, en esta y queda uno con la duda de que va ahí, es solo solo una recomendación.
porque en la class Profile no iria el " def __str__(self): return self.website"?
No habia visto la Relacion de 1:1. Cual seria la diferencia de agregar los campos (website y biography en este caso), en la misma tabla de Author?

📚 Nombre de la clase Relaciones uno a uno (1:1) en Django
🎯 Idea principal Una relación uno a uno (1:1) conecta un registro de una tabla con exactamente un registro de otra tabla. En Django, este tipo de relación se implementa cuando dos modelos tienen una correspondencia directa y exclusiva. Se utiliza cuando una entidad necesita .
⚡ Síntesis en 10 segundos
🔑 Puntos clave
Relación uno a uno Cada registro de un modelo está vinculado a un único registro de otro modelo.
Extensión de modelos Permite agregar información adicional a una entidad sin modificar su modelo principal.
Relación exclusiva Un objeto solo puede estar relacionado con uno del otro modelo.
Diseño modular de datos Separar información en distintos modelos puede mejorar la organización del sistema.
Gestión mediante ORM Django permite acceder fácilmente al objeto relacionado mediante la relación definida.
🧠 Conceptos importantes
Relación exclusiva Vínculo donde cada registro solo puede tener una única relación con otro registro.
Extensión de entidad Estrategia para dividir información en múltiples modelos relacionados.
Normalización de datos Proceso de organizar la información para evitar duplicación o estructuras innecesarias.
Modelo relacionado Entidad que contiene información adicional conectada a otro modelo.
🧩 Modelo mental de la clase
Entidad principal ↓
Entidad secundaria que extiende su información
↓
Se establece relación 1:1
↓
Cada registro tiene exactamente un registro relacionado
↓
La aplicación accede a ambos como parte de la misma entidad lógica
Ejemplo conceptual:
Usuario ↓
Perfil del usuario
Cada usuario tiene un único perfil.
🚀 Acciones inmediatas
💼 Aplicación profesional
Las relaciones 1:1 se usan cuando se necesita extender entidades sin modificar su estructura principal, por ejemplo:
Permiten mantener los modelos modulares y organizados.
🔥 Errores comunes
Usar una relación uno a uno cuando en realidad se necesita una relación uno a muchos.
Colocar demasiada información en un solo modelo en lugar de separar responsabilidades.
Crear relaciones innecesarias que complican el diseño de la base de datos.
Confundir extensión de datos con dependencia entre entidades.
📝 Reflexión estratégica
Las relaciones uno a uno permiten separar responsabilidades dentro del modelo de datos. Esto facilita extender el sistema sin modificar estructuras existentes.
Diseñar bien este tipo de relación ayuda a construir aplicaciones más flexibles, donde las entidades pueden crecer sin que el modelo principal se vuelva complejo o difícil de mantener.
Como hizo para salir asi de la shell ?
Comparto este ejemplo que me ayudo a entender más estos temas:
from django.db import models
class Certificate(models.Model):
company = models.CharField(max_length=100) # Mejor usar CharField para textos cortos
title = models.CharField(max_length=200)
link = models.URLField()
def __str__(self):
return f"{self.title} - {self.company} - {self.link}"
class Department(models.Model): # Relación 1 a muchos con User
name = models.CharField(max_length=100)
description = models.TextField(max_length=300, blank=True)
def __str__(self):
return self.name
class User(models.Model):
name = models.CharField(max_length=100)
email = models.EmailField()
certificates = models.ManyToManyField(Certificate, related_name="users") # Relación muchos a muchos con Certificate
department = models.ForeignKey(Department, on_delete=models.CASCADE, related_name="users", null=True, blank=True) # Relación 1 a muchos
def __str__(self):
return f"{self.name} - {self.email}"
class Profile(models.Model): # Relación 1 a 1 con User
user = models.OneToOneField(User, on_delete=models.CASCADE, related_name="profile")
bio = models.TextField(max_length=500, blank=True)
phone_number = models.CharField(max_length=20, blank=True)
address = models.CharField(max_length=200, blank=True)
def __str__(self):
return f"Profile of {self.user.name}"
class Course(models.Model):
title = models.CharField(max_length=200)
description = models.TextField(max_length=500)
link = models.URLField()
certificates = models.ManyToManyField(Certificate, related_name="courses") # Relación muchos a muchos con Certificate
users = models.ManyToManyField(User, related_name="courses") # Relación muchos a muchos con User
def __str__(self):
return f"{self.title} - {self.description} - {self.link}"
Se supone que viendo los comentarios uno mismo se pueda guiar con este tipo de errores.