Polymorphism in Python: Explained with Examples

Polymorphism is one of the key principles of Object-Oriented Programming (OOP) that enables flexibility and reusability in code. In simple terms, polymorphism allows objects of different types to be treated as instances of a common superclass, with each object responding to the same method in its own way. The term polymorphism comes from the Greek word meaning "many shapes," and in programming, it signifies the ability of a single function or method to work with objects of multiple types.

In Python, polymorphism is implemented through inheritance, allowing a method defined in a superclass to be overridden by a method in a subclass. This capability makes Python an ideal language for building flexible, extensible, and easy-to-maintain applications.

In this article, we will explore polymorphism in Python, diving into what it is, how it works, and providing practical examples to explain polymorphism in Python. By the end, you’ll have a deeper understanding of how polymorphism helps in making your Python code more efficient and scalable. Whether you’re a beginner or looking to refine your understanding of OOP concepts, this guide will provide you with the essential knowledge to start using polymorphism effectively in your Python projects.

Also Read: T-Test vs. Z-Test: Key Differences, When to Use, and Hypothesis Testing Explained

What is Polymorphism in Python?

Polymorphism is a concept that allows different types of objects to be accessed through the same interface, with each object responding in its own way. In Python, polymorphism is an essential feature of Object-Oriented Programming (OOP), enabling objects from different classes to be treated as instances of a common superclass. The power of polymorphism lies in its ability to call the same method on different objects, but with each object performing the method in a way that’s specific to its class.

In simpler terms, polymorphism lets you write code that can handle objects of multiple types seamlessly. The same function or method can operate on different data types and produce different behaviors, depending on the object it is invoked upon.

A polymorphism example in Python demonstrates how different object types can respond to the same method call, such as different shapes implementing a draw() method. This showcases the power of polymorphism by allowing code to be more flexible and reusable, while reducing complexity.

How Polymorphism Works in Python

In Python, polymorphism can be achieved using two primary mechanisms:

1. Method Overloading: This involves defining multiple methods with the same name but different argument lists. However, Python does not support traditional method overloading in the way that languages like Java or C++ do. Instead, Python uses default arguments and variable-length argument lists to achieve a similar result.
   
   
2. Method Overriding: This is the most common form of polymorphism. It occurs when a method in a subclass has the same name as a method in the parent class, but the method in the subclass provides a different implementation. When the method is called on an object of the subclass, the overridden method is executed.
   

Let's take a closer look at both forms of polymorphism to better understand their use in Python.

Why is Polymorphism Important in Python?

Polymorphism plays a significant role in improving the flexibility, maintainability, and scalability of your Python code. By allowing objects of different classes to be treated as instances of a common superclass, polymorphism enables a more general and flexible approach to writing code. Here are some key reasons why polymorphism is important in Python:

1. Code Reusability

One of the major advantages of polymorphism is code reusability. Instead of writing multiple methods for each type of object, polymorphism allows you to write a single method that works for all the objects of different classes, as long as they share a common superclass. This minimizes code duplication and promotes a more efficient and manageable codebase.

For example, you might write a generic draw() method for a series of shapes like circles, squares, and triangles. Instead of writing separate draw_circle(), draw_square(), and draw_triangle() methods, you can rely on polymorphism to call draw() on any shape object and let each shape class implement its specific drawing logic.

2. Flexibility and Extensibility

Polymorphism makes your code more flexible and extensible. If you decide to add a new type of object, you don't need to modify existing code. As long as the new class inherits from the same parent class and implements the necessary methods, the polymorphic behavior will still work.

For example, if you have a game that uses a Character class with a move() method, you can easily add new character types (e.g., Mage, Warrior, Healer) without changing any code that already works with the Character objects.

3. Simplified Code Maintenance

Because polymorphism promotes the use of generalized functions and methods, code maintenance becomes easier. If you need to update the logic of a method, you can do so in one place (the superclass or the overriding method in the subclass), and the changes will propagate throughout the codebase without the need for significant rewrites.

For example, if you need to update how an object interacts with a database, you can modify the save() method in a single class, and all objects that inherit from it will automatically benefit from the update.

4. Better Organization and Design

Polymorphism encourages better organization of code by making it more modular and decoupled. It allows you to focus on the behavior of objects rather than worrying about the specific details of each object type. This leads to more clean and well-organized code, especially in large applications.

In summary, polymorphism enhances the flexibility, extensibility, and maintainability of Python code, while also improving the reusability of functions and methods across different object types. It’s a crucial feature for developing scalable and efficient applications.

Also Read: Key Loss Functions in Deep Learning and Their Applications

