Advertisement

---

Top

< Prev

Next >

Like most of the programming languages, Python language also gives us a powerful OOP feature known as inheritance. Inheritance allows us to create a class by inheriting the features of an existing class.

The class that wants to use the features of another class is referred to as the subclass or derived class, whereas the class whose features are to be inherited by another class is referred to as the base class or superclass. Hence, inheritance gives Python the power of reusability.

What features a subclass inherits from its base class, through inheritance?

When a subclass inherits a base class, it inherits all the members of superclass, such as :
• Instance variables of the base class.
• Methods of the base class.

Note - Unlike other programming languages like C++ and Java, Python does not have visibility modes like private/public/protected, hence all the members declared in a class are inherited by its subclass through inheritance.

Syntax of Inheritance

Let us take a look at a general syntax of performing inheritance, using which we could define a derived class which is inheriting a base class.

class derived-class-name(base-class-name):
	#member1 of derived class
	#member2 of dervied class
	.
	.
	.

• To indicate that inheritance is being performed, the keyword class is followed by a space, which is followed by the name of the derived class, followed by a pair of parentheses () enclosing the name of the base class, followed by a colon :
  


• Next, we can define all the members of the derived class with proper indentation.


• The derived-class-name is the name of the derived class, which is being defined and it is going to inherit features of another class i.e. a base class specified with the name base-class-name.

Types of Inheritance in Python

• Single Inheritance - When a class is inheriting a single class.
• Multiple Inheritance - When we a class is inheriting multiple classes(all at once).
• Multilevel Inheritance - When a class inherits the features of multiple classes(one class at a time).

• Example of Single Inheritance


Let us understand how to perform single inheritance by creating a class, which is inheriting the features of another class.

Note : We can access the inherited members of the base claby by using the dot operator, with the object of its derived class.



# Python - Example of single inheritance


# Base class
class X:
    a = 10
    b = 20.6

    # Method of class X
    def method_x(self):
        return 'class X'


	
# Derived class Y, inheriting from the class X
class Y(X):
    i = 30

    # Method of class Y
    def method_y(self):
        return 'class Y'




# Creating an object of class Y
ob_y = Y()


# Using the object of class Y to access the inherited member, a, of class X
print('a = : ', ob_y.a)


# Using the object of class Y to access the inherited member, b, of class X
print('b = : ', ob_y.b)


# Using the object of class Y to access the inherited method, method_x() of class X
print(ob_y.method_x())


# Using the object of class Y to access its own member, i.
print('y = : ', ob_y.i)


# Using the object of class Y to access its own method, method_y()
print(ob_y.method_y())




Output




a = :  10
b = :  20.6
class X
y = :  30
class Y


In the example above, the class named Y has inherited another class named X, which means that the members of class X, such as a, b and method_x() are inherited and have become members in the derived class Y, and finally we have created an object of derived class Y to access not only its own members but also the inherited members of the base class X, by using the dot operator.




Advertisement






• Example of multiple inheritance


Let us understand an example of multiple inheritance by creating a class, which is inheriting the features of multiple classes.

Note: Just like we did in the case of single inheritance, we are going to use the object of a derived class to access the inherited members of its base class by using the dot operator.



# Python - Example of multiple inheritance


# Base class1
class X:
    a = 10
    b = 20.6

    # Method of class X
    def method_x(self):
        return 'class X'

	
	
# Base class2
class Y:
    i = 20

    
    # Method of class Y
    def method_y(self):
        return 'class Y'

	
# Derived class Z, inheriting from class X and class Y
class Z(X,Y):
    j = 30


    # Method of class Z
    def method_z(self):
        return 'class Z'




# Creating an object of class Z
ob_z = Z()


# Using the object of class Z to access the inherited member, a, of class X
print('a = : ', ob_z.a)


# Using the object of class Z to access the inherited member, b, of class X
print('b = : ', ob_z.b)


# Using the object of class Z to access the inherited member, method_x() of class X
print(ob_z.method_x())


# Using the object of class Z to access the inherited member, i, of class Y
print('i = : ', ob_z.i)


