Polymorphism

Intermediate ~25 min read

Polymorphism ("many forms") allows different objects to respond to the same method call in their own way. Python embraces polymorphism through duck typing - focusing on what an object can do (its methods) rather than what it is (its type).

Python's Approach to Polymorphism

Unlike Java or C++, Python doesn't require explicit interfaces or inheritance for polymorphism. If an object has the right methods, it can be used - this is called duck typing: "If it walks like a duck and quacks like a duck, it's a duck."

Polymorphism Basics

Polymorphism allows you to write code that works with objects of different types, as long as they share a common interface (same method names).

# Polymorphism Basics

print("=== Polymorphism Basics ===\n")

# 1. What is polymorphism?
print("1. Same method name, different classes:")

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

def move(self):
        return "Running on 4 legs"

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

def move(self):
        return "Prowling silently"

class Bird:
    def speak(self):
        return "Tweet!"

def move(self):
        return "Flying through the air"

# Different classes, same interface
animals = [Dog(), Cat(), Bird()]

for animal in animals:
    print(f"   {animal.__class__.__name__}: {animal.speak()}, {animal.move()}")
print()

# 2. Polymorphism enables flexible code
print("2. Write code that works with ANY object having the right methods:")

def make_it_speak(thing):
    """Works with ANY object that has a speak() method."""
    print(f"   {thing.speak()}")

# Works with all our animals
make_it_speak(Dog())
make_it_speak(Cat())
make_it_speak(Bird())

# Would also work with any new class we create!
class Robot:
    def speak(self):
        return "Beep boop!"

make_it_speak(Robot())  # Works!
print()

# 3. Polymorphism with built-in functions
print("3. Python's built-in polymorphism:")

# len() works with different types
print(f"   len('hello'): {len('hello')}")
print(f"   len([1, 2, 3]): {len([1, 2, 3])}")
print(f"   len({{'a': 1}}): {len({'a': 1})}")

# + operator is polymorphic
print(f"   2 + 3 = {2 + 3}")           # Addition
print(f"   'a' + 'b' = {'a' + 'b'}")   # Concatenation
print(f"   [1] + [2] = {[1] + [2]}")   # List concat
print()

# 4. Why polymorphism matters
print("4. Benefits of polymorphism:")
print("""
   - Write more generic, reusable code
   - Add new types without changing existing code
   - Focus on WHAT objects can do, not WHAT they are
   - Makes code more flexible and extensible
""")

# Example: A function that processes any "file-like" object
class StringBuffer:
    def __init__(self, data):
        self.data = data
        self.position = 0

def read(self, n=-1):
        if n == -1:
            result = self.data[self.position:]
            self.position = len(self.data)
        else:
            result = self.data[self.position:self.position + n]
            self.position += n
        return result

def process_readable(source):
    """Works with any object that has read() method."""
    return source.read(5)

# Works with our custom class
buffer = StringBuffer("Hello, World!")
print(f"   Custom buffer: {process_readable(buffer)}")

Output

Click Run to execute your code

Write Generic Functions

The key benefit of polymorphism is writing functions that work with ANY object having the right methods. Your function doesn't need to know about every possible type - it just uses the interface.

Polymorphism Through Inheritance

Inheritance naturally creates polymorphism. A base class defines the interface, and child classes provide different implementations through method overriding.

# Polymorphism Through Inheritance

print("=== Inheritance Polymorphism ===\n")

# 1. Method overriding for polymorphism
print("1. Base class with common interface:")

class Shape:
    """Base class defining the interface."""

def area(self):
        raise NotImplementedError("Subclass must implement")

def perimeter(self):
        raise NotImplementedError("Subclass must implement")

def describe(self):
        return f"{self.__class__.__name__}: area={self.area():.2f}"

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

def area(self):
        return self.width * self.height

def perimeter(self):
        return 2 * (self.width + self.height)

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

def area(self):
        import math
        return math.pi * self.radius ** 2

