Purpose of polymorphism in Python - Deep Dive

Overview - Purpose of polymorphism

What is it?

Polymorphism means many forms. In programming, it allows one interface to control access to different types of objects. This means you can use the same function or method name to work with different kinds of data or objects. It helps write flexible and reusable code.

Why it matters

Without polymorphism, programmers would need to write separate code for every type of object or data they want to work with. This would make programs longer, harder to read, and difficult to maintain. Polymorphism solves this by letting one piece of code work with many types, saving time and reducing errors.

Where it fits

Before learning polymorphism, you should understand basic programming concepts like functions, classes, and inheritance. After mastering polymorphism, you can explore advanced topics like design patterns, interfaces, and dynamic typing.

Mental Model

Core Idea

Polymorphism lets one action work on many different types of objects through a shared interface.

Think of it like...

Think of a universal remote control that can operate many different devices like a TV, DVD player, or sound system. You press the same button, but each device responds in its own way.

┌───────────────┐
│   Interface   │
│  (e.g., play) │
└──────┬────────┘
       │
 ┌─────┴─────┐  ┌─────┴─────┐  ┌─────┴─────┐
 │  TV       │  │  Radio    │  │  Speaker  │
 │ play()    │  │ play()    │  │ play()    │
 └───────────┘  └───────────┘  └───────────┘

Build-Up - 7 Steps

1

Foundation

Understanding basic functions

Concept: Functions perform tasks when called by name.

In Python, a function is a named block of code that runs when you call it. For example: def greet(): print('Hello!') greet() # This prints Hello! to the screen.

Result

The program prints: Hello!

Knowing how functions work is essential because polymorphism often uses functions or methods to act on different objects.

2

Foundation

Introduction to classes and objects

Concept: Classes define blueprints for objects that have properties and behaviors.

A class is like a recipe, and an object is the cake made from that recipe. For example: class Dog: def bark(self): print('Woof!') my_dog = Dog() my_dog.bark() # Prints Woof!

Result

The program prints: Woof!

Understanding classes and objects is key because polymorphism works by using objects of different classes through a common interface.

3

Intermediate

Using inheritance to share behavior

Concept: Inheritance lets one class get properties and methods from another class.

Inheritance means a new class can reuse code from an existing class. For example: class Animal: def speak(self): print('Some sound') class Cat(Animal): def speak(self): print('Meow') class Dog(Animal): def speak(self): print('Woof') pets = [Cat(), Dog()] for pet in pets: pet.speak()

Result

The program prints: Meow Woof

Inheritance allows different classes to share a method name, which is the foundation for polymorphism.

4

Intermediate

Polymorphism with method overriding

🤔Before reading on: Do you think calling the same method on different objects runs the same code or different code? Commit to your answer.

Concept: Method overriding lets subclasses provide their own version of a method defined in a parent class.

When subclasses define a method with the same name as the parent, the subclass method runs instead. This lets the same method name do different things: class Bird(Animal): def speak(self): print('Tweet') animals = [Dog(), Cat(), Bird()] for animal in animals: animal.speak()

Result

The program prints: Woof Meow Tweet

Knowing that the same method name can run different code depending on the object is the heart of polymorphism.

5

Intermediate

Polymorphism with duck typing

🤔Before reading on: Does Python require objects to share a parent class to be polymorphic? Yes or no? Commit to your answer.

Concept: Duck typing means an object's suitability is determined by the presence of methods and properties, not its inheritance.

In Python, if an object has the right method, it can be used regardless of its class: class Car: def drive(self): print('Car driving') class Person: def drive(self): print('Person driving') things = [Car(), Person()] for thing in things: thing.drive()

Result

The program prints: Car driving Person driving

Understanding duck typing shows polymorphism is about behavior, not strict class hierarchies.

6

Advanced

Polymorphism in function arguments

🤔Before reading on: Can a single function accept different object types if they share method names? Yes or no? Commit to your answer.

Concept: Functions can use polymorphism by calling methods on arguments without knowing their exact types.

A function can call the same method on different objects: def make_it_speak(animal): animal.speak() make_it_speak(Dog()) # Woof make_it_speak(Cat()) # Meow

Result

The program prints: Woof Meow

Knowing functions can work with any object that supports a method name makes code flexible and reusable.

7

Expert

Polymorphism and dynamic dispatch internals

🤔Before reading on: Do you think Python decides which method to run at compile time or runtime? Commit to your answer.

Concept: Python uses dynamic dispatch to decide at runtime which method version to call based on the object's actual type.

When you call obj.method(), Python looks up the method in the object's class at runtime, not before. This allows polymorphism because the exact method depends on the object's class: # Example: class A: def greet(self): print('Hello from A') class B(A): def greet(self): print('Hello from B') obj = B() obj.greet() # Calls B's greet, decided at runtime

Result

The program prints: Hello from B

Understanding dynamic dispatch explains how polymorphism works under the hood and why Python is flexible but slower than static languages.

Under the Hood

Polymorphism works because Python stores methods in class dictionaries and looks them up at runtime. When you call a method on an object, Python checks the object's class for that method. If the method is overridden in a subclass, Python finds that version first. This runtime lookup is called dynamic dispatch. It allows the same method call to run different code depending on the object's actual class.

