If you are like most Python programmers, you have probably heard of multiple inheritance, but you may not know exactly how it works. Multiple Inheritance in Python is a powerful mechanism for code reuse. It allows you to write more flexible and DRY code by inheriting from one or more classes instead of creating new ones from scratch.
In Python, multiple inheritance is a powerful feature that allows you to inherit one class’s properties and methods from another. This article will show you how to use Multiple Inheritance in Python and give a few examples to help you understand how it works. By the end, you will be able to understand how multiple inheritance can be used to create complex classes that behave like simple ones. So let us get started.
Table of Contents
What is Multiple Inheritance?
Multiple inheritance is a feature of object-oriented programming that allows multiple classes to inherit from the same parent class. This enables related code to be centralized in one place and makes it easy for different parts of your application to share common functionality.
Python Multi-Level Inheritance
Python multi-level inheritance is a programming construct that allows you to extend a class or subclass of a given type by adding another level of hierarchy. Each additional level in the hierarchy inherits all the properties and methods from the parent level but may also add new ones. This allows you to create complex structures that are easy to understand and maintain.
class Bear_Family:
def show_family(self):
print("Its a Bear Fam:")
class Papa_Bear(Bear_Family):
fathername = ""
def show_father(self):
print(self.fathername)
class Mama_Bear(Bear_Family):
mothername = ""
def show_mother(self):
print(self.mothername)
class baby_bear(Papa_Bear,Mama_Bear):
def show_parent(self):
print("Father :", self.fathername)
print("Mother :", self.mothername)
b1 = baby_bear()
b1.fathername = "david"
b1.mothername = "natasha"
b1.show_family()
b1.show_parent() Output
Multiple Inheritance in Python
Python multiple inheritance is a feature of the Python programming language that allows you to inherit from multiple classes simultaneously. This can be helpful when it comes to structuring your code in a modular and reusable way.
class dog:
def bark(self):
print('barking')
class puppy:
def pup(self):
print('pupping')
class dogFam(puppy, dog):
pass
if __name__ == '__main__':
df = dogFam()
df.bark()
df.pup() Output
Built-in Inheritance Class Method
The built-in inheritance method in Python allows you to create a subclass of an existing class. This is useful when you want to add additional functionality or replace the default behavior of an existing class. To use the built-in inheritance method, first you need to create a new class that inherits from the original class. Then, you can define any methods that you want to include in your new subclass. Following are the built-in methods of multiple inheritance in Python:
- Issub class
- Isinstance class
The issub Class Method
The relationships between the given classes are checked using the issubclass(sub, sup) method. If the first class is a subclass of the second it returns true; otherwise, it returns false.
class Cal1:
def addition(self,a,b):
return a+b;
class Cal2:
def subtraction(self,a,b):
return a-b;
class Derived(Cal1,Cal2):
def multiply(self,a,b):
return a*b;
d = Derived()
print(issubclass(Derived,Cal2))
print(issubclass(Cal1,Cal2)) Output
The isinstance Class Method
The isinstance() method in Python enables you to determine if the objects and classes are related or not. For example, if the first argument is an instance of the second argument, i.e., class, it returns true.
class Cal1:
def addition(self,a,b):
return a+b;
class Cal2:
def subtract(self,a,b):
return a-b;
class Derived(Cal1,Cal2):
def multiply(self,a,b):
return a*b;
d = Derived()
print(isinstance(d,Derived)) Output
The Super( ) Function
The super function is a built-in module in the Python programming language that allows you to access functions and methods of other classes from within your own class. This can be useful for extending or modifying functionality of existing classes, or for creating new classes with specific functionalities.
class grandfather:
def m(self):
print("mother")
class grandmother(grandfather):
def m(self):
print("grandmother")
super().m()
class father(grandfather):
def m(self):
print("father")
super().m()
class mother(grandmother, father):
def m(self):
print("grandfather")
super().m()
obj = mother()
obj.m() Output
Method Overriding
When dealing with multiple inheritance, Python Method overriding can be a helpful tool. It allows you to override methods in subclasses without having to write the same code twice.
class human:
def eye_color(self):
print("color")
class girl(human):
def eye_color(self):
print("honey colored")
g = girl()
g.eye_color() Output
Also learn the basic concepts of Python Object Oriented Programming.
Method Resolution Order
Python uses the method resolution order (MRO) to search for the appropriate method to invoke when the parent classes have methods with the same name, and the child class invokes them. If a specific attribute is not found in the current class, it has been looked for in the parent classes before being looked for in multiple inheritance. Each class is examined once, starting with the parent classes on the left.
class grandfather:
def m(self):
print("mother")
class grandmother(grandfather):
def m(self):
print("grandmother")
super().m()
class father(grandfather):
def m(self):
print("father")
super().m()
class mother(grandmother, father):
def m(self):
print("grandfather")
super().m()
print(mother.mro())
print(mother.__mro__) Output
Diamond Problem
Diamond problem in multiple inheritance occurs when a class has more than one parent. This can cause problems if the parents have different properties or methods, and this could lead to inconsistency in the behavior of instances of the class.
FAQs
What are the limitations of multiple inheritance?
- Objects inherited from a parent class can only have one direct or indirect superclass. This means you cannot create an object combining two classes.
- When an object is created via multiple inheritance, the corresponding base classes must all be defined before any instances of those classes can be created.
What is the difference between multiple inheritance and multilevel inheritance?
When a class inherits from numerous base classes, that is referred to as Multiple Inheritance, whereas when a class inherits from a derived class and creates that derived class as a base class for the next one, it is referred to as Multilevel Inheritance. In comparison to multiple inheritance, multilevel inheritance is more common.
Conclusion
Multiple inheritance in Python can sometimes be confusing, but with this article, you now have everything you need to know about how it works. For example, writing multiple inheritance can help reduce duplicated efforts and increase productivity. Now that you know all about multiple inheritance, we hope it will not be too hard to keep your code organized and clean. Just be careful since it can lead to unexpected errors if not implemented properly. Thanks for reading.