def perimeter(self):
        import math
        return 2 * math.pi * self.radius

class Triangle(Shape):
    def __init__(self, base, height, side1, side2, side3):
        self.base = base
        self.height = height
        self.sides = (side1, side2, side3)

def area(self):
        return 0.5 * self.base * self.height

def perimeter(self):
        return sum(self.sides)

# Polymorphism in action - same code, different behaviors
shapes = [Rectangle(4, 5), Circle(3), Triangle(6, 4, 5, 5, 6)]

for shape in shapes:
    print(f"   {shape.describe()}")
print()

# 2. Polymorphism enables generic functions
print("2. Generic function using polymorphism:")

def total_area(shapes):
    """Calculate total area of any shape objects."""
    return sum(shape.area() for shape in shapes)

def largest_shape(shapes):
    """Find shape with largest area."""
    return max(shapes, key=lambda s: s.area())

print(f"   Total area: {total_area(shapes):.2f}")
print(f"   Largest: {largest_shape(shapes).describe()}")
print()

# 3. Extending with new shapes - no code changes needed
print("3. Adding new shapes (Open/Closed Principle):")

class Square(Rectangle):
    """Square is just a special rectangle."""
    def __init__(self, side):
        super().__init__(side, side)

class Ellipse(Shape):
    """New shape - existing code still works!"""
    def __init__(self, a, b):
        self.a = a  # semi-major axis
        self.b = b  # semi-minor axis

def area(self):
        import math
        return math.pi * self.a * self.b

def perimeter(self):
        # Approximation
        import math
        return math.pi * (3 * (self.a + self.b) -
                         ((3*self.a + self.b) * (self.a + 3*self.b)) ** 0.5)

# Add new shapes - existing functions still work!
all_shapes = shapes + [Square(4), Ellipse(3, 2)]

print(f"   Total area (with new shapes): {total_area(all_shapes):.2f}")
print()

# 4. Practical example: Payment processing
print("4. Practical example - Payment System:")

class PaymentMethod:
    def process(self, amount):
        raise NotImplementedError

def get_name(self):
        return self.__class__.__name__

class CreditCard(PaymentMethod):
    def __init__(self, card_number):
        self.card_number = card_number

def process(self, amount):
        return f"Charged ${amount} to card ****{self.card_number[-4:]}"

class PayPal(PaymentMethod):
    def __init__(self, email):
        self.email = email

def process(self, amount):
        return f"PayPal payment of ${amount} from {self.email}"

class Crypto(PaymentMethod):
    def __init__(self, wallet):
        self.wallet = wallet

def process(self, amount):
        return f"Crypto transfer of ${amount} to {self.wallet[:8]}..."

def checkout(payment_method, amount):
    """Works with ANY payment method!"""
    print(f"   Processing with {payment_method.get_name()}:")
    print(f"   {payment_method.process(amount)}")

checkout(CreditCard("1234567890123456"), 99.99)
checkout(PayPal("user@example.com"), 49.99)
checkout(Crypto("0x742d35Cc6634C0532925a3b844Bc9e7595f"), 199.99)

Output

Click Run to execute your code

Open/Closed Principle

Polymorphism enables the Open/Closed Principle: code is open for extension (add new shapes without changing existing code) but closed for modification (existing functions work with new types automatically).

Duck Typing

Python's duck typing means you don't need inheritance for polymorphism. Any object with the right methods will work - the type doesn't matter, only the behavior.

# Duck Typing

print("=== Duck Typing ===\n")

# 1. "If it walks like a duck and quacks like a duck..."
print("1. Duck typing principle:")
print('   "If it looks like a duck and quacks like a duck, it\'s a duck"')
print()

# No need for inheritance - just have the right methods!
class Duck:
    def quack(self):
        return "Quack quack!"

def walk(self):
        return "Waddle waddle"

class Person:
    def quack(self):
        return "I'm pretending to quack!"

def walk(self):
        return "Walking on two legs"

