Topic 10618 min readStructured Tutorial

Understanding Polymorphism in Python

Quick Answer

Polymorphism explains polymorphism is a fundamental concept in object-oriented programming that allows objects of different classes to be treated as objects of a common superclass.

Learning Objectives

Explain the purpose of Polymorphism in a practical learning context.
Identify the main ideas, terms, and decisions involved in Polymorphism.
Apply Polymorphism in a simple real-world scenario or practice task.

Introduction to Polymorphism

Polymorphism is a fundamental concept in object-oriented programming that allows objects of different classes to be treated as objects of a common superclass.

In Python, polymorphism enables functions or methods to use entities of different types at different times, enhancing flexibility and code reusability.

Polymorphism allows the same interface to be used for different underlying forms (data types).

What is Polymorphism?

The term polymorphism means 'many forms'. In programming, it refers to the ability of different objects to respond, each in its own way, to the same method call.

Polymorphism allows methods to do different things based on the object it is acting upon, even though they share the same name.

Enables code to be more flexible and extensible.
Supports method overriding and duck typing in Python.
Helps in implementing interfaces and abstract classes.

Types of Polymorphism in Python

Python supports two main types of polymorphism: compile-time (or static) polymorphism and runtime (or dynamic) polymorphism.

However, due to Python's dynamic nature, runtime polymorphism is more commonly used.

Operator Overloading (compile-time polymorphism): Same operator behaves differently with different data types.
Method Overriding (runtime polymorphism): Subclass provides a specific implementation of a method already defined in its superclass.
Duck Typing: An object's suitability is determined by the presence of certain methods and properties, rather than the actual type.

Operator Overloading Example

Python allows operators like +, -, * to be overloaded to work with user-defined classes.

Method Overriding Example

A subclass can override a method of its superclass to provide a specific behavior.

Polymorphism in Action: Code Examples

Let's explore practical examples demonstrating polymorphism in Python.

Example 1: Method Overriding

Here, different classes implement the same method name but with different behaviors.

Example 2: Duck Typing

Python's duck typing allows functions to operate on any object that implements the required methods.

Practical Example

Each subclass overrides the 'sound' method to provide its specific implementation. When called, the correct method is executed based on the object type.

The function 'lets_fly' accepts any object with a 'fly' method, demonstrating polymorphism through duck typing.

Examples

Method Overriding Example

class Animal:
    def sound(self):
        print("Some generic sound")

class Dog(Animal):
    def sound(self):
        print("Bark")

class Cat(Animal):
    def sound(self):
        print("Meow")

animals = [Dog(), Cat(), Animal()]
for animal in animals:
    animal.sound()

Each subclass overrides the 'sound' method to provide its specific implementation. When called, the correct method is executed based on the object type.

Duck Typing Example

class Bird:
    def fly(self):
        print("Flying in the sky")

class Airplane:
    def fly(self):
        print("Flying through clouds")

def lets_fly(flying_object):
    flying_object.fly()

bird = Bird()
airplane = Airplane()
lets_fly(bird)
lets_fly(airplane)

The function 'lets_fly' accepts any object with a 'fly' method, demonstrating polymorphism through duck typing.

Best Practices

Use polymorphism to write flexible and maintainable code.
Prefer method overriding over complex conditional statements.
Leverage duck typing to write generic functions that work with any compatible object.
Document overridden methods clearly to avoid confusion.
Test polymorphic behavior thoroughly to ensure correct method resolution.

Common Mistakes

Assuming polymorphism works only with inheritance; duck typing is also a form of polymorphism.
Overusing polymorphism leading to code that is hard to understand.
Not properly overriding methods, causing unexpected behavior.
Ignoring the importance of method signatures when overriding.
Failing to test all subclasses for correct polymorphic behavior.

Hands-on Exercise

Implement Polymorphism with Shapes

Create classes for different shapes (Circle, Square, Triangle) each with a method 'area'. Write a function that takes a list of shapes and prints their areas using polymorphism.

Expected output: Printed area values for each shape in the list.

Hint: Override the 'area' method in each shape class with the correct formula.

Demonstrate Duck Typing

Write two classes with a method 'describe'. Create a function that calls 'describe' on any object passed to it. Show how this function works with instances of both classes.

Expected output: Descriptions printed from both objects.

Hint: Ensure both classes implement the 'describe' method.

Interview Questions

What is polymorphism in Python?

Interview

Polymorphism in Python is the ability of different objects to respond to the same method call in different ways, enabling flexible and reusable code.

How does Python implement polymorphism?

Interview

Python implements polymorphism primarily through method overriding, operator overloading, and duck typing.

What is duck typing?

Interview

Duck typing is a concept where the suitability of an object is determined by the presence of certain methods and properties, rather than the object's actual type.