Python

Polymorphism in Python

What is Polymorphism in Python?

Polymorphism in Python refers to the ability of different objects to respond to the same method or function in different ways. It is derived from the Greek words “poly” (many) and “morph” (forms), meaning “many forms.” This object-oriented programming concept allows functions and methods to operate on objects of different types, enhancing flexibility and extensibility in your code.

Core Principles of Polymorphism in Python

Same interface, different behavior
Encourages code reusability
Enables extensibility and maintainability
Often implemented using inheritance or duck typing

Types of Polymorphism in Python

1. Duck Typing

Python uses a concept known as duck typing—"If it looks like a duck and quacks like a duck, it must be a duck." This means that Python cares more about whether an object behaves a certain way rather than its actual type.


class Dog:

    def speak(self):

        return "Woof!"

class Cat:

    def speak(self):

        return "Meow!"

def make_sound(animal):

    print(animal.speak())

dog = Dog()

cat = Cat()

make_sound(dog)

make_sound(cat)

Explanation: The make_sound() function can accept any object that has a speak() method, regardless of its actual class. This is a perfect demonstration of polymorphism in Python using duck typing.

2. Method Overriding (Runtime Polymorphism)

Method overriding occurs when a subclass defines a method that is already defined in its parent class. The overridden method in the child class is called at runtime, not the parent class’s method.


class Animal:

    def speak(self):

        print("Some generic sound")

class Dog(Animal):

    def speak(self):

        print("Woof!")

class Cat(Animal):

    def speak(self):

        print("Meow!")

animals = [Dog(), Cat(), Animal()]

for animal in animals:

    animal.speak()

Explanation: Despite using the same method name speak(), each class has a different implementation. Python determines at runtime which method to invoke based on the object type.

3. Operator Overloading

Operator overloading is another example of polymorphism in Python. It allows built-in operators to have different behavior depending on the operands.


class Book:

    def __init__(self, pages):

        self.pages = pages

    def __add__(self, other):

        return self.pages + other.pages

book1 = Book(150)

book2 = Book(200)

print(book1 + book2) # Output: 350

Explanation: The + operator is overloaded using the __add__ method, allowing us to sum the pages of two book objects.

Why Use Polymorphism in Python?

Improves code readability: Common interfaces reduce redundancy
Supports scalability: Easily add new classes with shared interfaces
Facilitates maintenance: Central logic is easier to manage and debug
Enables flexible design: You can write general-purpose functions and methods

Real-World Applications of Polymorphism in Python

1. GUI Event Handling

Buttons, checkboxes, and sliders may all call a generic event handler function that is polymorphic in behavior.

2. Game Development

Game characters (enemies, players, NPCs) can use the same method names for different actions like attack() or move().

3. File Processing

Different file formats (JSON, CSV, XML) can be read with a common read() method, with format-specific behavior inside the implementation.

Best Practices When Using Polymorphism in Python

Use interfaces and base classes to define expected behaviors
Avoid overcomplicating code with unnecessary polymorphic behavior
Use duck typing with caution and proper documentation
Take advantage of Python’s built-in features like magic methods