pre_save and post_save signals in Django - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when a pre_save signal modifies a model field?

Consider a Django model with a pre_save signal that changes a field value before saving. What will be the final saved value in the database?

Django

from django.db import models
from django.db.models.signals import pre_save
from django.dispatch import receiver

class Product(models.Model):
    name = models.CharField(max_length=100)
    price = models.DecimalField(max_digits=6, decimal_places=2)

@receiver(pre_save, sender=Product)
def update_price(sender, instance, **kwargs):
    if instance.price < 10:
        instance.price = 10.00

p = Product(name='Pen', price=5.00)
p.save()
print(Product.objects.get(name='Pen').price)

A 10.00

B 5.00

C 0.00

D Raises an error

💡 Hint

Think about when pre_save runs and what it can change.

The pre_save signal runs before the model instance is saved to the database. Modifying the instance's fields in pre_save changes what gets saved. Here, the price is set to 10.00 if it was less than 10 before saving.

❓ state_output

intermediate

What is printed by this post_save signal?

Given a post_save signal that prints a message after saving a model, what will be printed when a new instance is created?

Django

from django.db import models
from django.db.models.signals import post_save
from django.dispatch import receiver

class UserProfile(models.Model):
    username = models.CharField(max_length=50)

@receiver(post_save, sender=UserProfile)
def notify_save(sender, instance, created, **kwargs):
    if created:
        print(f"Created user: {instance.username}")
    else:
        print(f"Updated user: {instance.username}")

u = UserProfile(username='alice')
u.save()

A Raises an error

B Created user: alice

C No output

D Updated user: alice

💡 Hint

Check the created flag in post_save.

The post_save signal receives a created boolean that is True when a new instance is created. The signal prints "Created user: alice" when saving a new UserProfile.

📝 Syntax

advanced

Which option correctly connects a pre_save signal to a model?

Select the code snippet that correctly registers a pre_save signal handler for a Django model named Order.

A

from django.db.models.signals import pre_save
from django.dispatch import receiver

@receiver(pre_save, sender=Order)
def before_save(sender, instance, **kwargs):
    print('Saving order')

B

from django.db.models.signals import pre_save
from django.dispatch import receiver

@receiver(post_save, sender=Order)
def before_save(sender, instance, **kwargs):
    print('Saving order')

C

from django.db.models.signals import pre_save

@pre_save.connect

def before_save(sender, instance):
    print('Saving order')

D

from django.db.models.signals import pre_save
from django.dispatch import receiver

@receiver(pre_save)
def before_save(sender, instance, **kwargs):
    print('Saving order')

💡 Hint

Remember to specify the sender model in the @receiver decorator.

Option A correctly uses @receiver(pre_save, sender=Order) to connect the signal handler to the Order model's pre_save event.

Option A misuses @pre_save.connect without specifying sender and has wrong syntax.

Option A uses post_save instead of pre_save.

Option A misses the sender argument, so it listens to all models, which is usually incorrect.

🔧 Debug

advanced

Why does this post_save signal cause a recursion error?

Analyze the code below. Why does saving the instance inside the post_save signal cause a recursion error?

Django

from django.db import models
from django.db.models.signals import post_save
from django.dispatch import receiver

class Profile(models.Model):
    bio = models.TextField(blank=True)

@receiver(post_save, sender=Profile)
def update_bio(sender, instance, **kwargs):
    if not instance.bio:
        instance.bio = 'Default bio'
        instance.save()

p = Profile()
p.save()

A Because the signal handler is missing the <code>created</code> argument.

B Because <code>post_save</code> signals cannot modify model instances.

C Because calling <code>instance.save()</code> inside <code>post_save</code> triggers <code>post_save</code> again, causing infinite recursion.

D Because <code>bio</code> field cannot be blank, causing a validation error.

💡 Hint

Think about what happens when you save inside a post_save signal.

Calling instance.save() inside a post_save signal triggers the signal again, causing infinite recursion and eventually a recursion error.

🧠 Conceptual

expert

Which statement best describes the difference between pre_save and post_save signals?

Choose the most accurate description of how pre_save and post_save signals behave in Django.

A <code>pre_save</code> only runs when creating new instances; <code>post_save</code> only runs when updating existing instances.

B <code>pre_save</code> runs after saving the instance; <code>post_save</code> runs before saving and can modify fields.

C <code>pre_save</code> and <code>post_save</code> both run after saving but differ in the order of execution.

D <code>pre_save</code> runs before the model instance is saved and can modify fields; <code>post_save</code> runs after saving and can access the saved instance but changes won't affect the current save.

💡 Hint

Consider when each signal is triggered relative to the database save operation.

pre_save is triggered before the model instance is saved to the database, allowing modifications to the instance before saving.

post_save runs after the instance is saved, so changes made in post_save do not affect the current save operation.