Method Overriding in Python

Any object-oriented programming language can allow a subclass or child class to offer a customized implementation of a method already supplied by one of its superclasses or parent classes. This capability is known as method overriding. The term "override" refers to a method in a subclass that replaces a method in a superclass when both methods share the same name, parameters, signature, and return type (or sub-type).

The object that calls a method will determine which version of the method is executed. When a method is called from an object of a parent class, the method's parent class version is executed; however, when a method is called from an object of a subclass, the child class version is executed. In other words, the version of an overridden method depends on the object being referenced, not the type of the reference variable.

Example:

# program to determine the method overriding
# Defining a parent class
class Parent():
	# producer
	def __init__(self):
		self.value = "Inside Parent"
	# showing a parents method
	def show(self):
		print(self.value)		
# Defining a child class
class Child(Parent):	
	# Constructor
	def __init__(self):
		self.value = "Inside Child"		
	# showing the child's method
	def show(self):
		print(self.value)
# Chauffeur's code
obj1 = Parent()
obj2 = Child()
obj1.show()
obj2.show()

Output:

Inside Parent
Inside Child

Method Overriding with Multilevel and Multiple Inheritance

1. Multiple Inheritance: A class is said to be a multiple inheritance when it is derived from more than one base class.

Example:

Let's look into the below implementation, where we want to override a method using only one parent class.

# program to determine method overriding in multiple inheritances  
# Defining a parent class 1
class Parent1():
    # showing a parent's method
    def show(self):
        print ("Inside Parent1")
 # Defining a Parent Class 2
class Parent2():
    # showing a parent's method
    def display(self):
        print ("Inside Parent2")
# Defining a child class
class Child (Parent1, Parent2):
    #  showing a child's method
    def show(self):
        print ("Inside Child")
obj = Child ()
  obj. show ()
obj. display ()

Output:

Inside Child
Inside Parent2

2. Multilevel Inheritance: A Class is said to be multilevel inheritance if a child and grandchild relationship exists.

Example:

Let's look at an instance where we simply want to override one method from a parent class. The implementation is shown below.

# program to determine method overriding in multilevel inheritance  
class Parent (): 
    #  showing Parent's method
    def display(self):
        print ("Inside Parent")
# subclass 
class Child (Parent): 
    # showing the child's method
    def show(self):
        print ("Inside Child")
# subclass
class GrandChild (Child): 
    # showing the child's method
    def show(self):
        print ("Inside GrandChild")         
g = GrandChild ()   
g.show()
g.display()

Output:

Inside GrandChild
Inside Parent

Within the overridden method, calling the Parent's method

The overridden methods may also invoke methods from the parent class. There are typically two ways to accomplish this.

1. Using Class name: Inside the overridden method, use the Parent classname-method to invoke methods from the Parent's class.

Example:

# program to determine 
# calling the Parent's class method
# In the overridden method
class Parent ():
    def show(self):
        print ("Inside Parent")
class Child (Parent):
    def show(self):
        # child's class method is called
        Parent.show(self)
        Print ("Inside Child")
obj = Child ()
obj. show ()

Output:

Inside Parent
Inside Child

2. Using Super (): The Super () function in Python allows us to refer to the parent class explicitly. It comes in handy when we need to call superclass functions. It gives us the proxy object to use "super" to refer to the parent class.

Example

# Program to determine the Super () function used 
# In multiple inheritances 
class JTP1: 
    def __init__(self): 
        print ('HEY !!!!!! jtpI am initialized (Class JSP1)') 
    def sub_JTP (self, b): 
        print ('Printing from class JTP1:', b) 
# inheritance of JTP2 to JTP1 occurs
class JTP2(JTP1): 
    def __init__(self): 
        print ('HEY !!!!!! JTP I am initialized (Class JSP2)') 
        super().__init__() 
    
    def sub_JTP (self, b): 
        print ('Printing from class JTP2:', b) 
        super (). sub_JTP (b + 1) 
# inheritance of both JTP2 and JTP1 is done by JTP3
class JTP3(JTP2): 
    def __init__(self): 
        print ('HEY !!!!!! JTP I am initialized (Class JSP3)') 
        super().__init__() 
    def sub_JTP (self, b): 
        print ('Printing from class JTP3:', b) 
        super ().sub_JTP(b + 1) 
# function main
if __name__ == '__main__': 
jtp = JTP3() 
jtp.sub_JTP(10)

Output:

HEY  !!!!!! JTP I am initialized (Class JSP3)
HEY  !!!!!! JTP I am initialized (Class JSP2)
HEY  !!!!!! JTP I am initialized (Class JSP1)
Printing from class JTP3: 10
Printing from class JTP3: 11
Printing from class JTP3: 12

Next TopicPyGTK For GUI Programming

← prev next →