Author: saqibkhan

In object-oriented programming, the concept of dynamic binding is closely related to polymorphism. In Python, dynamic binding is the process of resolving a method or attribute at runtime, instead of at compile time.

According to the polymorphism feature, different objects respond differently to the same method call based on their implementations. This behavior is achieved through method overriding, where a subclass provides its implementation of a method defined in its superclass.

The Python interpreter determines which is the appropriate method or attribute to invoke based on the object’s type or class hierarchy at runtime. This means that the specific method or attribute to be called is determined dynamically, based on the actual type of the object.

Example

The following example illustrates dynamic binding in Python −

Open Compiler

classshape:defdraw(self):print("draw method")returnclasscircle(shape):defdraw(self):print("Draw a circle")returnclassrectangle(shape):defdraw(self):print("Draw a rectangle")return

shapes =[circle(), rectangle()]for shp in shapes:
   shp.draw()

It will produce the following output −

Draw a circle
Draw a rectangle

As you can see, the draw() method is bound dynamically to the corresponding implementation based on the object’s type. This is how dynamic binding is implemented in Python.

Duck Typing

Another concept closely related to dynamic binding is duck typing. Whether an object is suitable for a particular use is determined by the presence of certain methods or attributes, rather than its type. This allows for greater flexibility and code reuse in Python.

Duck typing is an important feature of dynamic typing languages like Python (Perl, Ruby, PHP, Javascript, etc.) that focuses on an object’s behavior rather than its specific type. According to the “duck typing” concept, “If it walks like a duck and quacks like a duck, then it must be a duck.”

Duck typing allows objects of different types to be used interchangeably as long as they have the required methods or attributes. The goal is to promote flexibility and code reuse. It is a broader concept that emphasizes object behavior and interface rather than formal types.

Here is an example of duck typing −

Open Compiler

classcircle:defdraw(self):print("Draw a circle")returnclassrectangle:defdraw(self):print("Draw a rectangle")returnclassarea:defarea(self):print("calculate area")returndefduck_function(obj):
   obj.draw()

objects =[circle(), rectangle(), area()]for obj in objects:
   duck_function(obj)

It will produce the following output −

Draw a circle
Draw a rectangle
Traceback (most recent call last):
 File "C:\Python311\hello.py", line 21, in <module>
  duck_function(obj)
 File "C:\Python311\hello.py", line 17, in duck_function
 obj.draw()
AttributeError: 'area' object has no attribute 'draw'

The most important idea behind duck typing is that the duck_function() doesn’t care about the specific types of objects it receives. It only requires the objects to have a draw() method. If an object “quacks like a duck” by having the necessary behavior, it is treated as a “duck” for the purpose of invoking the draw() method.

Thus, in duck typing, the focus is on the object’s behavior rather than its explicit type, allowing different types of objects to be used interchangeably as long as they exhibit the required behavior.

Method overloading is a feature of object-oriented programming where a class can have multiple methods with the same name but different parameters. To overload method, we must change the number of parameters or the type of parameters, or both.

Method Overloading in Python

Unlike other programming languages like Java, C++, and C#, Python does not support the feature of method overloading by default. However, there are alternative ways to achieve it.

Example

If you define a method multiple times as shown in the below code, the last definition will override the previous ones. Therefore, this way of achieving method overloading in Python generates error.

Open Compiler

classexample:defadd(self, a, b):
  x = a+b
  return x
   defadd(self, a, b, c):
  x = a+b+c
  return x
obj = example()print(obj.add(10,20,30))print(obj.add(10,20))

The first call to add() method with three arguments is successful. However, calling add() method with two arguments as defined in the class fails.

60
Traceback (most recent call last):
 File "C:\Users\user\example.py", line 12, in <module>
  print (obj.add(10,20))
     ^^^^^^^^^^^^^^
TypeError: example.add() missing 1 required positional argument: 'c'

The output tells you that Python considers only the latest definition of add() method, discarding the earlier definitions.

To simulate method overloading, we can use a workaround by defining default value to method arguments as None, so that it can be used with one, two or three arguments.

Example

The below example shows how to achieve method overloading in Python −

Open Compiler

classexample:defadd(self, a =None, b =None, c =None):
  x=0if a !=Noneand b !=Noneand c !=None:
     x = a+b+c
  elif a !=Noneand b !=Noneand c ==None:
     x = a+b
  return x
obj = example()print(obj.add(10,20,30))print(obj.add(10,20))

It will produce the following output −

60
30

With this workaround, we are able to incorporate method overloading in Python class.