Why designed this way?

Python was designed for simplicity and flexibility. Dynamic dispatch and polymorphism let programmers write code that works with many types without strict type declarations. This design favors developer speed and code reuse over raw performance. Other languages use static dispatch for speed but lose flexibility. Python chose dynamic dispatch to support rapid development and polymorphism naturally.

┌───────────────┐
│   Call obj.method()   │
└───────────────┘
          │
          ▼
┌─────────────────────┐
│ Look up method in    │
│ obj's class dict     │
└─────────────────────┘
          │
          ▼
┌─────────────────────┐
│ If found, run method │
│ code from that class │
└─────────────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does polymorphism mean objects must share the same parent class? Commit yes or no.

Common Belief: Polymorphism only works if all objects inherit from the same parent class.

Reality: In Python, polymorphism works as long as objects have the required methods, regardless of inheritance (duck typing).

Why it matters: Believing this limits code reuse and flexibility, causing unnecessary inheritance and complex class hierarchies.

Quick: Is polymorphism only about method overriding? Commit yes or no.

Common Belief: Polymorphism only happens when subclasses override parent methods.

Reality: Polymorphism also includes duck typing where unrelated classes share method names without inheritance.

Why it matters: Missing this leads to misunderstanding Python's dynamic nature and limits creative, flexible designs.

Quick: Does Python decide which method to call before running the program? Commit yes or no.

Common Belief: Python decides which method to call when the program is compiled.

Reality: Python decides at runtime which method to call based on the object's actual class (dynamic dispatch).

Why it matters: Thinking otherwise causes confusion about performance and debugging, leading to wrong assumptions about code behavior.

Quick: Does polymorphism always improve performance? Commit yes or no.

Common Belief: Polymorphism makes programs run faster because it reuses code.

Reality: Polymorphism improves code flexibility and reuse but can add slight runtime overhead due to dynamic method lookup.

Why it matters: Expecting performance gains can lead to wrong optimizations and ignoring trade-offs between speed and flexibility.

Expert Zone

1

Polymorphism in Python is tightly linked to its dynamic typing system, allowing more flexible code than statically typed languages.

2

Method resolution order (MRO) affects which method runs in multiple inheritance scenarios, a subtlety experts must master.

3

Using polymorphism with abstract base classes and protocols can enforce interfaces while keeping flexibility.

When NOT to use

Polymorphism is not ideal when performance is critical and static dispatch can be used instead. Also, if strict type safety is required, static typing or interfaces in other languages may be better.

Production Patterns

In real-world Python, polymorphism is used in frameworks like Django where different models share methods, or in testing where mock objects replace real ones but share method names. It enables plugin systems and flexible APIs.

Connections

Interfaces in Java

Polymorphism in Python builds on similar ideas as Java interfaces but without strict type enforcement.

Understanding Python's polymorphism helps grasp how interfaces define contracts in statically typed languages.

Biological polymorphism

Both share the idea of one form having many variations.

Knowing biological polymorphism shows how diversity under one category can be powerful and adaptable.

Human language communication

Polymorphism is like using one word with different meanings depending on context.

This connection helps appreciate how context and interpretation shape meaning, similar to method behavior depending on object type.

Common Pitfalls

#1 Assuming all objects must inherit from the same class to be polymorphic.

Wrong approach:

class A:
def speak(self):
print('A')

class B:
def speak(self):
print('B')

objs = [A(), B()]
for obj in objs:
if not isinstance(obj, A):
print('Not polymorphic')
else:
obj.speak()

Correct approach:

class A:
def speak(self):
print('A')

class B:
def speak(self):
print('B')

objs = [A(), B()]
for obj in objs:
obj.speak()

Root cause:

Misunderstanding that polymorphism depends on shared methods, not inheritance.

#2 Overriding methods but forgetting to keep the same method name.

Wrong approach:

class Animal:
def speak(self):
print('Sound')

class Dog(Animal):
def bark(self): # Wrong method name
print('Woof')

pets = [Dog()]
for pet in pets:
pet.speak() # Error: Dog has no speak()

Correct approach:

class Animal:
def speak(self):
print('Sound')

class Dog(Animal):
def speak(self): # Correct method name
print('Woof')

pets = [Dog()]
for pet in pets:
pet.speak()

Root cause:

Not matching method names breaks polymorphism because the expected interface is missing.

#3 Expecting polymorphism to improve performance automatically.

Wrong approach:

def process(obj):
for _ in range(1000000):
obj.method() # Using polymorphism without care

# Assuming this is faster

Correct approach:

# For performance-critical code, avoid excessive dynamic calls or use static typing
# or caching methods outside loops.

Root cause:

Confusing code flexibility with execution speed.

Key Takeaways

Polymorphism allows one interface to work with many object types by sharing method names.

It relies on dynamic method lookup at runtime, enabling flexible and reusable code.

Python's duck typing means objects don't need a common parent class to be polymorphic.

Understanding polymorphism helps write cleaner, more maintainable programs that adapt to new requirements.

Misunderstanding polymorphism can lead to rigid code, bugs, or wrong performance expectations.