F expressions for field comparisons in Django - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What does this Django query return?

Consider a Django model Product with fields price and discount_price. What does this query return?

Product.objects.filter(price__gt=F('discount_price'))

A All products where the price is greater than the discount price.

B All products where the price is less than the discount price.

C All products where the price equals the discount price.

D All products regardless of price or discount price.

💡 Hint

Remember that F('discount_price') refers to the value of the discount_price field in the database.

The filter uses an F expression to compare the price field to the discount_price field for each product. It returns products where price is greater than discount_price.

📝 Syntax

intermediate

Which option correctly uses an F expression to find records where two fields are equal?

You want to find all Order objects where total_price equals amount_paid. Which query is correct?

A Order.objects.filter(total_price=F('amount_paid'))

B Order.objects.filter(total_price__eq=F('amount_paid'))

C Order.objects.filter(F('total_price') == F('amount_paid'))

D Order.objects.filter(total_price=amount_paid)

💡 Hint

Use the correct Django ORM syntax for field comparisons with F expressions.

Option A correctly uses the Django ORM syntax to compare two fields using an F expression. Option A uses an invalid lookup, C uses Python syntax not supported in filters, and D compares to a variable, not a field.

🔧 Debug

advanced

Why does this Django query raise an error?

Given the model Employee with fields salary and bonus, what causes the error in this query?

Employee.objects.filter(salary > F('bonus'))

A F expressions cannot be used with numeric fields.

B The field names salary and bonus must be strings inside F expressions.

C The filter method requires a list, not a comparison.

D The comparison operator > cannot be used directly inside filter; use lookup syntax instead.

💡 Hint

Check how Django expects comparisons in filter arguments.

Django ORM filters require lookups like __gt for greater than comparisons. Using > directly causes a syntax error.

❓ state_output

advanced

What is the result count of this query?

Assume the Book model has fields pages and read_pages. Which query returns books where pages are at least twice the read_pages?

Book.objects.filter(pages__gte=F('read_pages') * 2)

What does this query return?

A Books where pages equal read_pages multiplied by 2.

B Books where the read pages are greater than or equal to twice the total pages.

C Books where the total pages are greater than or equal to twice the read pages.

D Books where pages are less than twice the read pages.

💡 Hint

Remember that __gte means greater than or equal to.

The filter uses an F expression with multiplication to compare pages to twice read_pages, returning books where pages >= 2 * read_pages.

🧠 Conceptual

expert

What happens when you use F expressions in update() with field comparisons?

Consider this code:

Product.objects.filter(stock__lt=F('reorder_level')).update(stock=F('stock') + 10)

What is the effect of this update?

A It decreases stock by 10 for products where stock is less than reorder_level.

B It increases the stock by 10 only for products where stock is less than reorder_level.

C It sets stock to 10 for all products regardless of stock or reorder_level.

D It causes a runtime error because F expressions cannot be used in update().

💡 Hint

Think about how update() and F expressions work together in Django.

The update uses an F expression to add 10 to the stock field only for products where stock is less than reorder_level, modifying those records in the database.

Practice

1. What is the main purpose of using F expressions in Django ORM?

easy

A. To compare or update model fields directly in the database without fetching data

B. To convert query results into Python dictionaries

C. To create new database tables automatically

D. To write raw SQL queries inside Django models

Solution

1. Step 1: Understand what F expressions do

   F expressions allow referencing model fields directly in queries without loading data into Python.

2. Step 2: Identify the correct use case

   This lets you compare or update fields efficiently in the database, avoiding extra data transfer.

3. Final Answer:

   To compare or update model fields directly in the database without fetching data -> Option A

4. Quick Check:

   F expressions = direct DB field operations [OK]

Hint: F expressions work inside queries without loading data [OK]

Common Mistakes:

• Thinking F expressions convert results to dicts
• Confusing F expressions with migrations
• Assuming F expressions run raw SQL

2. Which of the following is the correct syntax to filter objects where the field score is greater than the field min_score using F expressions?

