Python is a high level general purpose programming language which has a clear/easy learning curve. Python programming language is massively used in various domains like Artificial Intelligence, Data Science, Web Development, Utilities Tools and Scripts and many more
Python is a Programming language, and the default Python we use is written in C programming language which is also referred to as CPython (Python implementation in C). There are various implementation of Python Programming language i.e Jython(in JAVA), Skulpt(in JS) e.t.c
To make everything easy: We refer CPython as Python
The word polymorphism represents having multiple forms. In OOP, polymorphism means a same-named method can have multiple behaviors or signatures.
The same function or method can perform multiple tasks. In software development, the concept of polymorphism is very important.Example1
Here, a multiply function is used to multiply two numbers as well as three numbers. So, it is showing multiple properties.
def multiply(a,b,c=1): print(a*b*c) multiply(1,2,1) multiply(2,3)
Let us create two classes having similar method names. Also, create a common interface for getting the multiple forms of the same methods.
class Cat: def sound(self): print("A cat is meowing.") class Dog: def sound(self): print("A dog is barking.") def check_polymorphism(obj): obj.sound() cat1=Cat() dog1=Dog() check_polymorphism(cat1) check_polymorphism(dog1)
Here, in both classes, there is a common method which is sound. This sound method shows polymorphism for two objects of different classes.Output
Duck Typing in Python
A cat is meowing. A dog is barking.
It is the implementation of polymorphism where the type or the class of an object is less important than the method it defines.
For example, if a bird walks like a duck, quacks like a duck, swims like a duck, then any bird is a duck. So, in duck typing, the class of the object does not matter.
If the methods of two completely different classes are the same then both are taken as the same.Example
In the example, There are two classes having similar behavior following the duck typing concept.
class PyCharm: def execute(self): print("Compiling..") print("Running...") print("In pycharm...") class OwnEditor: def execute(self): print("Spell check.") print("Convention check.") print("Compiling..") print("Running......") print("In my own editor\n\n") class Laptop: def code(self,ide): ide.execute() ide1=OwnEditor() ide2=PyCharm() lap1=Laptop() lap1.code(ide1) lap1.code(ide2)
Spell check. Convention check. Compiling.. Running...... In my own editor
Basically, operators have it's own predefined meaning and task. Any operators perform their tasks based on what they are pre-defined to do.
For example, the '+' operator is used to add two integers. Also, this is used to concatenate two strings. When we type num1+num2, behind the scene, integer class calls for __add__() method.Example
>>>2+3 5 >>>2*3 6
Same thing can be done with following way.
>>>int.__add__(2,3) 5 >>>int.__mul__(2,3) 6
We are able to add and multiply two integers here because class 'int' belongs __add__() and __mul__() methods which are being called when we simply type '+' and '*'. behind the scene.
What if we try to add and multiply the object in our own classes? The simple answer is we will get an error as follows.
class StudentMark: def __init__(self, mark1, mark2): self.mark1=mark1 self.mark2=mark2 student_mark1=StudentMark(50,35) student_mark2=StudentMark(40,60) print(student_mark1+student_mark2)
print(student_mark1+student_mark2) TypeError: unsupported operand type(s) for +: 'StudentMark' and 'StudentMark'
Here we got an error as above because our own class StudentMark doesn't have the method to call an operator. In this situation, operator overloading comes into the picture. We define operator ourselves for our own class object as follows.
class Number: def __init__(self, num): self.num=mark1 def __add__(self,other): return self.num+other.num num1=Number(100) num1=Number(200) result=num1+num1 print(result)
If Class is having multiple methods with the same name, then it is called method overloading. By default, Python does not support method overloading but there are several methods to achieve it.
In python, if we try to implement method overloading, we can only use the method which is most latest.Example
def Hello(): print("Hello World>>1!") def Hello(): print("Hello World>>2!") def Hello(): print("Hello World>>3!") hello()
Hello World>>3! #last one is printed.
To implement method overloading, we can use Multiple Dispatch Decorator as follows: It can be installed by the following command.
pip3 install multipledispatch
from multipledispatch import dispatch class CalculateSum: @dispatch(int, int) def sum(num1,num2): return num1+num2 @dispatch(int,int,int) def sum(num1,num2,num3): return num1+num2+num3 @dispatch(str,str,str) def sum(str1,str2,str3): return str1+str2+str3 test1=CalculateSum() sum1=test1.sum(2,3) sum2=test1.sum(1,2,3) sum3=test1.sum("Hello ","Python ","TheRighWay!") print(sum1) print(sum2) print(sum3)
5 6 Hello PythonTheRightWay!
So, using dispatch decorator we are able to use method overloading in python efficiently.Method Overriding
Method overriding is the concept in OOP in which a method of sub-class or child-class overrides the method of parent-class.
In another word, Overriding is the property of a class to change the implementation of a method provided by one of its base classes.
In inheritance, a child class can access the methods and attributes of the inherited parent class. For example, let us consider, A parent-class has a method X() which class is being inherited by class B. Now, sub-class B can access X() method. Also, if B sub-class which is inheriting parent-class A creates the same method X() with the same arguments and same signature then it is called as method X() of sub-class B is overriding the X() method of parent-class B.Example
In inheritance, a subclass accesses its parent class's methods.
class A: def show(): print("In class A.") class B(A): pass obj=B() obj.show()
In class A.
After implementation of method overriding, sub-class uses its own class even when sub-class is inheriting parent-class. That means a method of sub-class is overriding the method of parent-class.
class A: def show(): print("In class A.") class B(A): def show(): print("In class B.") obj=B() obj.show()
In class B.