Model inheritance is a Django ORM feature that allows developers to create hierarchical relationships between database models. It enables code reuse, extensibility, and a cleaner code base by leveraging the principles of object-oriented programming.

Whether you’re building a complex web application or working on a smaller project, model inheritance can offer significant benefits, such as reducing redundancy and ensuring consistent behavior.

django admin panel showing the fields from an abstract model

Types of Model Inheritance in Django

Django offers support for three types of model inheritance:

Each of these types of model inheritance has benefits and you’ll use them for specific purposes.

Abstract Base Classes

Abstract base classes provide a way to define common fields and methods that multiple models can inherit. For example, if you have two models sharing similar fields, you can use an abstract base class to define the similar fields. Take a look at this example:

The code snippet above defines two Django models:CustomerandSeller. These models share two common fields, namelynameandemail. To prevent this redundancy, you can create a separate model to hold the common fields in theCustomerandSellermodels and make it abstract.

django admin showing the fields from two inherited models

The above code snippet defines a new model and sets theabstractattribute toTrue. This means the model will be abstract, and Django will not create a table in the database.

You can rewrite theCustomerandSellermodels like this:

In the code snippet above, theCustomerandSellersmodels inherit from theUserInfomodel instead ofmodels.Model.

You can view your models in the admin panel by registering them in youradmin.pyfile like this:

adding a new post in the Django admin panel

Migrate your modes and start your development server by running the following on acommand line:

Navigate to your admin site and log in with your superuser details. You should see all three fields for each model.

proxy model string representation in Django admin panel

In this example, Django has created a table for theCustomerandSellermodels. You can see that theUserInfomodel has no table since it is abstract.

Multi-Table Inheritance

You can use multi-table inheritance when the parent model also needs to exist as a table in the database alongside the child model.

Unlike abstract base class inheritance, where the parent model will not be a table in the database, multi-table inheritance creates a table for the parent model.

new proxy model string representation in Django admin panel.

In multi-table inheritance, the child model inherits all the fields and methods from its parent model and adds its specific fields.Foreign keyshelp to establish themodel relationshipbetween parent and child models.

Here’s an example of multi-table inheritance:

This code snippet defines three models. The first model, calledPerson, is abstract. It defines only the first and last names of a person.

The second model, calledEmployee, inherits the fields ofPersonbut defines additional fields. TheEmployeemodel is not abstract, so it will have its table in the database.

The final model, calledManager, inherits the fields of theEmployeemodel and adds a field calledtitle.

The relationship between theEmployeeandManagermodels is calledMulti-Table Inheritance. Migrate your models, register them inadmin.py, start your server, and navigate to the admin panel. You should see two tables created by Django.

When you try to add a new manager, you’ll notice that it has all the fields from theEmployeemodel as well as its own custom field.

Proxy Models

A proxy model helps you create a new model that extends from an existing model without creating a new database table. In this kind of model inheritance, the proxy and original models will share the same table. Using proxy models, you can do things like creating custom models and changing default managers.

you’re able to create a proxy model by addingproxy=Truein theMetaclass. Here’s an example:

Typical usage of a proxy model is appropriate when a base model exists and there is a need to create a specialized version of it with added functionality. Here’s a basic example:

This code snippet defines two models:PostandMyPost. ThePostmodel defines two fields for title and author. TheProxyPostmodel inherits from thePostmodel.

Migrate the above models and add a new post to the table created for thePostmodel.

After adding the post, open theProxy poststable. You should find the post you added to thePosttable in it.

The changes you make to posts in theProxy poststable will affect the corresponding post in thePosttable, and vice-versa. This proves that they truly share the same table.

You can modify thestr()method of the proxy model:

With this modification, aProxyPost’sstring representation will be its author, not the title. The ordering of the proxy model will also be by the title instead of the default ID field.

When using proxy models, you should bear in mind that you cannot add custom fields to your proxy model. The primary use case of proxy models is when you want one model to support multiple behaviors.

Proxy models help you change the behavior of an existing model without modifying its fields or underlying database table structure.

Use Model Inheritance for Code Reusability and Organizational Structure

By utilizing the different techniques of model inheritance, you can easily create reusable and organized code for your project.

Model inheritance avoids redundant code and enhances the maintainability and scalability of your code. It also makes it easy to navigate your code, thus fostering efficient collaboration among development teams.

Apart from model inheritance, Django offers template inheritance, which is a great way to manage and organize templates for your projects.