Why ORM maps Python to database in Django - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why use ORM in Django?

What is the main reason Django's ORM maps Python classes to database tables?

A To make the database run faster by converting Python code directly into machine code

B To allow developers to work with database data using Python objects instead of SQL queries

C To replace the need for a database by storing all data in Python memory

D To automatically generate HTML pages from Python classes without templates

💡 Hint

Think about how ORM helps developers avoid writing raw SQL.

Django's ORM lets developers use Python classes and objects to interact with the database. This means you write Python code instead of SQL queries, making database work easier and less error-prone.

❓ component_behavior

intermediate

What happens when you save a Django model instance?

Given a Django model instance, what does calling the .save() method do in terms of ORM behavior?

Django

class Book(models.Model):
    title = models.CharField(max_length=100)

book = Book(title='Learn Django')
book.save()

A It creates or updates a row in the database table corresponding to the Book model

B It only updates the Python object in memory without affecting the database

C It deletes the corresponding row from the database

D It generates an HTML page showing the book details

💡 Hint

Think about how ORM syncs Python objects with the database.

Calling .save() on a Django model instance tells the ORM to write the data to the database. If the object is new, it inserts a new row; if it exists, it updates the row.

📝 Syntax

advanced

Identify the correct Django ORM query syntax

Which option correctly retrieves all Book objects with title 'Django Basics' using Django ORM?

A Book.objects.get_all(title='Django Basics')

B Book.filter(title='Django Basics')

C Book.objects.find(title='Django Basics')

D Book.objects.filter(title='Django Basics')

💡 Hint

Remember the Django ORM uses 'objects' manager and 'filter' method for queries.

The correct way to query multiple objects matching a condition is using Book.objects.filter(). Other options are invalid methods or missing the manager.

🔧 Debug

advanced

Why does this Django ORM query raise an error?

What error will this code raise and why? class Author(models.Model): name = models.CharField(max_length=50) # Query: Author.objects.get(name='Unknown')

A TypeError because name field is not a string

B MultipleObjectsReturned error because more than one Author has name 'Unknown'

C DoesNotExist error because no Author with name 'Unknown' exists

D SyntaxError because get() requires a list of names

💡 Hint

What happens if get() finds no matching record?

The get() method expects exactly one matching record. If none exist, Django raises a DoesNotExist error.

❓ state_output

expert

What is the output of this Django ORM code snippet?

Consider this code: class Product(models.Model): name = models.CharField(max_length=50) price = models.DecimalField(max_digits=5, decimal_places=2) Product.objects.create(name='Pen', price=1.50) Product.objects.create(name='Notebook', price=3.00) cheap_products = Product.objects.filter(price__lt=2.00) print(list(cheap_products.values_list('name', flat=True))) What will be printed?

A ['Pen']

B ['Pen', 'Notebook']

C []

D ['Notebook']

💡 Hint

Look at the filter condition price__lt=2.00 and which products match.

The filter price__lt=2.00 selects products with price less than 2.00. Only 'Pen' has price 1.50, so the output is ['Pen'].

Practice

1. Why does Django use an ORM to map Python classes to database tables?

easy

A. To prevent any changes to the database structure

B. To make the database run faster by skipping Python

C. To force developers to write raw SQL queries

D. To let developers work with databases using Python code instead of SQL

Solution

1. Step 1: Understand ORM purpose

   ORM stands for Object-Relational Mapping, which connects Python objects to database tables.

2. Step 2: Identify why mapping is useful

   This allows developers to use Python code to create, read, update, and delete data without writing SQL.

3. Final Answer:

   To let developers work with databases using Python code instead of SQL -> Option D

4. Quick Check:

   ORM = Python code for database [OK]

Hint: ORM means use Python classes, not SQL, for database [OK]

Common Mistakes:

• Thinking ORM makes database faster by skipping Python
• Believing ORM forces raw SQL writing
• Assuming ORM blocks database changes

2. Which of the following is the correct way to define a Django model field that maps to a database column?

easy

A. name = models.FieldChar(100)

B. name = CharField(max_length=100)

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

D. name = models.Char(100)

Solution

1. Step 1: Recall Django model field syntax

   Django model fields are defined using models.FieldType() with parameters.

2. Step 2: Match correct field type and parameters

   CharField is the correct field for text with a max length, and it requires max_length.

3. Final Answer:

   name = models.CharField(max_length=100) -> Option C

4. Quick Check:

   Correct field syntax = name = models.CharField(max_length=100) [OK]

Hint: Use models.FieldType() with parameters for fields [OK]

Common Mistakes:

• Omitting 'models.' prefix
• Using wrong field class names
• Passing parameters incorrectly

3. Given this Django model and code:

class Book(models.Model):
    title = models.CharField(max_length=50)

book = Book(title='Django Guide')
book.save()
print(Book.objects.count())

What will be printed?

medium

A. 0

B. 1

C. Error because save() is missing arguments

D. The title 'Django Guide'

Solution

1. Step 1: Understand model instance creation and saving

   Creating book with title and calling save() stores it in the database.

2. Step 2: Check what Book.objects.count() does

   This counts how many Book records exist in the database, which is 1 after saving.

3. Final Answer:

   1 -> Option B

4. Quick Check:

   Saved one book, count = 1 [OK]

Hint: save() adds record, count() shows total saved [OK]

Common Mistakes:

• Thinking save() needs arguments
• Confusing count() with printing title
• Assuming count() returns 0 before save

4. What is wrong with this Django model code?

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

author = Author(name='Alice')
author.save(name='Bob')

medium

A. save() method does not accept arguments like name

B. CharField requires max_length to be 100 or more

C. Model class must be named with lowercase

D. You cannot create model instances with parameters

Solution

1. Step 1: Check save() method usage

   The save() method does not take field values as arguments; it saves current instance data.

2. Step 2: Identify correct way to update fields

   To change a field, assign it before calling save(), e.g., author.name = 'Bob'.

3. Final Answer:

   save() method does not accept arguments like name -> Option A

4. Quick Check:

   save() takes no args, just saves instance [OK]

Hint: save() saves instance, does not take field args [OK]

Common Mistakes:

• Passing fields to save() method
• Thinking max_length must be >=100
• Naming model classes lowercase

5. You want to update all books with title 'Old Title' to 'New Title' using Django ORM. Which code correctly does this efficiently?

hard

A. Book.objects.filter(title='Old Title').update(title='New Title')

B. for book in Book.objects.all():
if book.title == 'Old Title':
book.title = 'New Title'
book.save()

C. Book.update(title='New Title').filter(title='Old Title')

D. Book.objects.get(title='Old Title').title = 'New Title'

Solution

1. Step 1: Understand bulk update with filter

   filter(...).update(...) updates all matching records in one database query efficiently.

2. Step 2: Compare other options

   for book in Book.objects.all():
       if book.title == 'Old Title':
           book.title = 'New Title'
           book.save()

   updates one by one, less efficient; A has wrong method order; D updates one object but does not save.

3. Final Answer:

   Book.objects.filter(title='Old Title').update(title='New Title') -> Option A

4. Quick Check:

   Bulk update with filter().update() is best [OK]

Hint: Use filter().update() for fast bulk changes [OK]

Common Mistakes:

• Updating objects one by one instead of bulk
• Calling update() before filter()
• Forgetting to save after changing fields