Python’s abc module lets you create abstract base classes which is a great way to enforce method contracts in your code. With abc.ABC, @abstractmethod, and the new @override decorator from Python 3.12, you can make your class hierarchy both cleaner and safer.

Abstract Classes 101

To define a base class that requires certain methods to be implemented, use abc.ABC and @abstractmethod:

from abc import ABC, abstractmethod

class Animal(ABC):

    @abstractmethod
    def speak(self):
        # Subclasses must implement this method
        raise NotImplementedError

If you forget to implement speak() in a subclass, Python will stop you:

class Dog(Animal):

    def wag_tail(self):
        print("Wagging tail")

dog = Dog()  # Error!

Output:

TypeError: Can't instantiate abstract class Dog without
an implementation for abstract method 'speak'

This guarantees that required methods are never left out.

Adding @override for Safety

Python 3.12 added @override in typing, which helps catch typos or mismatches when overriding methods:

from typing import override

class Dog(Animal):

    @override
    def speak(self):
        print("Woof!")

This decorator doesn’t change behaviour at runtime, but makes static analysis tools more powerful and your intent clearer.

Real-World Example: Django Views

Let’s define a Django generic view that enforces a get_report_data() method:

from abc import ABC, abstractmethod
from typing import override
from django.views.generic import TemplateView

class AbstractReportView(TemplateView, ABC):
    template_name = "report.html"

    @abstractmethod
    def get_report_data(self):
        raise NotImplementedError

    @override
    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['report'] = self.get_report_data()
        return context

Any subclass must implement get_report_data():

class SalesReportView(AbstractReportView):

    @override
    def get_report_data(self):
        return {
            'title': 'Sales Report',
            'data': [100, 200, 150],
        }

If you don’t, Django will raise the same TypeError on view instantiation.

Conclusion: Using abc.ABC, @abstractmethod, and @override gives your code structure and reliability, especially in complex class hierarchies like those found in Django generic views.