Like C++, a class can be derived from more than one base classes in Python. This is called multiple inheritance.
In multiple inheritance, the features of all the base classes are inherited into the derived class. The syntax for multiple inheritance is similar to single inheritance.
class Base1: pass class Base2: pass class MultiDerived(Base1, Base2): pass
Here, MultiDerived is derived from classes Base1 and Base2.
MultiDerived inherits from both
On the other hand, we can also inherit from a derived class. This is called multilevel inheritance. It can be of any depth in Python.
In multilevel inheritance, features of the base class and the derived class is inherited into the new derived class.
An example with corresponding visualization is given below.
class Base: pass class Derived1(Base): pass class Derived2(Derived1): pass
Here, Derived1 is derived from Base, and Derived2 is derived from Derived1.
Every class in Python is derived from the class
object. It is the most base type in Python.
So technically, all other class, either built-in or user-defines, are derived classes and all objects are instances of
# Output: True print(issubclass(list,object)) # Output: True print(isinstance(5.5,object)) # Output: True print(isinstance("Hello",object))
In the multiple inheritance scenario, any specified attribute is searched first in the current class. If not found, the search continues into parent classes in depth-first, left-right fashion without searching same class twice.
So, in the above example of
MultiDerived class the search order is [
object]. This order is also called linearization of
MultiDerived class and the set of rules used to find this order is called Method Resolution Order (MRO).
MRO must prevent local precedence ordering and also provide monotonicity. It ensures that a class always appears before its parents and in case of multiple parents, the order is same as tuple of base classes.
MRO of a class can be viewed as the
__mro__ attribute or
mro() method. The former returns a tuple while latter returns a list.
>>> MultiDerived.__mro__ (<class '__main__.MultiDerived'>, <class '__main__.Base1'>, <class '__main__.Base2'>, <class 'object'>) >>> MultiDerived.mro() [<class '__main__.MultiDerived'>, <class '__main__.Base1'>, <class '__main__.Base2'>, <class 'object'>]
Here is a little more complex multiple inheritance example and its visualization along with the MRO.
class X: pass class Y: pass class Z: pass class A(X,Y): pass class B(Y,Z): pass class M(B,A,Z): pass # Output: # [<class '__main__.M'>, <class '__main__.B'>, # <class '__main__.A'>, <class '__main__.X'>, # <class '__main__.Y'>, <class '__main__.Z'>, # <class 'object'>] print(M.mro())
Refer to this, for further discussion on MRO and to know the actual algorithm how it is calculated.