Implement Method Overloading Using MultipleDispatch

Python’s standard library doesn’t have any other provision for implementing method overloading. However, we can use a dispatch function from a third-party module named MultipleDispatch for this purpose.

First, you need to install the Multipledispatch module using the following command −

pip install multipledispatch

This module has a @dispatch decorator. It takes the number of arguments to be passed to the method to be overloaded. Define multiple copies of add() method with @dispatch decorator as below −

Example

In this example, we are using multipledispatch to overload a method in Python.

from multipledispatch import dispatch
classexample:@dispatch(int,int)defadd(self, a, b):
  x = a+b
  return x
   @dispatch(int,int,int)defadd(self, a, b, c):
  x = a+b+c
  return x
obj = example()print(obj.add(10,20,30))print(obj.add(10,20))

Output

60
30

Method Overriding in Python

The Python method overriding refers to defining a method in a subclass with the same name as a method in its superclass. In this case, the Python interpreter determines which method to call at runtime based on the actual object being referred to.

You can always override your parent class methods. One reason for overriding parent’s methods is that you may want special or different functionality in your subclass.

Example

In the code below, we are overriding a method named myMethod of Parent class.

Open Compiler

# define parent classclassParent:defmyMethod(self):print('Calling parent method')# define child classclassChild(Parent):defmyMethod(self):print('Calling child method')# instance of child
c = Child()# child calls overridden method
c.myMethod()

When the above code is executed, it produces the following output −

Calling child method

To understand Method Overriding in Python, let us take another example. We use following Employee class as parent class −

classEmployee:def__init__(self,nm, sal):
  self.name=nm
  self.salary=sal
   defgetName(self):return self.name
   defgetSalary(self):return self.salary

Next, we define a SalesOfficer class that uses Employee as parent class. It inherits the instance variables name and salary from the parent. Additionally, the child class has one more instance variable incentive.

We shall use built-in function super() that returns reference of the parent class and call the parent constructor within the child constructor __init__() method.

classSalesOfficer(Employee):def__init__(self,nm, sal, inc):super().__init__(nm,sal)
  self.incnt=inc
   defgetSalary(self):return self.salary+self.incnt

The getSalary() method is overridden to add the incentive to salary.

Example

Declare the object of parent and child classes and see the effect of overriding. Complete code is below −

Open Compiler

classEmployee:def__init__(self,nm, sal):
  self.name=nm
  self.salary=sal
   defgetName(self):return self.name
   defgetSalary(self):return self.salary

classSalesOfficer(Employee):def__init__(self,nm, sal, inc):super().__init__(nm,sal)
  self.incnt=inc
   defgetSalary(self):return self.salary+self.incnt

e1=Employee("Rajesh",9000)print("Total salary for {} is Rs {}".format(e1.getName(),e1.getSalary()))
s1=SalesOfficer('Kiran',10000,1000)print("Total salary for {} is Rs {}".format(s1.getName(),s1.getSalary()))

When you execute this code, it will produce the following output −

Total salary for Rajesh is Rs 9000
Total salary for Kiran is Rs 11000

Base Overridable Methods

The following table lists some generic functionality of the object class, which is the parent class for all Python classes. You can override these methods in your own class −

What is Polymorphism in Python?

The term polymorphism refers to a function or method taking different forms in different contexts. Since Python is a dynamically typed language, polymorphism in Python is very easily implemented.

If a method in a parent class is overridden with different business logic in its different child classes, the base class method is a polymorphic method.

Ways of implementing Polymorphism in Python

There are four ways to implement polymorphism in Python −

• Duck Typing
• Operator Overloading
• Method Overriding
• Method Overloading

Learn Python in-depth with real-world projects through our Python certification course. Enroll and become a certified expert to boost your career.

Duck Typing in Python

Duck typing is a concept where the type or class of an object is less important than the methods it defines. Using this concept, you can call any method on an object without checking its type, as long as the method exists.

This term is defined by a very famous quote that states: Suppose there is a bird that walks like a duck, swims like a duck, looks like a duck, and quaks like a duck then it probably is a duck.

Example

In the code given below, we are practically demonstrating the concept of duck typing.

Open Compiler

classDuck:defsound(self):return"Quack, quack!"classAnotherBird:defsound(self):return"I'm similar to a duck!"defmakeSound(duck):print(duck.sound())# creating instances
duck = Duck()
anotherBird = AnotherBird()# calling methods
makeSound(duck)   
makeSound(anotherBird)

When you execute this code, it will produce the following output −

Quack, quack!
I'm similar to a duck!

