What Is Polymorphism?

In Python, len("hello") returns 5, len([4, 8, 15]) returns 3, and len({"a": 1}) returns 1. It is one function name used on three types, and each type counts its own way: a string counts characters, a list counts items, a dictionary counts keys. The word comes from Greek: poly, many, and morph, form. One call, many forms of behavior.

How polymorphism works

Code calls a method by name, such as shape.area(). When that line runs, the language looks at the actual object and finds area on the object's own class. This lookup is called dynamic dispatch, and it is what lets one line do different work for different objects:

import math

class Shape:
    def area(self):
        raise NotImplementedError

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

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

shapes = [Circle(1), Square(3), Circle(2)]
for shape in shapes:
    # One line of code, a different area() for each type
    print(type(shape).__name__, round(shape.area(), 2))

Circle 3.14
Square 9
Circle 12.57

Python finds the method by searching the object's class first, then its parent classes in a fixed order called the method resolution order. If Square had no area() of its own, the search would reach Shape.area() and raise NotImplementedError, a signal that every subclass must supply one.

The loop never checks what kind of shape it holds. To add a triangle, you write a Triangle class with its own area(), and the loop works unchanged. Without polymorphism, the loop would need an if isinstance(...) branch for every shape, edited each time a new one appears.

Types of polymorphism

When people say "polymorphism" in object-oriented programming without more detail, they almost always mean the first row: subtype polymorphism through overriding.

Python has all three in its own way. Overriding works as in the shapes example. Operators such as + are ad hoc polymorphism. Functions like max() and sorted() are parametric in spirit: they accept a list of numbers, strings or dates, as long as the items can be compared, and type hints such as list[int] or a TypeVar can state that explicitly.

Compile-time vs runtime polymorphism in Java

Java has both kinds, and interview questions often ask about the difference:

class Animal { String sound() { return "..."; } }
class Dog extends Animal {
    @Override String sound() { return "Woof"; }
}

Animal pet = new Dog();
pet.sound();          // "Woof": chosen at run time from the object

int add(int a, int b)          { return a + b; }
double add(double a, double b) { return a + b; }
add(2, 3);            // int version, chosen by the compiler
add(2.5, 1.0);        // double version

The variable pet has the type Animal, yet the Dog version runs, because the choice depends on the object, not the variable. The two add methods are overloading: the compiler picks one from the argument types before the program runs. Interfaces give the same runtime behavior without sharing code: any class that implements Comparable can be sorted by Collections.sort. C++ works the same way with one difference: a method gets runtime dispatch only if it is declared virtual. See polymorphism in Java, method overloading and C++ virtual functions.

Polymorphism in Python: duck typing and operators

Python does not require a shared parent class. If an object has the method the code calls, it works: "if it walks like a duck and quacks like a duck, it is a duck". Operators are polymorphic too. Writing a + b calls a.__add__(b), so your own classes can support +, len() and print():

class Vector:
    def __init__(self, x, y):
        self.x, self.y = x, y
    def __add__(self, other):          # called for v1 + v2
        return Vector(self.x + other.x, self.y + other.y)
    def __len__(self):                 # called for len(v)
        return 2
    def __repr__(self):                # called by print()
        return f"Vector({self.x}, {self.y})"

print(1 + 2, "ab" + "cd", [1] + [2])   # built-in types
print(Vector(1, 2) + Vector(10, 20))    # your own type
print(len("hello"), len([1, 2, 3]), len(Vector(0, 0)))

3 abcd [1, 2]
Vector(11, 22)
5 3 2

Inheritance is one way to get polymorphism, not a requirement. Vector inherits from nothing special, yet len() and + treat it like a built-in type. The Python inheritance docs show the subclass route.

Common mistakes

Expecting Python to overload by signature. A second def with the same name silently replaces the first:

def greet(name):
    return "Hi " + name

def greet(first, last):          # replaces the first greet
    return "Hi " + first + " " + last

print(greet("Ana", "Silva"))
print(greet("Ana"))

Hi Ana Silva
Traceback (most recent call last):
  ...
TypeError: greet() missing 1 required positional argument: 'last'

Use a default argument instead: def greet(first, last="").

Forgetting virtual in C++. Without it, calling a method through a pointer to the base class runs the base version, even when the object is a subclass.

Overrides that change the meaning. If area() on one subclass returns the perimeter, every caller that trusts area() breaks. An override must keep the promise the parent made; this rule is known as the Liskov substitution principle.

Type checks everywhere. A chain of if type(x) == ... branches is usually a sign that each type should carry its own method instead.

Where to go next

Polymorphism works together with encapsulation, which protects each object's data, and abstraction, which defines the shared interface the types implement. Practice overriding in the Python classes docs, or try the Java course, where overloading and overriding appear side by side.