# Using the object of class Z to access the inherited member, method_y() of class Y
print(ob_z.method_y())


# Using the object of class Z to access its own member, j
print('j = : ', ob_z.j)


# Using the object of class Z to access its own member, method_z()
print(ob_z.method_z())




Output




a = :  10
b = :  20.6
class X
i = :  20
class Y
j = :  30
class Z


In the example above, we have created the class Z by inheriting from two classes X and Y, which means that the members of base class X, such as a, b and method_x() and the members of base class Y, such as i and method_y() are inherited and have become members in the derived class Z, and finally we have created an object of derived class Z to access its own members and the inherited members of base classes X and Y, by using the dot operator.






• Example of multilevel inheritance


When a class inherits the features of multiple classes(inheriting one class at a time), it is known as multilevel inheritance. Let us understand how to create a class which inherits the feature of two classes(inheriting one class at a time) by performing multiple inheritance.



# Python - Multilevel Inheritance Example

#First Base class
class X:
    x1 = 10
    def get_x1(self):
        return self.x1




# Intermediate base class Y, inheriting from class X
class Y(X):
    y1 = 20
    def get_y1(self):
        return self.y1




# Derived class Z, inheriting the intermediate base class Y
class Z(Y):
    z1 = 30
    def get_z1(self):
        return z1




# Creating an object of derived class
ob = Z()


# Using object of derived class Z, to access an inherited instance variable, x1
print('x1 = : ',ob.x1)


# Using object of derived class Z, to access an inherited method, get_x1()
print('x1 = : ',ob.get_x1())


# Using object of derived class Z, to access an inherited instance variable, y1
print('y1 = : ',ob.y1)


# Using object of derived class Z, to access an inherited method, get_y1()
print('y1 = : ',ob.get_y1())


# Using object of derived class Z, to access its own instance variable, z1
print('z1 = : ',ob.z1)


# Using object of derived class Z, to access its own method, get_z1()
print('z1 = : ',ob.get_z1())




Output




x1 = :  10
x1 = :  10
y1 = :  20
y1 = :  20
z1 = : 30
z1 = : 30


In the example above, we have created the class Z by inheriting from the class Y, which has inherited from the class X, which eventually means that class Z has inherited from two classes X and Y.

Due to this multilevel inheritance, the members of base class X, such as x1 and get_x1() and the members of base class Y, such as y1 and get_y1() are inherited and have become members in the derived class Z, and finally we have created an object of derived class Z to access its own members and the inherited members of base class X and Y by using the dot operator.






Why inheritance is used?



• Inheritance is used to use the existing features of a class.
• Inheritance is also used in a situation when we want to create a more specialized version of a generic(general) class, by using its existing needed features and redefining its general features with some specialized features in the specialized class.

An example

# Python - Example of inheritance


#A general class, Fruit
class Fruit:
    
    def message(self):
        print('This is a fruit')
        
    def fruit_name(self):
        print('Fruit')
        
    def fruit_color(self):
        print('Color')


# A specialized class, Mango inheriting the general class Fruit
class Mango(Fruit):

    # Redefining the inherited general method with a specialized version   
    def fruit_name(self):
        print('Name - Mango')

    # Redefining the inherited general method with a specialized version  
    def fruit_color(self):
        print('Color - Yellow')
    
    def has_seed(self):
        print('Seed - Yes')



# Creating an object of specialized class, Mango
ob= Mango()

# Calling the general method inherited by the specialized class, Mango
ob.message()

# Calling the methods of specialized class, Mango
ob.fruit_name()
ob.fruit_color()
ob.has_seed()





Output -:




This is a fruit
Name - Mango
Color - Yellow
Seed - Yes





Program Analysis



• We have created a specialized class Mango by inheriting a generic(general) class Fruit.
• The class Mango has inherited the general method message() of class Fruit.
• The class Mango has redefined the inherited general methods of class Fruit such as fruit_name() and fruit_color(), to give then a specialized meaning.
• The class Mango has also defined its own unique specialized method has_seed() to display property of a Mango.







Please share this article -






< Prev
Next >
< Python class method
Python super() function >



Advertisement