One situation where Mixins are useful in Python is when you need to modify a method of similar classes that you are importing from a package.
For just a single class, it is easier to just create a derived class, but if the same modification must be applied to several classes, then it is cleaner to implement this modification once in a Mixin and then apply it to all of them.
Here an example in Django:
Django has several generic view classes that allow to pull objects from the database and feed them to the html templates.
One for example shows the detail of a specific object:
from django.views.generic.detail import DetailView
This class has a get_object method that gets an object from the database given a primary key.
We need to modify this method to allow access to an object only to the user that owns them.
We first implement a Mixin, i.e. an independent class that only implements the method we wish to override:
def get_object(self, *args, **kwargs):
obj = super(OwnedObjectMixin, self).get_object(*args, **kwargs)
if not obj.user == self.request.user:
Then we create a new derived class which inherits both from the Mixin and from the class we want to modify.
class ProtectedDetailView(OwnedObjectMixin, DetailView):
This overrides the get_object method of DetailView with the get_object method of OwnedObjectMixin, and the call to super calls the get_object method of DetailView, so has the same effect of subclassing DetailView and override the get_object method, but we can be apply the same Mixin to other classes.