Polymorphism

Polymorphism = ability of object of different types to be handled by a common interface. This means a method of a class can do different things in subclasses. Python has duck typing polymorphism or sub type polymorphism.
Polymorphism = Because derived objects share the same interface as their parents, the calling code can call any function in that class’ interface. At run-time, the appropriate function will be called depending on the type of object passed leading to possibly different behaviors.

# Sub-type polymorphism (via. inheritance) 
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
    print animal.name + ': ' + animal.talk()

Ad-hoc polymorphism (Overloading) is also known as function overloading, we use typing in order to resolve which function will be invoked. We may have two functions, both called fn, where one accepts an int parameter, while the other accepts a String parameter, and the right function to invoke is chosen based on the type of parameter being passed.
Parametric Polymorphism - generics and type inference (C++) using Template
Sub-type polymorphism (via. inheritance) - In python mostly used. In polymorphism we see subclass (Cat and Dog) inheriting from the parent class (Animal) and overriding the method Talk.
Duck typing - In case of duck typing we don’t create a subclass instead new class is created with method having same name but different function. Duck typing with modules.

Duck Typing = where the type or the class of an object is less important than the methods it defines. When you use duck typing, you do not check types at all. Instead, you check for the presence of a given method or attribute

In polymorphism we see subclass (Cat and Dog) inheriting from the parent class (Animal) and overriding the method Talk.
In case of duck typing we don’t create a subclass instead new class is created with method having same name but different function.

class Duck:
    def quack(self):
        print("Quaaaaaack!")
    def feathers(self):
        print("The duck has white and gray feathers.")
    def name(self):
        print("ITS A DUCK NO NAME")


class Person:
    def quack(self):
        print("The person imitates a duck.")
    def feathers(self):
        print("The person takes a feather from the ground and shows it.")
    def name(self):
        print("John Smith")

def in_the_forest(duck):
    duck.quack()
    duck.feathers()
    duck.name()

def game():
    for element in [Duck(), Person()]:
        in_the_forest(element)

game()

References