Polymorphism is one of the core concepts of Object-Oriented Programming (OOP). It allows objects of different classes to be treated as objects of a common superclass. This means you can write code that works on the "interface" rather than the actual "implementation."

In this tutorial, you'll learn:

• What polymorphism is

• How Python implements polymorphism

• Real-world use cases

• Tips and common pitfalls

• A complete example at the end

✅ What is Polymorphism?

Polymorphism means "many forms." In Python, it refers to the ability of different objects to respond to the same method in different ways.

This allows functions, methods, or operators to process objects differently depending on their data type or class.

Types of Polymorphism in Python

Python supports two types of polymorphism:

1. Duck Typing (Dynamic Typing)

2. Method Overriding (Runtime Polymorphism)

Let’s understand both step by step.

1️⃣ Duck Typing (Informal Polymorphism)

Python follows "duck typing" — If it looks like a duck and quacks like a duck, it’s a duck.

You don’t care about the object’s type; you care whether it supports the desired behavior.

Example:

class Dog:
    def speak(self):
        return "Woof!"

class Cat:
    def speak(self):
        return "Meow!"

def animal_sound(animal):
    print(animal.speak())

# Using different objects with the same interface
dog = Dog()
cat = Cat()

animal_sound(dog)  # Output: Woof!
animal_sound(cat)  # Output: Meow!

Here, both Dog and Cat have a speak() method, and we can pass either into animal_sound() — that's duck typing!

2️⃣ Method Overriding (Runtime Polymorphism)

When a subclass provides a specific implementation of a method defined in its superclass, it is method overriding.

Example:

class Animal:
    def move(self):
        print("The animal moves.")

class Bird(Animal):
    def move(self):
        print("The bird flies.")

class Fish(Animal):
    def move(self):
        print("The fish swims.")

def move_animal(animal):
    animal.move()

# Different outputs based on object type
move_animal(Animal())  # Output: The animal moves.
move_animal(Bird())    # Output: The bird flies.
move_animal(Fish())    # Output: The fish swims.

Here, each subclass overrides the move() method in its own way — classic runtime polymorphism.

Operator Overloading (Bonus: Compile-time Polymorphism)

Although Python does not support traditional function overloading, it does support operator overloading.

Example:

print(10 + 5)        # Output: 15 (int addition)
print("Hello " + "World")  # Output: Hello World (string concatenation)

The + operator behaves differently based on the data type — a form of polymorphism!

Complete Code Example

Let’s put it all together with a practical example:

class Employee:
    def work(self):
        raise NotImplementedError("Subclasses must implement this method")

class Developer(Employee):
    def work(self):
        return "Writes code."

class Designer(Employee):
    def work(self):
        return "Designs user interfaces."

class Manager(Employee):
    def work(self):
        return "Manages team."

def perform_work(employee: Employee):
    print(f"{employee.__class__.__name__}: {employee.work()}")

# Create a list of employees
team = [Developer(), Designer(), Manager()]

for member in team:
    perform_work(member)

Output:

Developer: Writes code.
Designer: Designs user interfaces.
Manager: Manages team.

This is an example of polymorphism where each object behaves differently even though the interface (work) is the same.

Tips for Using Polymorphism in Python

• Use abstract base classes to define expected interfaces using the abc module.

• Prefer duck typing for flexible and concise code.

• Use polymorphism to reduce if-else blocks that depend on object types.

• Document your methods well if relying on duck typing, since there's no type enforcement.

⚠️ Common Pitfalls

✅ Summary

Polymorphism in Python helps you write cleaner, more maintainable, and extensible code. Mastering it will make your object-oriented programs more elegant and powerful.