Mastering Inheritance in Python: Multiple and Multilevel Techniques

Unlock the Power of Inheritance in Python

The Magic of Multiple Inheritance

Imagine creating a class that can inherit traits from multiple superclasses. In Python, this is possible through multiple inheritance. For instance, a Bat class can inherit characteristics from both Mammal and WingedAnimal classes, making it a true hybrid.

The Syntax of Multiple Inheritance

To create a class that inherits from multiple superclasses, simply separate the superclass names with commas. For example:

class MultiDerived(SuperClass1, SuperClass2):
pass

Putting Multiple Inheritance into Practice

Let’s see how this works with an example:
“`
class Mammal:
def mammal_info(self):
print(“I’m a mammal!”)

class WingedAnimal:
def wingedanimalinfo(self):
print(“I have wings!”)

class Bat(Mammal, WingedAnimal):
pass

b1 = Bat()
b1.mammalinfo() # Output: I’m a mammal!
b1.wingedanimal_info() # Output: I have wings!
“`
The Next Level: Multilevel Inheritance

But Python’s inheritance capabilities don’t stop there. You can also create a class that inherits from another derived class, a concept known as multilevel inheritance.

The Syntax of Multilevel Inheritance

The syntax is similar to multiple inheritance, with each derived class building upon the previous one:
“`
class DerivedClass1(SuperClass):
pass

class DerivedClass2(DerivedClass1):
pass
“`
A Real-World Example of Multilevel Inheritance

Let’s see how this works in practice:
“`
class SuperClass:
def super_method(self):
print(“I’m the superclass!”)

class DerivedClass1(SuperClass):
def derived_method1(self):
print(“I’m the first derived class!”)

class DerivedClass2(DerivedClass1):
def derived_method2(self):
print(“I’m the second derived class!”)

d2 = DerivedClass2()
d2.supermethod() # Output: I’m the superclass!
d2.derivedmethod1() # Output: I’m the first derived class!
d2.derived_method2() # Output: I’m the second derived class!
“`
Method Resolution Order (MRO): The Secret to Inheritance Success

But what happens when multiple superclasses have the same method name? Python uses the Method Resolution Order (MRO) to determine which method to call. The MRO specifies that methods should be inherited from the leftmost superclass first.

Understanding MRO in Action

Let’s see an example of MRO in action:
“`
class SuperClass1:
def info(self):
print(“I’m SuperClass1!”)

class SuperClass2:
def info(self):
print(“I’m SuperClass2!”)

class Derived(SuperClass1, SuperClass2):
pass

d1 = Derived()
d1.info() # Output: I’m SuperClass1!
“
In this case, the MRO dictates that theinfo()method fromSuperClass1is called first, rather than the one fromSuperClass2`.