Types of Polymorphism in Python

Polymorphism can be categorized into two main types: Method Overloading and Method Overriding. Both serve the purpose of allowing objects of different types to use the same method, but they achieve this in different ways. Let’s explore both types in detail.

1. Compile-time Polymorphism (Method Overloading)

Method Overloading refers to the ability of a method to handle different numbers or types of parameters. However, Python doesn’t support traditional method overloading as seen in languages like Java or C++. In Python, if you define a method with the same name multiple times in the same class, the last definition will override the previous ones.

Despite this, Python still provides a way to achieve overloading-like behavior using default arguments or variable-length argument lists. This allows you to handle different numbers of arguments, mimicking method overloading.

Example of Method Overloading Using Default Arguments:

In this example, the add() method has default arguments (b and c), which means it can work with one, two, or three arguments. This is an example of how Python can simulate method overloading using default values, which is part of compile-time polymorphism.

Example of Method Overloading Using Variable-Length Arguments:

Here, the print_message() method uses the *args syntax, which allows it to accept any number of arguments. This is another example of how polymorphism can be implemented in Python.

2. Runtime Polymorphism (Method Overriding)

Method Overriding occurs when a subclass provides its own implementation of a method that is already defined in its superclass. The key difference between method overloading and overriding is that method overriding occurs at runtime—it is determined by the actual object type (i.e., the subclass object), not the reference type (i.e., the superclass type).

In method overriding, the subclass defines a method with the same name as the parent class, and when called on an object, the overridden method in the subclass gets executed.

Example of Method Overriding in Python:

Output:

Animal makes a sound

Dog barks

Cat meows

‍

In this example, each subclass (Dog and Cat) overrides the sound() method of the superclass Animal. The method that gets executed depends on the actual object type, making this runtime polymorphism in action.

Also Read: Support Vector Machines (SVM): From Hyperplanes to Kernel Tricks

Summary of the Two Types of Polymorphism in Python:

• Method Overloading (Compile-Time Polymorphism): Achieved using default or variable-length arguments. Python doesn’t natively support method overloading in the same way other languages like Java do, but these techniques allow similar functionality.
  
  
• Method Overriding (Runtime Polymorphism): Occurs when a subclass provides a specific implementation of a method already defined in its parent class. The method called is determined at runtime based on the actual object type.
  

Both forms of polymorphism help Python developers write cleaner, more flexible, and reusable code. By taking advantage of polymorphism, you can design systems that are adaptable to new functionality with minimal changes to existing code.

Polymorphism Example in Python

Now that we've explored the concept and types of polymorphism, let’s dive into a practical example to explain polymorphism in Python in more detail. Below, we will walk through an example that demonstrates how polymorphism works in real-life scenarios, such as different shapes drawing themselves.

In this example, we will define a superclass Shape with a method draw(), and then we will have multiple subclasses (Circle, Square, and Triangle) that implement their own version of the draw() method. This showcases runtime polymorphism because the appropriate draw() method will be invoked based on the type of the object (i.e., the subclass).

Polymorphism Example: Drawing Shapes

Output:

Drawing a shape

Drawing a circle

Drawing a square

Drawing a triangle

‍

Explanation:

1. Base Class (Shape): The Shape class has a method draw() that simply prints a generic message. This is the method that will be overridden by the subclasses.
   
   
2. Derived Classes (Circle, Square, Triangle): Each of these subclasses overrides the draw() method, providing its own implementation based on the shape it represents.
   
   
3. Polymorphism in Action: We create a list of shape objects (shapes), including instances of Shape, Circle, Square, and Triangle. When we iterate through the list and call draw() on each object, Python invokes the correct version of draw() based on the actual type of the object. This is a classic case of runtime polymorphism.
   
   
4. Flexibility: If we later add more shapes (e.g., Rectangle or Pentagon), we don’t need to modify the existing code that calls the draw() method. We simply need to create a new class that inherits from Shape and implements its own version of draw(). This demonstrates how polymorphism makes your code more flexible and scalable.
   

Why This Example Works:

• Object-Oriented Design: The polymorphism here leverages inheritance, with each subclass providing its specific implementation of the draw() method, allowing the program to handle multiple object types through the same interface.
  
  
• Code Reusability: The code calling draw() doesn’t need to know or care about the specific type of shape it’s dealing with. This enhances code reusability and simplifies adding new shapes without needing to change the calling code.
  

This example illustrates polymorphism clearly and shows how Python’s flexible object-oriented capabilities can make your code more maintainable and extensible in the long run.

Advantages of Using Polymorphism in Python