easy

A. Model.objects.filter(F('score') > F('min_score'))

B. Model.objects.filter(score > F('min_score'))

C. Model.objects.filter(score__gt='min_score')

D. Model.objects.filter(score__gt=F('min_score'))

Solution

1. Step 1: Recall correct filter syntax with F expressions

   Use field lookups like score__gt=F('min_score') to compare fields.

2. Step 2: Check each option

   Model.objects.filter(score__gt=F('min_score')) uses correct Django ORM syntax. Model.objects.filter(score > F('min_score')) uses invalid Python syntax inside filter. Model.objects.filter(score__gt='min_score') compares to string, not field. Model.objects.filter(F('score') > F('min_score')) is invalid syntax.

3. Final Answer:

   Model.objects.filter(score__gt=F('min_score')) -> Option D

4. Quick Check:

   Use field lookups with F('field') [OK]

Hint: Use field lookups like __gt with F('field') [OK]

Common Mistakes:

• Using Python operators inside filter()
• Passing field names as strings instead of F expressions
• Confusing field lookup syntax

3. Given the model Product with fields price and discount_price, what will this query return?

Product.objects.filter(discount_price__lt=F('price')).count()

medium

A. The total number of products in the database

B. The number of products where discount_price is less than price

C. The number of products where discount_price equals price

D. Raises a syntax error

Solution

1. Step 1: Understand the filter condition

   The filter selects products where discount_price is less than price using an F expression.

2. Step 2: Understand the count() method

   It returns the number of records matching the filter condition.

3. Final Answer:

   The number of products where discount_price is less than price -> Option B

4. Quick Check:

   filter with F expression returns matching count [OK]

Hint: F expressions compare fields inside filters correctly [OK]

Common Mistakes:

• Thinking count() returns all products
• Confusing less than with equals
• Assuming syntax error due to F expression

4. Identify the error in this Django query using F expressions:

Order.objects.filter(total__gt=F(total_paid))

medium

A. Missing quotes around the field name in F expression

B. Using __gt instead of __lt for comparison

C. F expressions cannot be used in filters

D. total and total_paid fields must be integers

Solution

1. Step 1: Check F expression syntax

   The field name inside F() must be a string, so it should be F('total_paid').

2. Step 2: Analyze the given query

   The query uses F(total_paid) without quotes, causing a NameError or syntax error.

3. Final Answer:

   Missing quotes around the field name in F expression -> Option A

4. Quick Check:

   F('field_name') requires quotes [OK]

Hint: Always put field names as strings inside F() [OK]

Common Mistakes:

• Omitting quotes inside F()
• Confusing comparison operators
• Believing F expressions can't be in filters

5. You want to update all Employee records to increase their salary by the value in their bonus field using F expressions. Which code snippet correctly performs this update?

hard

A. Employee.objects.update(salary=F('salary' + 'bonus'))

B. Employee.objects.update(salary='salary + bonus')

C. Employee.objects.update(salary=F('salary') + F('bonus'))

D. Employee.objects.update(salary=F('salary') - F('bonus'))

Solution

1. Step 1: Understand how to update fields with F expressions

   You can perform arithmetic operations between fields using F expressions like F('salary') + F('bonus').

2. Step 2: Check each option

   Employee.objects.update(salary=F('salary') + F('bonus')) correctly adds the two fields. Employee.objects.update(salary=F('salary' + 'bonus')) incorrectly concatenates strings inside F(). Employee.objects.update(salary='salary + bonus') assigns a string, not a field operation. Employee.objects.update(salary=F('salary') - F('bonus')) subtracts instead of adding.

3. Final Answer:

   Employee.objects.update(salary=F('salary') + F('bonus')) -> Option C

4. Quick Check:

   Use arithmetic with F('field') for updates [OK]

Hint: Use F('field1') + F('field2') for field arithmetic updates [OK]

Common Mistakes:

• Concatenating field names as strings inside F()
• Assigning string expressions instead of F expressions
• Using wrong arithmetic operator