The super() keyword is a useful tool in Django, a high-level Python web framework, for working with inheritance in classes. It allows a subclass to refer to its parent class, allowing the subclass to inherit attributes and methods from the parent class while also being able to override or extend them as needed.

Using super() can greatly simplify the process of working with inheritance in Django, allowing you to easily reuse code and customize your models, views, forms, and other components to fit your specific needs. In this article, we'll take a closer look at how to use the super() keyword in Django and explore some common use cases.

Inheriting attributes and methods in the __init__ method

One common use of super() in Django is in the __init__ method of a subclass. This method is called when an instance of the subclass is created, and it is used to initialize the attributes of the instance.

For example, consider a Django model called Product with a subclass called Book. The Product model might have fields for a title and a price, while the Book model might have an additional field for the author. In the __init__ method of the Book model, we can use super() to call the __init__ method of the Product model and pass in the title and price fields, while also adding the author field specific to the Book model:

class Product(models.Model):
    title = models.CharField(max_length=200)
    price = models.DecimalField(decimal_places=2, max_digits=10)

class Book(Product):
    author = models.CharField(max_length=200)

    def __init__(self, *args, **kwargs):
        # additional procesing before saving
        super().__init__(*args, **kwargs)

Using super().__init__(*args, **kwargs) in this way allows the Book model to inherit the title and price fields from the Product model, while also adding the author field specific to the Book model.

Overriding or extending methods in the subclass

Another common use of super() in Django is in the save method of a model. This method is called when the model instance is saved to the database, and it is used to persist any updates to the model instance.

For example, consider a Django model called Product with a save method that updates a last_modified field every time the model is saved. A subclass of Product called Book might want to override the save method to do some additional processing before saving the model. In this case, the save method of the Book model could use super() to call the save method of the Product model and pass in any additional arguments, while also doing the additional

class Product(models.Model):
    title = models.CharField(max_length=200)
    price = models.DecimalField(decimal_places=2, max_digits=10)
    last_modified = models.DateTimeField(auto_now=True)

    def save(self, *args, **kwargs):
        self.last_modified = timezone.now()
        self.save()

class Book(Product):
    author = models.CharField(max_length=200)

    def save(self, *args, **kwargs):
        # Do additional processing here
        super().save(*args, **kwargs)

In this revised version of the example code, the save method of the Product model saves the model instance after updating the last_modified field. When the save method of the Book model is called, it uses super().save(*args, **kwargs) to call the save method of the Product model, which saves the model instance with the updated last_modified field.

Using super() in a Django serializer

In Django, serializers are used to convert Django models or querysets into JSON format, allowing you to easily send data over the web or store it in a database. Serializers are typically used in combination with Django views and Django Rest Framework, a powerful toolkit for building APIs in Django.

You can use super() in a Django serializer to easily inherit attributes and methods from a parent serializer and customize or extend them as needed. For example, consider a Django serializer called ProductSerializer with a subclass called BookSerializer. The ProductSerializer might have fields for a title and a price, while the BookSerializer might have an additional field for the author. In the BookSerializer, we can use super() to call the ProductSerializer and pass in the title and price fields, while also adding the author field specific to the BookSerializer.

Using super() in Django template views

Django template views are used to render HTML templates and pass data to them for display. You can use super() in a Django template view to easily inherit attributes and methods from a parent template view and customize or extend them as needed.

One common use of super() in Django template views is in the get_context_data method, which is used to pass data to the template for rendering. For example, consider a Django template view called ProductView with a subclass called BookView. The ProductView might have a title variable, while the BookView might want to add an additional author variable. In the BookView, we can use super() to call the get_context_data method of the ProductView and pass in the title variable, while also adding the author variable specific to the BookView:

class ProductView(TemplateView):
    template_name = 'product.html'

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['title'] = 'Product'
        return context

class BookView(ProductView):
    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['author'] = 'John Doe'
        return context

Using super().get_context_data(**kwargs) in this way allows the BookView to inherit the title variable from the ProductView.

Using super() in Django forms

Django forms are used to validate and process user input. You can use super() in a Django form to easily inherit attributes and methods from a parent form and customize or extend them as needed.

One common use of super() in Django forms is in the validate method, which is used to perform validation on the form data. For example, consider a Django form called ProductForm with a subclass called BookForm. The ProductForm might have a field for a title, while the BookForm might want to add an additional author field and validate that the author field is not empty. In the BookForm, we can use super() to call the validate method of the ProductForm and pass in the cleaned_data dictionary, while also performing the additional validation for the BookForm:

class ProductForm(forms.Form):
    title = forms.CharField(max_length=200)

    def validate(self):
        cleaned_data = super().validate()
        title = cleaned_data.get('title')
        # Validate the title field
        if not title:
            raise forms.ValidationError('Please enter a title.')
        return cleaned_data

class BookForm(ProductForm):
    author = forms.CharField(max_length=200)

    def validate(self):
        cleaned_data = super().validate()
        author = cleaned_data.get('author')
        # Validate the author field
        if not author:
            raise forms.ValidationError('Please enter an author.')
        return cleaned_data

Using super().validate() in this way allows the BookForm to inherit the validation for the title field from the ProductForm, while also performing additional validation for the author field specific to the BookForm.

Conclusion

The super() keyword is a useful tool in Django for working with inheritance in classes. It allows a subclass to easily inherit attributes and methods from a parent class and customize or extend them as needed. Whether you're working with models, views, forms, or other components, super() can greatly simplify the process of working with inheritance in Django.

I hope this article has helped you understand how to use the super() keyword in Django and how it can make working with inheritance in your projects easier and more efficient. If you have any further questions or need additional clarification, don't hesitate to ask.

Disclaimer - I am not an expert & still learning. So, there may be some things which i may missed out or may be wrongly explained. As I got any comment about mistakes or figured out somewhere then i will correct it in blog.