Polymorphism provides a number of benefits that help improve the quality and maintainability of code. Let’s look at some of the key advantages of using polymorphism.

1. Code Reusability

One of the primary advantages of polymorphism is that it allows you to write general code that can work with objects of different classes. This enhances code reusability because a single method or function can operate on multiple types of objects without the need for rewriting or duplicating code.

For instance, in the previous example of drawing shapes, we were able to use the same method (draw()) for different types of shapes (circle, square, triangle). This avoids having to write separate methods for each shape, making the code more concise and easier to maintain.

2. Simplified Code Maintenance

Polymorphism allows code to remain simpler and easier to maintain. Since polymorphism allows objects to be treated in a general way, adding new types of objects doesn’t require changes to the existing code that interacts with those objects.

For example, when you add a new shape (like Rectangle or Pentagon), the logic to draw the shape can be handled by the new subclass without modifying the rest of the system. The code that calls the draw() method remains unchanged.

3. Increased Flexibility and Extensibility

With polymorphism, it’s easy to add new functionality to a system without affecting the existing code. The system can be extended simply by adding new subclasses and overriding existing methods. The calling code does not need to know what type of object it is interacting with, making it more flexible.

For example, if your system uses a Shape class and you later decide to introduce a new type of shape (like Ellipse), you can create a new Ellipse class that inherits from Shape and implements the draw() method. This makes your system extensible and allows it to grow with minimal disruption to existing functionality.

4. Improved Readability and Reduced Complexity

By utilizing polymorphism, you can create a more intuitive and readable code structure. Polymorphism allows you to avoid repetitive checks for object types, reducing the complexity of the program. The code that uses polymorphism focuses on behavior rather than on the specifics of each object, leading to a cleaner and more understandable codebase.

For instance, in the shape-drawing example, the same function (draw()) is used to handle different types of shapes, making the code more consistent and easy to follow.

5. Promotes Better Software Design (Loose Coupling)

Polymorphism encourages loose coupling between classes. Loose coupling means that objects of different classes can interact with one another without being tightly dependent on each other’s implementation details. This makes the code more modular and easier to change without breaking other parts of the system.

For example, the draw() method doesn't need to know the specifics of each shape; it just calls the method on any object that has a draw() method. This helps prevent rigid dependencies between objects, making the code more maintainable and adaptable to changes.

6. Easier to Work with Abstract Concepts

Polymorphism, especially when combined with inheritance, allows you to work with abstract concepts more easily. You can define generic methods in a superclass and override them in subclasses to implement specific functionality. This creates a clear, understandable abstraction that hides implementation details and allows users to interact with high-level features rather than specific details of each class.

For example, in the Shape class, you define a general draw() method, which is then customized by subclasses (e.g., Circle, Square). The user doesn't need to know how each shape is drawn—just that it can be drawn using the draw() method.

Also Read: A Deep Dive into Ensemble Methods in Machine Learning: Techniques and Algorithms

Summary of Advantages:

• Code Reusability: Write general methods that work for different object types.
  
  
• Simplified Maintenance: Add new objects without changing the existing code.
  
  
• Flexibility and Extensibility: Easily extend the system by adding new subclasses.
  
  
• Improved Readability: Avoid repetitive code and simplify logic.
  
  
• Loose Coupling: Make your code more modular and less dependent on specific class implementations.
  
  
• Abstraction: Handle complex concepts with simpler, more abstract interfaces.
  

By leveraging these advantages, polymorphism helps Python developers write cleaner, more maintainable, and more scalable code that can grow and adapt to new requirements over time.

Conclusion

In conclusion, polymorphism in Python is a fundamental concept in object-oriented programming that allows a single method or function to operate on objects of different types, leading to more flexible and reusable code. By enabling objects of various classes to respond to the same method call in their own way, polymorphism reduces code duplication, simplifies maintenance, and increases the scalability of applications. Whether through method overloading or method overriding, polymorphism allows developers to write cleaner, more modular, and easily extendable code. By understanding and utilizing polymorphism, Python developers can create systems that are not only easier to maintain but also more adaptable to future changes, making it an essential tool in building efficient, robust, and scalable software.

Ready to transform your AI career? Join our expert-led courses at SkillCamper today and start your journey to success. Sign up now to gain in-demand skills from industry professionals. If you're a beginner, take the first step toward mastering Python! Check out this Fullstack Generative AI course to get started with the basics and advance to complex topics at your own pace.

To stay updated with latest trends and technologies, to prepare specifically for interviews, make sure to read our detailed blogs:

How to Become a Data Analyst: A Step-by-Step Guide

How Business Intelligence Can Transform Your Business Operations