pre_delete and post_delete signals in Django

Introduction

These signals let you run code right before or after a database record is deleted. This helps you clean up or update related data automatically.

You want to delete related files from storage when a database record is deleted.

You need to update a log or audit trail whenever a record is removed.

You want to prevent deletion if certain conditions are not met.

You want to notify other parts of your app after a record is deleted.

You want to clean up related database entries automatically.

Syntax

Django

from django.db.models.signals import pre_delete, post_delete
from django.dispatch import receiver
from yourapp.models import YourModel

@receiver(pre_delete, sender=YourModel)
def before_delete(sender, instance, **kwargs):
    # code to run before deletion
    pass

@receiver(post_delete, sender=YourModel)
def after_delete(sender, instance, **kwargs):
    # code to run after deletion
    pass

Use @receiver decorator to connect your function to the signal.

The instance argument is the object being deleted.

Examples

This deletes the file from storage before the Document record is deleted.

Django

from django.db.models.signals import pre_delete
from django.dispatch import receiver
from myapp.models import Document

@receiver(pre_delete, sender=Document)
def delete_file(sender, instance, **kwargs):
    instance.file.delete(save=False)

This prints a message after a Comment is deleted.

Django

from django.db.models.signals import post_delete
from django.dispatch import receiver
from myapp.models import Comment

@receiver(post_delete, sender=Comment)
def log_deletion(sender, instance, **kwargs):
    print(f"Comment by {instance.author} was deleted.")

Sample Program

This example shows two signal handlers printing messages before and after a Note is deleted.

Django

from django.db import models
from django.db.models.signals import pre_delete, post_delete
from django.dispatch import receiver

class Note(models.Model):
    text = models.CharField(max_length=100)

@receiver(pre_delete, sender=Note)
def before_note_delete(sender, instance, **kwargs):
    print(f"About to delete Note: {instance.text}")

@receiver(post_delete, sender=Note)
def after_note_delete(sender, instance, **kwargs):
    print(f"Deleted Note: {instance.text}")

# Simulate deleting a Note instance
note = Note(text='Remember to buy milk')

# Normally, deletion happens via note.delete(), but here we simulate signals manually
before_note_delete(Note, note)
# Imagine the note is deleted here
after_note_delete(Note, note)

Important Notes

Signals run every time the model instance is deleted, even if deleted in bulk.

Be careful with side effects in signals to avoid unexpected bugs.

Summary

pre_delete runs before a record is deleted.

post_delete runs after a record is deleted.

Use these signals to manage related cleanup or notifications automatically.

Practice

1. What is the main difference between Django's pre_delete and post_delete signals?

easy

A. pre_delete runs after a record is deleted, post_delete runs before.

B. pre_delete runs before a record is deleted, post_delete runs after.

C. Both signals run at the same time during deletion.

D. pre_delete only works with models, post_delete only with forms.

Solution

1. Step 1: Understand signal timing

   pre_delete is triggered just before a model instance is deleted from the database.

2. Step 2: Understand post_delete timing

   post_delete is triggered immediately after the instance has been deleted.

3. Final Answer:

   pre_delete runs before a record is deleted, post_delete runs after. -> Option B

4. Quick Check:

   Signal timing difference = pre_delete runs before a record is deleted, post_delete runs after. [OK]

Hint: Remember: pre_delete before removal, post_delete after removal [OK]

Common Mistakes:

• Confusing the order of signal execution
• Thinking both signals run simultaneously
• Assuming signals work only with forms

2. Which of the following is the correct way to connect a pre_delete signal to a model named Book?

easy

A. Book.pre_delete.connect(my_handler)

B. post_delete.connect(my_handler, sender=Book)

C. pre_delete.connect(my_handler, sender=Book)

D. connect(pre_delete, my_handler, Book)

Solution

1. Step 1: Recall signal connection syntax

   In Django, signals are connected using signal.connect(handler, sender=Model).

2. Step 2: Apply to pre_delete and Book

   Use pre_delete.connect(my_handler, sender=Book) to connect the handler to the Book model.