Method Overriding in Python

In method overriding, a method defined inside a subclass has the same name as a method in its superclass but implements a different functionality.

Example

As an example of polymorphism given below, we have shape which is an abstract class. It is used as parent by two classes circle and rectangle. Both classes override parent’s draw() method in different ways.

Open Compiler

from abc import ABC, abstractmethod
classshape(ABC):@abstractmethoddefdraw(self):"Abstract method"returnclasscircle(shape):defdraw(self):super().draw()print("Draw a circle")returnclassrectangle(shape):defdraw(self):super().draw()print("Draw a rectangle")return

shapes =[circle(), rectangle()]for shp in shapes:
   shp.draw()

Output

When you run the above code, it will produce the following output −

Draw a circle
Draw a rectangle

The variable shp first refers to circle object and calls draw() method from circle class. In next iteration, it refers to rectangle object and calls draw() method from rectangle class. Hence draw() method in shape class is polymorphic.

Overloading Operators in Python

Suppose you have created a Vector class to represent two-dimensional vectors, what happens when you use the plus operator to add them? Most likely Python will yell at you.

You could, however, define the __add__ method in your class to perform vector addition and then the plus operator would behave as per expectation −

Example

Open Compiler

classVector:def__init__(self, a, b):
  self.a = a
  self.b = b
   def__str__(self):return'Vector (%d, %d)'%(self.a, self.b)def__add__(self,other):return Vector(self.a + other.a, self.b + other.b)

v1 = Vector(2,10)
v2 = Vector(5,-2)print(v1 + v2)

When the above code is executed, it produces the following result −

Vector(7,8)

Method Overloading in Python

When a class contains two or more methods with the same name but different number of parameters then this scenario can be termed as method overloading.

Python does not allow overloading of methods by default, however, we can use the techniques like variable-length argument lists, multiple dispatch and default parameters to achieve this.

Example

In the following example, we are using the variable-length argument lists to achieve method overloading.

Open Compiler

defadd(*nums):returnsum(nums)# Call the function with different number of parameters
result1 = add(10,25)
result2 = add(10,25,35)print(result1)print(result2)

When the above code is executed, it produces the following result −

35
70

What is Inheritance in Python?

Inheritance is one of the most important features of object-oriented programming languages like Python. It is used to inherit the properties and behaviours of one class to another. The class that inherits another class is called a child class and the class that gets inherited is called a base class or parent class.

If you have to design a new class whose most of the attributes are already well defined in an existing class, then why redefine them? Inheritance allows capabilities of existing class to be reused and if required extended to design a new class.

Inheritance comes into picture when a new class possesses ‘IS A’ relationship with an existing class. For example, Car IS a vehicle, Bus IS a vehicle, Bike IS also a vehicle. Here, Vehicle is the parent class, whereas car, bus and bike are the child classes.

Creating a Parent Class

The class whose attributes and methods are inherited is called as parent class. It is defined just like other classes i.e. using the class keyword.

Syntax

The syntax for creating a parent class is shown below −

classParentClassName:{classbody}

Learn Python in-depth with real-world projects through our Python certification course. Enroll and become a certified expert to boost your career.

Creating a Child Class

Classes that inherit from base classes are declared similarly to their parent class, however, we need to provide the name of parent classes within the parentheses.

Syntax

Following is the syntax of child class −

classSubClassName(ParentClass1[, ParentClass2,...]):{sub classbody}

Types of Inheritance

In Python, inheritance can be divided in five different categories −

• Single Inheritance
• Multiple Inheritance
• Multilevel Inheritance
• Hierarchical Inheritance
• Hybrid Inheritance

Python – Single Inheritance

This is the simplest form of inheritance where a child class inherits attributes and methods from only one parent class.

Example

The below example shows single inheritance concept in Python −

Open Compiler

# parent classclassParent:defparentMethod(self):print("Calling parent method")# child classclassChild(Parent):defchildMethod(self):print("Calling child method")# instance of child
c = Child()# calling method of child class
c.childMethod()# calling method of parent class
c.parentMethod()

On running the above code, it will print the following result −

Calling child method
Calling parent method

Python – Multiple Inheritance

Multiple inheritance in Python allows you to construct a class based on more than one parent classes. The Child class thus inherits the attributes and method from all parents. The child can override methods inherited from any parent.

Syntax

classparent1:#statementsclassparent2:#statementsclasschild(parent1, parent2):#statements

Example

Python’s standard library has a built-in divmod() function that returns a two-item tuple. First number is the division of two arguments, the second is the mod value of the two operands.