class Robot:
    def quack(self):
        return "QUACK.EXE RUNNING"

def walk(self):
        return "Beep boop walking"

def make_it_act_like_duck(thing):
    """Doesn't check type - just uses the methods."""
    print(f"   {thing.__class__.__name__}:")
    print(f"      {thing.quack()}")
    print(f"      {thing.walk()}")

# All work because they have quack() and walk()
for thing in [Duck(), Person(), Robot()]:
    make_it_act_like_duck(thing)
print()

# 2. Duck typing vs type checking
print("2. Duck typing vs explicit type checking:")

# Bad - too restrictive
def bad_process_duck(duck):
    if isinstance(duck, Duck):  # Only works with Duck class!
        return duck.quack()
    raise TypeError("Must be a Duck!")

# Good - duck typing
def good_process_duck(duck):
    return duck.quack()  # Works with anything that can quack

print(f"   Good approach works with Person: {good_process_duck(Person())}")
print()

# 3. Real-world duck typing examples
print("3. Real-world examples:")

# File-like objects
class StringReader:
    """Not a file, but acts like one for reading."""
    def __init__(self, text):
        self.text = text
        self.pos = 0

def read(self, n=-1):
        if n < 0:
            result = self.text[self.pos:]
            self.pos = len(self.text)
        else:
            result = self.text[self.pos:self.pos+n]
            self.pos += n
        return result

def readline(self):
        newline_pos = self.text.find('\n', self.pos)
        if newline_pos == -1:
            return self.read()
        result = self.text[self.pos:newline_pos+1]
        self.pos = newline_pos + 1
        return result

def process_file_like(f):
    """Works with any file-like object."""
    return f.readline().strip()

reader = StringReader("Hello\nWorld\n")
print(f"   StringReader: {process_file_like(reader)}")
print()

# 4. EAFP vs LBYL
print("4. EAFP vs LBYL (Python's preferred style):")

# LBYL: Look Before You Leap (less Pythonic)
def calculate_lbyl(obj):
    if hasattr(obj, 'calculate'):
        return obj.calculate()
    else:
        return "Can't calculate"

# EAFP: Easier to Ask Forgiveness than Permission (Pythonic)
def calculate_eafp(obj):
    try:
        return obj.calculate()
    except AttributeError:
        return "Can't calculate"

class Calculator:
    def calculate(self):
        return 42

class NotCalculator:
    pass

print(f"   EAFP with Calculator: {calculate_eafp(Calculator())}")
print(f"   EAFP with NotCalculator: {calculate_eafp(NotCalculator())}")
print()

# 5. Duck typing best practices
print("5. Best practices:")
print("""
   DO:
   - Trust objects have the methods you need
   - Use try/except for error handling
   - Document expected interface in docstrings

DON'T:
   - Use isinstance() to check types (usually)
   - Require specific class inheritance
   - Over-specify parameter types

Duck typing makes Python flexible and powerful!
""")

Output

Click Run to execute your code

EAFP: Easier to Ask Forgiveness than Permission

Python's preferred style is EAFP - try to use the object and handle exceptions if it fails. Don't check types with isinstance() before using an object. Let duck typing work!

Python Protocols

Protocols are informal interfaces that enable polymorphism with built-in functions like len(), for loops, and operators. Implement special methods to make your objects work with Python's syntax.

# Polymorphism with Protocols

print("=== Python Protocols ===\n")

# 1. Protocols are informal interfaces
print("1. Common Python protocols:")
print("""
   Protocol        Method(s) needed
   --------        ----------------
   Iterable        __iter__()
   Iterator        __iter__(), __next__()
   Sized           __len__()
   Container       __contains__()
   Callable        __call__()
   Comparable      __lt__(), __eq__(), etc.
""")

# 2. Making objects work with len()
print("2. Sized protocol - work with len():")

class Playlist:
    def __init__(self, name):
        self.name = name
        self.songs = []