3. Final Answer:

   pre_delete.connect(my_handler, sender=Book) -> Option C

4. Quick Check:

   Correct connect syntax = pre_delete.connect(my_handler, sender=Book) [OK]

Hint: Use signal.connect(handler, sender=Model) to connect signals [OK]

Common Mistakes:

• Using post_delete instead of pre_delete
• Trying to call connect on the model itself
• Incorrect argument order in connect

3. Given this code snippet, what will be printed when a Book instance is deleted?

from django.db.models.signals import pre_delete, post_delete
from django.dispatch import receiver

@receiver(pre_delete, sender=Book)
def before_delete(sender, instance, **kwargs):
    print(f"Deleting book: {instance.title} (pre_delete)")

@receiver(post_delete, sender=Book)
def after_delete(sender, instance, **kwargs):
    print(f"Deleted book: {instance.title} (post_delete)")

book = Book(title='Django Basics')
book.delete()

medium

A. Deleting book: Django Basics (pre_delete)
Deleted book: Django Basics (post_delete)

B. Deleted book: Django Basics (post_delete)
Deleting book: Django Basics (pre_delete)

C. Only Deleting book: Django Basics (pre_delete) is printed

D. No output is printed

Solution

1. Step 1: Understand signal order on deletion

   pre_delete runs before the instance is deleted, so its print runs first.

2. Step 2: Understand post_delete runs after deletion

   After deletion, post_delete signal triggers, printing the second message.

3. Final Answer:

   Deleting book: Django Basics (pre_delete) Deleted book: Django Basics (post_delete) -> Option A

4. Quick Check:

   Signal print order = Deleting book: Django Basics (pre_delete) Deleted book: Django Basics (post_delete) [OK]

Hint: pre_delete prints before delete, post_delete prints after [OK]

Common Mistakes:

• Assuming post_delete prints before pre_delete
• Expecting only one signal to run
• Forgetting to call delete() on the instance

4. What is wrong with this code that tries to use pre_delete signal?

from django.db.models.signals import pre_delete

@pre_delete(sender=Author)
def cleanup(sender, instance, **kwargs):
    print('Cleaning up author data')

medium

A. Using @pre_delete decorator is incorrect; should use @receiver instead.

B. Missing import for Author model.

C. Signal handler must return a value.

D. The function name 'cleanup' is reserved and cannot be used.

Solution

1. Step 1: Check signal handler decoration

   Django signals use the @receiver(signal, sender=Model) decorator, not @pre_delete(sender=Model).

2. Step 2: Confirm correct decorator usage

   Replace @pre_delete(sender=Author) with @receiver(pre_delete, sender=Author) to fix the error.

3. Final Answer:

   Using @pre_delete decorator is incorrect; should use @receiver instead. -> Option A

4. Quick Check:

   Use @receiver for signals, not @pre_delete [OK]

Hint: Use @receiver(signal, sender=Model) to decorate signal handlers [OK]

Common Mistakes:

• Using signal name as decorator directly
• Forgetting to import @receiver
• Assuming signal handlers must return values

5. You want to automatically delete all Comment objects related to a Post before the Post itself is deleted. Which signal and approach is best?

hard

A. Use post_delete on Comment to delete the post after comments are removed.

B. Use post_delete on Post to delete related Comment objects after the post is removed.

C. Use pre_delete on Comment to delete the post before comments are removed.

D. Use pre_delete on Post to delete related Comment objects before the post is removed.

Solution

1. Step 1: Understand deletion order requirement

   Comments must be deleted before the post to avoid foreign key errors.

2. Step 2: Choose correct signal and model

   pre_delete on Post allows deleting related comments before the post is removed.

3. Final Answer:

   Use pre_delete on Post to delete related Comment objects before the post is removed. -> Option D

4. Quick Check:

   Delete related objects in pre_delete to avoid FK errors [OK]

Hint: Delete related objects in pre_delete to prevent FK constraint errors [OK]

Common Mistakes:

• Deleting related objects after post deletion causes errors
• Using signals on wrong model
• Trying to delete parent in comment signals