when to use pre_save, save, post_save in django?

I shall try my best to explain it with an example:

pre_save and post_save are signals that are sent by the model. In simpler words, actions to take before or after the model's save is called.

A save triggers the following steps

• Emit a pre-save signal.
• Pre-process the data.
• Most fields do no pre-processing — the field data is kept as-is.
• Prepare the data for the database.
• Insert the data into the database.
• Emit a post-save signal.

Django does provide a way to override these signals.

Now,

pre_save signal can be overridden for some processing before the actual save into the database happens - Example: (I dont know a good example of where pre_save would be ideal at the top of my head)

Lets say you have a ModelA which stores reference to all the objects of ModelB which have not been edited yet. For this, you can register a pre_save signal to notify ModelA right before ModelB's save method gets called (Nothing stops you from registering a post_save signal here too).

Now, save method (it is not a signal) of the model is called - By default, every model has a save method, but you can override it:

class ModelB(models.Model):    def save(self):        #do some custom processing here: Example: convert Image resolution to a normalized value        super(ModelB, self).save()

Then, you can register the post_save signal (This is more used that pre_save)

A common usecase is UserProfile object creation when User object is created in the system.

You can register a post_save signal which creates a UserProfile object that corresponds to every User in the system.

Signals are a way to keep things modular, and explicit. (Explicitly notify ModelA if i save or change something in ModelB )

I shall think of more concrete realworld examples in an attempt to answer this question better. In the meanwhile, I hope this helps you

Don't forget about recursions risk. If you use post_save method with instance.save() calling, instead of .update method, you should disconnect your post_save signal:

Signal.disconnect(receiver=None, sender=None, dispatch_uid=None)[source] To disconnect a receiver from a signal, call Signal.disconnect(). The arguments are as described in Signal.connect(). The method returns True if a receiver was disconnected and False if not.

The receiver argument indicates the registered receiver to disconnect. It may be None if dispatch_uid is used to identify the receiver.

... and connect it again after.

update() method don't send pre_ and post_ signals, keep it in mind.

pre_save

it's used before the transaction saves.

post_save

it's used after the transaction saves.

You can use pre_save for example if you have a FileField or an ImageField and see if the file or the image really exists.

You can use post_save when you have an UserProfile and you want to create a new one at the moment a new User it's created.