what is the practical use of polymorphism in Python

Question

I understand the concept of polymorphism but how can I apply it while coding? Can anyone tell me the practical usage of it.

Answer 1

Polymorphism is the ability to present the same interface for differing underlying forms. In practical terms, polymorphism means that if class B inherits from class A, it doesn’t have to inherit everything about class A, it can do some of the things that class A does differently. It is most commonly used while dealing with inheritance. Python is implicitly polymorphic, it has the ability to overload standard operators so that they have appropriate behaviour based on their context.

Refer the below example:

class Animal:

    def __init__(self,name):

        self.name=name

        def talk(self):

            pass

class Dog(Animal):

            def talk(self):

                print('Woof')

class Cat(Animal):

    def talk(self):

        print('MEOW!')

c= Cat('kitty')

c.talk()

d=Dog(Animal)

d.talk()

Output - 

Meow!

Woof

Answer 2

Check the Wikipedia example: it is very helpful at a high level:

class Animal:
    def __init__(self, name):    # Constructor of the class
        self.name = name
    def talk(self):              # Abstract method, defined by convention only
        raise NotImplementedError("Subclass must implement abstract method")

class Cat(Animal):
    def talk(self):
        return 'Meow!'

class Dog(Animal):
    def talk(self):
        return 'Woof! Woof!'

animals = [Cat('Missy'),
           Cat('Mr. Mistoffelees'),
           Dog('Lassie')]

for animal in animals:
    print animal.name + ': ' + animal.talk()

# prints the following:
#
# Missy: Meow!
# Mr. Mistoffelees: Meow!
# Lassie: Woof! Woof!

Notice the following: all animals "talk", but they talk differently. The "talk" behaviour is thus polymorphic in the sense that it is realized differently depending on the animal. So, the abstract "animal" concept does not actually "talk", but specific animals (like dogs and cats) have a concrete implementation of the action "talk".

Similarly, the "add" operation is defined in many mathematical entities, but in particular cases you "add" according to specific rules: 1+1 = 2, but (1+2i)+(2-9i)=(3-7i).

Polymorphic behaviour allows you to specify common methods in an "abstract" level, and implement them in particular instances.

For your example:

class Person(object):
    def pay_bill():
        raise NotImplementedError

class Millionare(Person):
    def pay_bill():
        print "Here you go! Keep the change!"

class GradStudent(Person):
    def pay_bill():
        print "Can I owe you ten bucks or do the dishes?"

You see, millionares and grad students are both persons. But when it comes to paying a bill, their specific "pay the bill" action is different.

Answer 3

class Pesron:
    def __init__(self,name,age):
        self.name=name
        self.age=age

class Emp(Pesron):
    def __init__(self,name,age,eno,esal):
        super().__init__(name,age)
        self.eno=eno
        self.esal=esal


    def display(self):
       print("employee Name is :",self.name)
       print("employee Age is :", self.age)
       print("employee NO is :", self.eno)
       print("employee Salary is :", self.esal)

e=Emp("satish",24,101,35000)
e.display()
e=Emp("sunil",27,102,40000)
e.display()

OUTPUT

employee Name is : satish
employee Age is : 24
employee NO is : 101
employee Salary is : 35000
employee Name is : sunil
employee Age is : 27
employee NO is : 102
employee Salary is : 40000