Why relationships model real-world data in Django - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a Django model with a foreign key relationship.

Django

class Book(models.Model):
    author = models.ForeignKey([1], on_delete=models.CASCADE)
    title = models.CharField(max_length=100)

Drag options to blanks, or click blank then click option'

AAuthor

Bmodels.CharField

CBook

DForeignKey

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong model name in ForeignKey

Forgetting to import the related model

The ForeignKey field links the Book model to the Author model, showing a real-world relationship where a book has an author.

2fill in blank

medium

Complete the code to add a many-to-many relationship between students and courses.

Django

class Student(models.Model):
    courses = models.[1](Course)
    name = models.CharField(max_length=50)

Drag options to blanks, or click blank then click option'

AForeignKey

BManyToManyField

CCharField

DOneToOneField

Attempts:

3 left

💡 Hint

Common Mistakes

Using ForeignKey instead of ManyToManyField

Not specifying the related model

ManyToManyField is used to model a many-to-many relationship, like students enrolled in multiple courses.

3fill in blank

hard

Fix the error in the model relationship by completing the code.

Django

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

Drag options to blanks, or click blank then click option'

AUser

BProfile

Cmodels.TextField

DForeignKey

Attempts:

3 left

💡 Hint

Common Mistakes

Linking to the wrong model

Using ForeignKey instead of OneToOneField

The OneToOneField should link to the User model to represent a one-to-one relationship between a profile and a user.

4fill in blank

hard

Fill both blanks to create a dictionary comprehension that maps each course name to the number of students enrolled, filtering courses with more than 5 students.

Django

course_counts = {course.name: [1] for course in courses if [2] > 5}

Drag options to blanks, or click blank then click option'

Acourse.students.count()

Blen(course.students)

Ccourse.students.count

Dcourse.students

Attempts:

3 left

💡 Hint

Common Mistakes

Using len() on a related manager

Using the attribute without calling count()

Use course.students.count() to get the number of students enrolled in each course and filter courses with more than 5 students.

5fill in blank

hard

Fill all three blanks to create a queryset filtering authors who have written more than 3 books and order them by name.

Django

authors = Author.objects.annotate(book_count=[1]).filter([2]__gt=[3]).order_by('name')

Drag options to blanks, or click blank then click option'

ACount('book')

Bbook_count

C3

Dfilter

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong annotation syntax

Filtering on the wrong field

Not ordering correctly

Use Count('book') to annotate the number of books per author, filter authors with book_count > 3, and order by name.

Practice

1. Why do Django models use relationships like ForeignKey to connect data?

easy

A. To avoid using any database tables

B. To make the database slower by adding extra links

C. To store all data in a single model without separation

D. To represent real-world connections between data clearly and efficiently

Solution

1. Step 1: Understand the purpose of relationships in Django models

   Relationships like ForeignKey link models to represent how real-world objects relate, such as a book belonging to an author.

2. Step 2: Recognize the benefit of clear data connections

   These links help organize data logically and make queries easier, reflecting real-world connections efficiently.

3. Final Answer:

   To represent real-world connections between data clearly and efficiently -> Option D

4. Quick Check:

   Relationships model real-world links [OK]

Hint: Relationships connect models like real-world links [OK]

Common Mistakes:

• Thinking relationships slow down the database
• Believing all data should be in one model
• Confusing relationships with avoiding tables

2. Which of the following is the correct way to define a one-to-many relationship in a Django model?

easy

A. author = models.ForeignKey(Author, on_delete=models.CASCADE)

B. author = models.ManyToManyField(Author)

C. author = models.CharField(max_length=100)

D. author = models.OneToOneField(Author)

Solution

1. Step 1: Identify the correct field for one-to-many

   In Django, ForeignKey creates a one-to-many link from one model to another.

2. Step 2: Check the syntax for ForeignKey

   The syntax author = models.ForeignKey(Author, on_delete=models.CASCADE) correctly defines this relationship.

3. Final Answer:

   author = models.ForeignKey(Author, on_delete=models.CASCADE) -> Option A

4. Quick Check:

   One-to-many uses ForeignKey [OK]

Hint: One-to-many uses ForeignKey with on_delete [OK]

Common Mistakes:

• Using ManyToManyField for one-to-many
• Forgetting on_delete argument
• Using CharField for relationships

3. Given these models:

class Author(models.Model):
    name = models.CharField(max_length=100)

class Book(models.Model):
    title = models.CharField(max_length=100)
    author = models.ForeignKey(Author, on_delete=models.CASCADE)

What will book.author.name return if book is a Book instance?

medium

A. The title of the book

B. The name of the author linked to the book

C. An error because author is not a string

D. The primary key of the author

Solution

1. Step 1: Understand the ForeignKey link

   The author field in Book links to an Author instance.

2. Step 2: Access the name attribute of the linked Author

   Using book.author.name accesses the Author's name string.

3. Final Answer:

   The name of the author linked to the book -> Option B

4. Quick Check:

   book.author.name returns author name [OK]

Hint: ForeignKey lets you access related model fields directly [OK]

Common Mistakes:

• Thinking book.author.name returns book title
• Expecting an error accessing author.name
• Confusing author primary key with name

4. What is wrong with this Django model relationship?

class Comment(models.Model):
    post = models.ForeignKey(Post)
    text = models.TextField()

medium

A. Missing the required on_delete argument in ForeignKey

B. ForeignKey should be replaced with ManyToManyField

C. TextField cannot be used for text data

D. The model name should be plural

Solution

1. Step 1: Check ForeignKey syntax requirements

   Since Django 2.0, ForeignKey requires the on_delete argument to specify behavior on deletion.

2. Step 2: Identify missing on_delete argument

   The model misses on_delete=models.CASCADE or similar, causing an error.

3. Final Answer:

   Missing the required on_delete argument in ForeignKey -> Option A

4. Quick Check:

   ForeignKey needs on_delete argument [OK]

Hint: Always add on_delete to ForeignKey fields [OK]

Common Mistakes:

• Omitting on_delete causes errors
• Replacing ForeignKey with ManyToManyField incorrectly
• Thinking TextField is invalid for text

5. You want to model a library system where each Book can have multiple Authors, and each Author can write multiple Books. Which Django relationship should you use to model this real-world data?

hard

A. Use a OneToOneField from Author to Book

B. Use a ForeignKey from Book to Author

C. Use a ManyToManyField on Book linking to Author

D. Use a CharField listing author names in Book

Solution

1. Step 1: Understand the real-world relationship

   Each book can have many authors, and each author can write many books, so the relationship is many-to-many.

2. Step 2: Choose the correct Django field for many-to-many

   Django's ManyToManyField models this relationship properly, allowing multiple links both ways.

3. Final Answer:

   Use a ManyToManyField on Book linking to Author -> Option C

4. Quick Check:

   Many-to-many needs ManyToManyField [OK]

Hint: Many-to-many means ManyToManyField in Django [OK]

Common Mistakes:

• Using ForeignKey for many-to-many
• Using OneToOneField incorrectly
• Storing author names as text instead of relations