This example tries to emulate the divmod() function. We define two classes division and modulus, and then have a div_mod class that inherits them.

classdivision:def__init__(self, a,b):
  self.n=a
  self.d=b
   defdivide(self):return self.n/self.d
classmodulus:def__init__(self, a,b):
  self.n=a
  self.d=b
   defmod_divide(self):return self.n%self.d
  
classdiv_mod(division,modulus):def__init__(self, a,b):
  self.n=a
  self.d=b
   defdiv_and_mod(self):
  divval=division.divide(self)
  modval=modulus.mod_divide(self)return(divval, modval)</code></pre>


The child class has a new method div_and_mod() which internally calls the divide() and mod_divide() methods from its inherited classes to return the division and mod values.



x=div_mod(10,3)print("division:",x.divide())print("mod_division:",x.mod_divide())print("divmod:",x.div_and_mod())



Output



division: 3.3333333333333335
mod_division: 1
divmod: (3.3333333333333335, 1)




Method Resolution Order (MRO)



The term method resolution order is related to multiple inheritance in Python. In Python, inheritance may be spread over more than one levels. Let us say A is the parent of B, and B the parent for C. The class C can override the inherited method or its object may invoke it as defined in its parent. So, how does Python find the appropriate method to call.



Each Python has a mro() method that returns the hierarchical order that Python uses to resolve the method to be called. The resolution order is from bottom of inheritance order to top.



In our previous example, the div_mod class inherits division and modulus classes. So, the mro method returns the order as follows −



[<class'__main__.div_mod'>,<class'__main__.division'>,<class'__main__.modulus'>,<class'object'>]



Python - Multilevel Inheritance



In multilevel inheritance, a class is derived from another derived class. There exists multiple layers of inheritance. We can imagine it as a grandparent-parent-child relationship.



Example



In the following example, we are illustrating the working of multilevel inheritance.



Open Compiler



# parent classclassUniverse:defuniverseMethod(self):print("I am in the Universe")# child classclassEarth(Universe):defearthMethod(self):print("I am on Earth")# another child classclassIndia(Earth):defindianMethod(self):print("I am in India")# creating instance 
person = India()# method calls
person.universeMethod() 
person.earthMethod() 
person.indianMethod()



When we execute the above code, it will produce the following result −



I am in the Universe
I am on Earth
I am in India




Python - Hierarchical Inheritance



This type of inheritance contains multiple derived classes that are inherited from a single base class. This is similar to the hierarchy within an organization.



Example



The following example illustrates hierarchical inheritance. Here, we have defined two child classes of Manager class.



Open Compiler



# parent classclassManager:defmanagerMethod(self):print("I am the Manager")# child classclassEmployee1(Manager):defemployee1Method(self):print("I am Employee one")# second child classclassEmployee2(Manager):defemployee2Method(self):print("I am Employee two")# creating instances 
emp1 = Employee1()  
emp2 = Employee2()# method calls
emp1.managerMethod() 
emp1.employee1Method()
emp2.managerMethod() 
emp2.employee2Method()



On executing the above program, you will get the following output −



I am the Manager
I am Employee one
I am the Manager
I am Employee two




Python - Hybrid Inheritance



Combination of two or more types of inheritance is called as Hybrid Inheritance. For instance, it could be a mix of single and multiple inheritance.



Example



In this example, we have combined single and multiple inheritance to form a hybrid inheritance of classes.



Open Compiler



# parent classclassCEO:defceoMethod(self):print("I am the CEO")classManager(CEO):defmanagerMethod(self):print("I am the Manager")classEmployee1(Manager):defemployee1Method(self):print("I am Employee one")classEmployee2(Manager, CEO):defemployee2Method(self):print("I am Employee two")# creating instances 
emp = Employee2()# method calls
emp.managerMethod() 
emp.ceoMethod()
emp.employee2Method()



On running the above program, it will give the below result −



I am the Manager
I am the CEO
I am Employee two




The super() function



In Python, super() function allows you to access methods and attributes of the parent class from within a child class.



Example



In the following example, we create a parent class and access its constructor from a subclass using the super() function.



Open Compiler



# parent classclassParentDemo:def__init__(self, msg):
  self.message = msg
   defshowMessage(self):print(self.message)# child classclassChildDemo(ParentDemo):def__init__(self, msg):# use of super functionsuper().__init__(msg)# creating instance
obj = ChildDemo("Welcome to Tutorialspoint!!")
obj.showMessage()



On executing, the above program will give the following result −



Welcome to Tutorialspoint!!