This is an old question, but I believe the answer is incorrect. There is a mistake in your code. It should read:
class MyListView[ListSortedMixin, ListPaginatedMixin, ListView]:
def get_context_data[self, **context]:
super[MyListView,self].get_context_data[**context]
return context
The order in which the get_context_data
will be called follows the same order as specified in the declaration of MyListView
. Notice the argument of super is MyListView
and not the super classes.
UPDATE:
I missed that your mixins don't call super. They should. Yes, even if they inherit from object, because super calls the next method in the MRO, not necessarily the parent of class it is in.
from django.views.generic import ListView
class ListSortedMixin[object]:
def get_context_data[self, **kwargs]:
print 'ListSortedMixin'
return super[ListSortedMixin,self].get_context_data[**context]
class ListPaginatedMixin[object]:
def get_context_data[self, **kwargs]:
print 'ListPaginatedMixin'
return super[ListPaginatedMixin,self].get_context_data[**context]
class MyListView[ListSortedMixin, ListPaginatedMixin, ListView]:
def get_context_data[self, **context]:
return super[MyListView,self].get_context_data[**context]
For MyListView
the MRO is then:
- MyListView
- ListSortedMixin
- ListPaginatedMixin
- ListView
- Whatever is above ListView ... n. object
Calling them one by one may work, but is not how it was intended to be used.
UPDATE 2
Copy and paste example to prove my point.
class Parent[object]:
def get_context_data[self, **kwargs]:
print 'Parent'
class ListSortedMixin[object]:
def get_context_data[self, **kwargs]:
print 'ListSortedMixin'
return super[ListSortedMixin,self].get_context_data[**kwargs]
class ListPaginatedMixin[object]:
def get_context_data[self, **kwargs]:
print 'ListPaginatedMixin'
return super[ListPaginatedMixin,self].get_context_data[**kwargs]
class MyListView[ListSortedMixin, ListPaginatedMixin, Parent]:
def get_context_data[self, **kwargs]:
return super[MyListView,self].get_context_data[**kwargs]
m = MyListView[]
m.get_context_data[l='l']
View Discussion
Improve Article
Save Article
View Discussion
Improve Article
Save Article
Prerequisite: Inheritance in Python
Method overriding is an ability of any object-oriented programming language that allows a subclass or child class to provide a specific implementation of a method that is already provided by one of its super-classes or parent classes. When a method in a subclass has the same name, same parameters or signature and same return type[or sub-type] as a method in its super-class, then the method in the subclass is said to override the method in the super-class.
The version of a method that is executed will be determined by the object that is used to invoke it. If an object of a parent class is used to invoke the method, then the version in the parent class will be executed, but if an object of the subclass is used to invoke the method, then the version in the child class will be executed. In other words, it is the type of the object being referred to [not the type of the reference variable] that determines which version of an overridden method will be executed.
Example:
class
Parent[]:
def
__init__[
self
]:
self
.value
=
"Inside Parent"
def
show[
self
]:
print
[
self
.value]
class
Child[Parent]:
def
__init__[
self
]:
self
.value
=
"Inside Child"
def
show[
self
]:
print
[
self
.value]
obj1
=
Parent[]
obj2
=
Child[]
obj1.show[]
obj2.show[]
Output:
Inside Parent Inside Child
Method overriding with multiple and multilevel inheritance
- Multiple Inheritance: When a class is derived from more than one base class it is called multiple Inheritance.
Example: Let’s consider an example where we want to override a method of one parent class only. Below is the implementation.
class
Parent1[]:
def
show[
self
]:
print
[
"Inside Parent1"
]
class
Parent2[]:
def
display[
self
]:
print
[
"Inside Parent2"
]
class
Child[Parent1, Parent2]:
def
show[
self
]:
print
[
"Inside Child"
]
obj
=
Child[]
obj.show[]
obj.display[]
Output:
Inside Child Inside Parent2
- Multilevel
Inheritance: When we have a child and grandchild relationship.
Example: Let’s consider an example where we want to override only one method of one of its parent classes. Below is the implementation.
class
Parent[]:
def
display[
self
]:
print
[
"Inside Parent"
]
class
Child[Parent]:
def
show[
self
]:
print
[
"Inside Child"
]
class
GrandChild[Child]:
def
show[
self
]:
print
[
"Inside GrandChild"
]
g
=
GrandChild[]
g.show[]
g.display[]
Output:
Inside GrandChild Inside Parent
Calling the Parent’s method within the overridden method
Parent class methods can also be called within the overridden methods. This can generally be achieved by two ways.
- Using Classname: Parent’s class methods can be called by using the
Parent
classname.method
inside the overridden method.Example:
class
Parent[]:
def
show[
self
]:
print
[
"Inside Parent"
]
class
Child[Parent]:
def
show[
self
]:
Parent.show[
self
]
print
[
"Inside Child"
]
obj
=
Child[]
obj.show[]
Output:
Inside Parent Inside Child
- Using
Super[]: Python
super[]
function provides us the facility to refer to the parent class explicitly. It is basically useful where we have to call superclass functions. It returns the proxy object that allows us to refer parent class by ‘super’.Example 1:
class
Parent[]:
def
show[
self
]:
print
[
"Inside Parent"
]
class
Child[Parent]:
def
show[
self
]:
super
[].show[]
print
[
"Inside Child"
]
obj
=
Child[]
obj.show[]
Output:
Inside Parent Inside Child
Example 2:
class
GFG1:
def
__init__[
self
]:
print
[
'HEY !!!!!! GfG I am initialised[Class GEG1]'
]
def
sub_GFG[
self
, b]:
print
[
'Printing from class GFG1:'
, b]
class
GFG2[GFG1]:
def
__init__[
self
]:
print
[
'HEY !!!!!! GfG I am initialised[Class GEG2]'
]
super
[].__init__[]
def
sub_GFG[
self
, b]:
print
[
'Printing from class GFG2:'
, b]
super
[].sub_GFG[b
+
1
]
class
GFG3[GFG2]:
def
__init__[
self
]:
print
[
'HEY !!!!!! GfG I am initialised[Class GEG3]'
]
super
[].__init__[]
def
sub_GFG[
self
, b]:
print
[
'Printing from class GFG3:'
, b]
super
[].sub_GFG[b
+
1
]
if
__name__
=
=
'__main__'
:
gfg
=
GFG3[]
gfg.sub_GFG[
10
]
Output:
HEY !!!!!! GfG I am initialised[Class GEG3] HEY !!!!!! GfG I am initialised[Class GEG2] HEY !!!!!! GfG I am initialised[Class GEG1] Printing from class GFG3: 10 Printing from class GFG2: 11 Printing from class GFG1: 12