OneToOneField for one-to-one in Django - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when you access a related object via OneToOneField?

Consider these Django models:

class Profile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    bio = models.TextField()

If you have a User instance u, what does u.profile return?

A The <code>Profile</code> instance linked to <code>u</code>, or raises <code>Profile.DoesNotExist</code> if none exists

B Always returns None

C The <code>User</code> instance itself

D A list of all <code>Profile</code> instances linked to <code>u</code>

💡 Hint

Think about how OneToOneField creates a direct link between two models.

OneToOneField creates a single related object accessible as an attribute. Accessing u.profile returns the linked Profile instance or raises DoesNotExist if none exists.

📝 Syntax

intermediate

Which is the correct way to define a OneToOneField in Django?

Choose the correct syntax to define a one-to-one relationship from Profile to User:

A user = models.ManyToManyField(User)

B user = models.ForeignKey(User, unique=True, on_delete=models.CASCADE)

C user = models.OneToOneField(User, on_delete=models.CASCADE)

D user = models.OneToManyField(User)

💡 Hint

OneToOneField is a specific field type in Django models.

Only models.OneToOneField correctly defines a one-to-one relationship. ForeignKey with unique=True is not recommended for this purpose. ManyToManyField and OneToManyField do not exist or do not represent one-to-one.

🔧 Debug

advanced

Why does accessing a OneToOneField related object raise an error?

Given these models:

class Profile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)

u = User.objects.create(username='alice')
print(u.profile)

This code raises Profile.DoesNotExist. Why?

A Because <code>on_delete=models.CASCADE</code> deletes the <code>User</code> instance

B Because <code>OneToOneField</code> requires <code>null=True</code> to work

C Because <code>User</code> model does not have a <code>profile</code> attribute by default

D Because no <code>Profile</code> instance linked to <code>u</code> exists yet

💡 Hint

Think about what happens if the related object is missing.

Accessing u.profile tries to find a Profile linked to u. If none exists, Django raises Profile.DoesNotExist. The other options are incorrect because null=True is not required, the reverse attribute is created automatically, and on_delete does not delete the user here.

❓ state_output

advanced

What is the output of this Django shell code involving OneToOneField?

Given these models and code:

class Profile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    bio = models.CharField(max_length=100)

u = User.objects.create(username='bob')
p = Profile.objects.create(user=u, bio='Hello')
print(u.profile.bio)

What will be printed?

A bob

B Hello

C Profile object at some memory address

D Raises Profile.DoesNotExist

💡 Hint

Remember that u.profile accesses the related Profile instance.

The code creates a User and a linked Profile with bio 'Hello'. Accessing u.profile.bio prints 'Hello'.

🧠 Conceptual

expert

Why use OneToOneField instead of ForeignKey with unique=True?

In Django, both OneToOneField and ForeignKey with unique=True can enforce one-to-one relationships. Why is OneToOneField preferred?

A OneToOneField creates a reverse attribute on the related model automatically, improving code clarity and access

B ForeignKey with unique=True does not enforce uniqueness at the database level

C OneToOneField allows multiple related objects, unlike ForeignKey

D ForeignKey with unique=True is deprecated and no longer supported in Django

💡 Hint

Think about how Django creates reverse relations and the developer experience.

OneToOneField automatically creates a reverse attribute on the related model, making it easier to access the linked object. ForeignKey with unique=True can enforce uniqueness but does not create a clear reverse one-to-one relation. Option A is incorrect because unique=True does enforce uniqueness. Option A is false because OneToOneField allows only one related object. Option A is false because ForeignKey with unique=True is still supported.