def add(self, song):
        self.songs.append(song)

def __len__(self):
        """Makes len(playlist) work."""
        return len(self.songs)

playlist = Playlist("My Mix")
playlist.add("Song 1")
playlist.add("Song 2")
playlist.add("Song 3")

print(f"   Playlist has {len(playlist)} songs")  # Works!
print()

# 3. Making objects iterable
print("3. Iterable protocol - work with for loops:")

class Countdown:
    def __init__(self, start):
        self.start = start

def __iter__(self):
        """Makes object iterable."""
        self.current = self.start
        return self

def __next__(self):
        """Returns next value."""
        if self.current <= 0:
            raise StopIteration
        value = self.current
        self.current -= 1
        return value

print("   Countdown from 5:", end=" ")
for num in Countdown(5):
    print(num, end=" ")
print()
print()

# 4. Making objects work with 'in'
print("4. Container protocol - work with 'in' operator:")

class NumberRange:
    def __init__(self, start, end):
        self.start = start
        self.end = end

def __contains__(self, value):
        """Makes 'in' operator work."""
        return self.start <= value <= self.end

def __len__(self):
        return self.end - self.start + 1

r = NumberRange(1, 100)
print(f"   50 in NumberRange(1, 100): {50 in r}")
print(f"   150 in NumberRange(1, 100): {150 in r}")
print()

# 5. Callable protocol
print("5. Callable protocol - objects as functions:")

class Multiplier:
    def __init__(self, factor):
        self.factor = factor

def __call__(self, value):
        """Makes object callable like a function."""
        return value * self.factor

double = Multiplier(2)
triple = Multiplier(3)

print(f"   double(5) = {double(5)}")  # Use like a function!
print(f"   triple(5) = {triple(5)}")
print()

# 6. Combining protocols
print("6. Combining multiple protocols:")

class ShoppingCart:
    """Implements multiple protocols."""

def __init__(self):
        self.items = []

def add(self, item, price):
        self.items.append((item, price))

# Sized protocol
    def __len__(self):
        return len(self.items)

# Container protocol
    def __contains__(self, item):
        return any(i[0] == item for i in self.items)

# Iterable protocol
    def __iter__(self):
        return iter(self.items)

# String representation
    def __str__(self):
        return f"Cart with {len(self)} items"

cart = ShoppingCart()
cart.add("Apple", 1.00)
cart.add("Banana", 0.50)
cart.add("Orange", 0.75)

print(f"   Cart: {cart}")
print(f"   Length: {len(cart)}")
print(f"   'Apple' in cart: {'Apple' in cart}")
print(f"   'Grape' in cart: {'Grape' in cart}")
print("   Items:")
for item, price in cart:
    print(f"      {item}: ${price:.2f}")

Output

Click Run to execute your code

Make Objects Pythonic

By implementing protocols (__len__, __iter__, __contains__, etc.), your custom objects can work with Python's built-in functions and syntax, making them feel like native Python types.

Common Mistakes

1. Unnecessary type checking

# Bad - defeats duck typing
def process(obj):
    if isinstance(obj, MyClass):
        return obj.process()
    raise TypeError("Must be MyClass!")

# Good - just use it
def process(obj):
    return obj.process()  # Works with any class that has process()

2. Not handling missing methods gracefully

# Bad - crashes if method missing
def display(obj):
    return obj.render()  # AttributeError if no render()

# Good - EAFP style
def display(obj):
    try:
        return obj.render()
    except AttributeError:
        return str(obj)  # Fallback

3. Forgetting to implement all interface methods

# Problem - incomplete implementation
class MyIterator:
    def __iter__(self):
        return self
    # Missing __next__! Will fail at runtime.

# Complete implementation
class MyIterator:
    def __init__(self, data):
        self.data = data
        self.index = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.index >= len(self.data):
            raise StopIteration
        value = self.data[self.index]
        self.index += 1
        return value

4. Breaking the interface contract

