Python Polymorphism – One Interface, Many Implementations

Method Overriding

A subclass can override a parent method to change its behaviour.

class Animal:
    def speak(self):
        return "..."

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

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

class Duck(Animal):
    def speak(self):
        return "Quack!"

animals = [Dog(), Cat(), Duck()]
for animal in animals:
    print(animal.speak())   # Each responds differently

Duck Typing

"If it walks like a duck and quacks like a duck, it's a duck." Python doesn't require inheritance — any object with the right method works.

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

class Robot:
    def speak(self): return "Beep boop!"

class Human:
    def speak(self): return "Hello!"

# No shared base class needed!
entities = [Dog(), Robot(), Human()]
for e in entities:
    print(e.speak())

Polymorphism with Abstract Methods

Use ABC to enforce that subclasses implement required methods.

from abc import ABC, abstractmethod
import math

class Shape(ABC):
    @abstractmethod
    def area(self): ...

    @abstractmethod
    def perimeter(self): ...

class Circle(Shape):
    def __init__(self, r): self.r = r
    def area(self): return math.pi * self.r**2
    def perimeter(self): return 2 * math.pi * self.r

class Square(Shape):
    def __init__(self, s): self.s = s
    def area(self): return self.s**2
    def perimeter(self): return 4 * self.s

for shape in [Circle(5), Square(4)]:
    print(f"Area: {shape.area():.2f}, Perimeter: {shape.perimeter():.2f}")

Operator Overloading

Define special methods to make operators work with your classes.

class Vector:
    def __init__(self, x, y):
        self.x, self.y = x, y

    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)

    def __mul__(self, scalar):
        return Vector(self.x * scalar, self.y * scalar)

    def __str__(self):
        return f"Vector({self.x}, {self.y})"

v1 = Vector(1, 2)
v2 = Vector(3, 4)

print(v1 + v2)    # Vector(4, 6)
print(v1 * 3)     # Vector(3, 6)

Duck Typing: Python's Polymorphism Without Inheritance

In many languages polymorphism requires a shared base class. Python uses duck typing: "if it walks like a duck and quacks like a duck, it's a duck." Any object with the right method works — no common ancestor needed.

class Dog:  quack = None
class Duck:
    def speak(self): return "Quack"
class Cat:
    def speak(self): return "Meow"

for animal in (Duck(), Cat()):
    print(animal.speak())   # works on both — no shared base class

Operator polymorphism via magic methods

The same + means different things by type — that's polymorphism too. Your classes join in by defining __add__, __len__, __str__:

print(3 + 4)        # 7   (integer add)
print("a" + "b")    # ab  (string concat)
print([1] + [2])    # [1, 2] (list extend)

EAFP style: prefer try: obj.speak() over if isinstance(obj, Duck). Checking behavior beats checking type — it keeps your code open to new classes you haven't met yet.

Interview Questions on Polymorphism

• What is polymorphism in object-oriented programming?
• What is method overriding and how does it relate to polymorphism?
• What is duck typing in Python?
• Does Python support method overloading? Why or why not?
• How does operator overloading demonstrate polymorphism?
• What is the difference between overriding and overloading?
• How does polymorphism work together with abstract base classes?

Related Topics