# Bad - same method name, different behavior
class GoodDuck:
    def speak(self):
        return "Quack"  # Returns string

class BadDuck:
    def speak(self):
        print("Quack")  # Prints instead of returning!

# Now this breaks:
message = BadDuck().speak()  # message is None!

5. Over-relying on inheritance for polymorphism

# Overly complex - forced inheritance
class BaseProcessor:
    def process(self): pass

class CSVProcessor(BaseProcessor):
    def process(self): ...

class JSONProcessor(BaseProcessor):
    def process(self): ...

# Simpler - just use duck typing
# No base class needed! Just have process() method
class CSVProcessor:
    def process(self): ...

class JSONProcessor:
    def process(self): ...

Exercise: Media Player

Task: Create a polymorphic media player system using both inheritance and duck typing.

Requirements:

AudioFile and VideoFile classes inheriting from MediaFile
ImageFile class (no inheritance - demonstrates duck typing)
All classes implement play() and get_info() methods
play_all() function that works with any media type
total_duration() using duck typing (some media has duration, some doesn't)

Output

Click Run to execute your code

Show Solution

class MediaFile:
    def __init__(self, filename, duration):
        self.filename = filename
        self.duration = duration

    def play(self):
        raise NotImplementedError

    def get_info(self):
        return f"{self.filename} ({self.duration}s)"


class AudioFile(MediaFile):
    def __init__(self, filename, duration, bitrate):
        super().__init__(filename, duration)
        self.bitrate = bitrate

    def play(self):
        return f"Playing audio: {self.filename}"

    def get_info(self):
        return f"{self.filename} ({self.duration}s, {self.bitrate}kbps)"


class VideoFile(MediaFile):
    def __init__(self, filename, duration, resolution):
        super().__init__(filename, duration)
        self.resolution = resolution

    def play(self):
        return f"Playing video: {self.filename}"

    def get_info(self):
        return f"{self.filename} ({self.duration}s, {self.resolution})"


class ImageFile:  # No inheritance - duck typing!
    def __init__(self, filename, dimensions):
        self.filename = filename
        self.dimensions = dimensions
        # No duration attribute!

    def play(self):
        return f"Displaying image: {self.filename}"

    def get_info(self):
        return f"{self.filename} ({self.dimensions})"


def play_all(media_list):
    for media in media_list:
        print(media.play())


def total_duration(media_list):
    total = 0
    for media in media_list:
        try:
            total += media.duration
        except AttributeError:
            pass  # Skip items without duration
    return total


# Test
media = [
    AudioFile("song.mp3", 180, 320),
    VideoFile("movie.mp4", 7200, "1920x1080"),
    ImageFile("photo.jpg", "4000x3000"),
]

for m in media:
    print(m.get_info())

play_all(media)
print(f"Total duration: {total_duration(media)}s")

Summary

Polymorphism: Different objects responding to the same method call
Duck typing: "If it has the right methods, use it" - no type checks
EAFP: Try to use the object, handle exceptions if it fails
Protocols: Implement __len__, __iter__, etc. for Python integration
Inheritance polymorphism: Base class defines interface, children override
Write generic functions that work with any object having the right methods

What's Next?

Now that you understand polymorphism and protocols, learn about Special Methods (dunder methods) - the double-underscore methods like __init__, __str__, and __eq__ that make your classes work with Python's syntax.

Previous Encapsulation

Next Special Methods

Python's Approach to Polymorphism

Polymorphism Basics

Write Generic Functions

Polymorphism Through Inheritance

Open/Closed Principle

Duck Typing

EAFP: Easier to Ask Forgiveness than Permission

Python Protocols

Make Objects Pythonic

Common Mistakes

1. Unnecessary type checking

2. Not handling missing methods gracefully

3. Forgetting to implement all interface methods

4. Breaking the interface contract

5. Over-relying on inheritance for polymorphism

Exercise: Media Player

Summary

What's Next?

Enjoying these tutorials?