Python Polymorphism

2. What is Polymorphism in Python (Very Simple Explanation)

4.1 Built-in Function Polymorphism Example

In this example (as shown below), we will use the len() function and you would observe how the same function behaves differently based on the data type passed to it.

print(len("Python"))
print(len([10, 20, 30, 40]))
print(len({"a": 1, "b": 2}))

Output:

6
4
2

Explanation:

In this example, first we pass a string ("Python") to the len() function and it counts characters (i.e., 6). After that, we pass a list, which counts the total number of elements (i.e., 4), and finally, we pass a dictionary and it counts the keys (i.e., 2).

If you notice, the function name (len) is the same, but its behavior is changed based on the data type. This is how polymorphism works for built-in functions.

4.2 User-Defined Function Polymorphism Using Arguments

In this section, we will define a user-defined function and it can behave differently based on the number of arguments we pass.

Example:

def add(a, b, c=0):
    return a + b + c

print(add(10, 20))
print(add(10, 20, 30))

Output:

30
60

Explanation:

In this example, first we have defined a function called add(), which takes a total of three arguments, and the third argument c has a default value of 0. This function returns the sum of three variables (a, b, c).

In the next statement, when we call add (10, 20), then Python uses the default value of c and returns 30 (10 + 20 + 0).

Finally, when we call add (10, 20, 30), then Python ignores the default value of variable c and returns the total sum as 60 (10 + 20 + 30).

The key point to learn here is that the same function name (add) works with different inputs and it also adjusts its behavior automatically, and this is called user-defined function polymorphism.

5. Class Polymorphism in Python

Polymorphism in classes means multiple classes can use the same method name, but the actual behavior depends on the object that calls it.

In simple words, the method name is the same, but the implementation is different.

5.1 Basic Class Polymorphism Example

class Car:
    def move(self):
        print("Car is moving")

class Boat:
    def move(self):
        print("Boat is moving")

class Plane:
    def move(self):
        print("Plane is flying")

vehicles = [Car(), Boat(), Plane()]

for vehicle in vehicles:
    vehicle.move()

Output:

Car is moving
Boat is moving
Plane is flying

Explanation:

In this example, we have created three different classes as given below:

• Car

• Boat

• Plane

Inside each class, we have defined a method named move(), but each move() method has a different behavior.

Next, we have created a list (vehicles) that contains three object references:

• Car() object

• Boat() object

• Plane() object

After that, we have defined a for loop, and the variable vehicle contains one object at a time during each iteration.

So, in simple words:

Iteration 1, vehicle refers to Car() object, so car.move() runs.

Iteration 2, vehicle refers to Boat() object, so boat.move() runs.

Iteration 3, vehicle refers to Plane() object, so plane.move() runs.

If you notice, Python automatically calls the correct move() method based on the object that vehicle is referring to at that moment, and this is also called runtime polymorphism.

6. Inheritance-Based Polymorphism (Important)

This is an important concept. Inheritance-based polymorphism happens when a child class inherits from a parent class and overrides one of its methods.

In this, the name of the method is the same, but the child class provides its own implementation.

It allows the same interface to behave differently based on the object.

Example:

class Notification:
    def send(self):
        print("sending notification")

class EmailNotification(Notification):
    def send(self):
        print("sending email notification")

class SMSNotification(Notification):
    def send(self):
        print("sending SMS notification")

notify = [EmailNotification(), SMSNotification()]

for note in notify:
    note.send()

Output:

sending email notification
sending SMS notification

Explanation:

In this example, we first create a parent class Notification, and after that, we create two child classes, and each overrides the send() method differently:

• EmailNotification

• SMSNotification

Please note that both child classes implement the send() method in their own way, but the name of the method is the same (it doesn’t change).

After that, we loop through the list, and it contains two objects, and each object is picked one by one, and its own send() method runs automatically.

At runtime, Python automatically calls the correct send() method based on the object type, and you don’t need to modify the existing code as well.

Please understand this completely because this is how we design large frameworks and production systems.

7. Operator Polymorphism in Python

Operator polymorphism means the same operator behaves differently depending on the data type it is used with.

Please note that the behavior of an operator gets changed automatically based on the operands.

7.1 Built-in Operator Polymorphism Example

print(10 + 20)
print("Hello" + " India")
print([1, 2] + [3, 4])

Output:

30
Hello India
[1, 2, 3, 4]

Explanation:

In this example, first we have used the + operator with numbers, so Python performs mathematical addition and prints 30.

After that, we have used + with strings, so instead of adding, Python joins both strings and prints it.

Finally, we have used the + operator with lists, and Python combines both lists into a single list.

As you can see, the operator + is the same, but its behavior gets changed based on the data type provided.

This is called operator polymorphism in Python.

7.2 Custom Operator Polymorphism

Custom operator polymorphism allows us to redefine the behavior of built-in operators for user-defined objects.

By implementing special methods like add() or sub(), you can make your objects behave naturally with operators, just like built-in data types.

Example:

class Salary:
    def __init__(self, amount):
        self.amount = amount

    def __add__(self, other):
        return Salary(self.amount + other.amount)

S1 = Salary(40000)
S2 = Salary(20000)

total = S1 + S2
print(total.amount)

Output:

60000

Explanation:

In the above example, first we have created a class Salary which is used to store an amount using the init constructor.

After that, we have defined a special method add to overload the + operator, and it tells Python how two Salary objects should be added.

Finally, when we write S1 + S2, Python internally calls S1.add(S2), and it is not normal integer addition.

Inside the add method, Python adds self.amount and other.amount, and then it returns a Salary object.

So now, the total refers to a Salary object containing 60000, and it prints this value.

As you can see, we have changed the behavior of the built-in + operator for our own class by defining the add method.

Now the + operator works with Salary class objects as well. This is called custom operator overloading and also a form of polymorphism for user-defined objects.

8. Duck Typing Polymorphism in Python

Duck typing means Python doesn’t care about the class; it only cares about behavior.

If an object has the required method or attribute, then Python will use it without checking its type.

This makes programs more flexible and reduces unnecessary type checking.

Example:

class Dog:
    def speak(self):
        print("Dog is barking")

class Cat:
    def speak(self):
        print("Cat meows")

def make_sound(animal):
    animal.speak()

make_sound(Dog())
make_sound(Cat())

Output:

Dog is barking
Cat meows

Explanation:

In this example, first we have created two classes, Dog and Cat, and both classes have a method called speak(), and please note that both of these classes are not inheriting from any common parent class.

After that, we have defined a function make_sound() which doesn’t check the type of object and simply calls the speak() method.

If the object has a speak() method, it works; otherwise, it would throw an error.

Please note that here, Python only cares about behavior, not class type, and this is duck typing.

In real-world production systems, it is always better to verify that an object actually has the required method (for example, by using hasattr() or proper structural typing) instead of simply assuming that the method will always exist.

8.1 Types of Polymorphism in Python (Quick Comparison)

9. How Python Decides Which Method to Call (Runtime Polymorphism)

In Python, normally developers think that method selection happens at compile time, but method selection is done at runtime. This is called runtime binding.

For example, when you call a method in Python using:

obj.method()

Python doesn’t assume immediately which version to execute. Instead, it looks at the actual object stored inside obj at runtime.

Step 1 – Python Checks the Object’s Class

First, Python checks the class to which that object belongs. If the called method is defined inside the class, then Python executes that method.

On the other side, if the method is not defined inside the class, then Python doesn’t stop searching there.

Step 2 – Python Follows Method Resolution Order (MRO)

If a called method is not found in the current class, then Python follows MRO.

As per MRO, a method is searched in the following order:

1. Current class

2. Parent class

3. Parent’s parent

4. And so on

As soon as the first matching method is found in the above given order, that method would be executed.

Step 3 → Closest Matching Method Wins

Suppose there is a child class that overrides a method of a parent class. In that case, Python would execute the child class method. The answer is simple because the overridden method is closer in the inheritance chain. This is how the overriding feature works in inheritance-based polymorphism.

Please note that all this decision-making happens at runtime, and this is called runtime polymorphism.

Polymorphism is one of the main features of Python object-oriented design.

Flowchart: Python Runtime Method Resolution

10. Common Mistakes Developers Make With Polymorphism

Polymorphism is a powerful feature in Python. If it is not used correctly, then it can create serious issues in production as well.

In my experience, I have seen that most runtime defects come many times due to incorrect design, not from syntax errors.

Let’s understand common mistakes clearly:

1. Some developers change the method signature in the child class. So if you try to call the method using the old signature, then it will break at runtime. So, you should never change the method signature in the child class.

2. Most beginners use if-else instead of polymorphism because this approach defeats the purpose of polymorphism. So, good practice is to let each class implement its own method, and you should call it directly.

3. I have seen many freshers create deep inheritance chains like:

Base → Level 1 → Level 2 → Level 3 → Level 4

This deep inheritance makes debugging difficult, and behavior also becomes unpredictable. As a best practice, shallow inheritance is always safe and easy to maintain as well.

4. Sometimes junior developers write code in such a way that a parent class returns one type of data and the child class returns a completely different data type, and it breaks the expected behavior of the system.

In Python, consistent return types are expected in polymorphism; otherwise, your downstream code would fail at runtime.

In my career, I have seen that even small polymorphism mistakes often cause silent failures in production environments.

11. Best Practices for Using Polymorphism in Production

1. You should keep base class methods simple and define clearly what the method is supposed to do. The base class should act as a stable contract so that all child classes can follow it safely.

2. Your child class should change how something is done and should not change what it is supposed to do. In short, the main purpose of the method should not change, and it should remain the same.

3. You should not create deep inheritance chains. Rather, one should combine smaller objects that implement required behavior. This way, it is easier to maintain the system.

4. One should use inheritance only when there is a true “is-a” relationship.

5. One should always test the base contract ( through proper unit testing) so that it can be ensured that all child classes behave correctly and consistently in production environments.

Golden Rule:

The aim of polymorphism should be to simplify design and improve flexibility. If it is making your system confusing, then you are not using polymorphism in a correct way.

12. When to Use Polymorphism and When Not to Use It

In many projects, I have seen that if you use polymorphism in a correct way, then your system becomes stable and easy to extend in the future (based on need).

On the other side, sometimes small applications become very complex because developers have not used polymorphism correctly. So, it becomes very important to use this feature wisely.

1. Use Polymorphism When:

a) If there are multiple objects (different classes) and all these different objects want to perform the same action differently, then polymorphism is the right design choice.

b) If you need to add new modules or features in future releases, then polymorphism is a safe choice for extension.

c) In large enterprise applications like banking, stability is very critical. Polymorphism gives you stability, as you can add new behavior without changing existing logic.

2. Avoid Polymorphism When:

a) If there is only one behavior and you are not expecting any variation, then you should not use polymorphism in those scenarios.

b) If your functionality is small and straightforward, then if you try to use polymorphism, it may over-engineer the solution. My advice is not to introduce abstraction when direct implementation is clearer.

c) If other developers struggle to understand the design and the abstraction is too heavy. Good software design should increase clarity, not decrease it.

13. Production-Grade Real-World Example

Based on my experience, I have never seen that payment systems are written using large if-else blocks (in backend service layers). Instead, we follow such an approach that a new payment system can be added without changing existing code. This type of stability is required in production banking environments where a small mistake can have a large financial impact.

Example:

class PaymentService:
    def pay(self, amount):
        raise NotImplementedError("Subclasses must implement pay() method")


class CreditCardPayment(PaymentService):
    def pay(self, amount):
        print(f"Paying {amount} using credit card")


class UPIPayment(PaymentService):
    def pay(self, amount):
        print(f"Paying {amount} using UPI")


def process_payment(service, amount):
    service.pay(amount)


# Creating objects
credit_payment = CreditCardPayment()
upi_payment = UPIPayment()

# Processing payments
process_payment(credit_payment, 5000)
process_payment(upi_payment, 2000)

Output:

Paying 5000 using credit card
Paying 2000 using UPI

Explanation:

In this code, first we have created a base contract class PaymentService, and it forces all inherited/child classes to implement the pay() method, and this also ensures consistency in large systems as well.

Next, both the child classes CreditCardPayment and UPIPayment override the pay() method, but the implementation for each is done differently.

Next, we define a function process_payment(), and it has two arguments: service and amount. The main point is that this function does not know which payment type it is handling, and inside the function, it calls service.pay(amount), and Python decides at runtime which method it needs to call based on object type, and this is called runtime polymorphism in action.

In the near future, if you need to add a new payment method like Wallet, NetBanking, etc., then those can be added without changing the existing code. So, this approach in frameworks also reduces production risk and helps to keep the system extensible and maintainable.

This is how service-layer architecture is structured in financial applications.

14. Frequently Asked Questions (FAQs) on Python Polymorphism

1. What is polymorphism in Python with real examples for beginners and professionals?

Ans: Polymorphism in Python is an object-oriented programming concept where the same function name, method name, or operator can perform different actions depending on the object or data type used at runtime. 

In simple words, you can say that it has “one interface, multiple behaviors ”. For example, the built-in len() function works with strings, lists, and dictionaries, but its behavior is changed automatically based on the data type. 

In production systems, we use polymorphism on frequently basis by using method overriding, inheritance, operator overloading, and duck typing to build scalable and maintainable applications.

2. What is the difference between method overloading and method overriding in Python polymorphism?

Ans: Python does not support traditional method overloading (like in Java or C++) directly. 

Instead, Python allows default arguments and variable-length arguments to simulate overloading behavior. On the other hand, method overriding is a main part of inheritance-based polymorphism, where a child class provides its own implementation of a method that is already defined in its parent class. 

Overriding supports runtime polymorphism and is mostly used in real-world frameworks and backend service architectures for the purpose of extending the functionality and you don’t need to modify the existing code.

3. How does runtime polymorphism work internally in Python using Method Resolution Order (MRO)?

Ans: Runtime polymorphism in Python works through dynamic binding in Python. In simple words, Python decides which method to execute while the program is running, not at compile time. 

When you call object.method(), Python first checks the object's class, then follows the Method Resolution Order (MRO) to search through parent classes until it finds the correct implementation. 

This mechanism is used to ensure that overridden methods in child classes take precedence over parent class methods and it also makes object-oriented design flexible and extensible for large-scale production applications

4. What is duck typing in Python and how is it different from inheritance-based polymorphism?

Ans: Duck typing in Python is a form of polymorphism where an object type is not checked explicitly. Instead, Python checks only whether the object has the required methods or attributes. Let’s try to understand it with a simple example. For example, if two different classes implement a method with same name speak(), a function can call object.speak() without checking the object's type. 

Unlike inheritance-based polymorphism, duck typing does not require a common base class, making Python programs more flexible and loosely coupled. 

This approach is mostly used in dynamic frameworks and modern Python design patterns.

5. What are the best practices for using polymorphism in production-level Python applications?

Ans: If you want to use polymorphism effectively in scalable Python applications, then Python developers should use the following given key best practices:

• You should always keep method signatures consistent across parent and child classes

• You should avoid deep inheritance hierarchies

• One should always use abstract base classes (abc.ABC) to enforce contracts

• You should maintain consistent return types in overridden methods

• You should always prefer composition over inheritance when appropriate

If you apply these best practices in a correct way, then polymorphism will reduce fragile if-else conditions, improves maintainability, and also, it will make software systems resilient to changing business requirements. 

However, if you would overuse abstraction, then it can increase complexity as well, so you should always remember that polymorphism simplifies design rather than complicating it.

15. Summary

In Python, polymorphism is not just an object-oriented design concept. If you want to build scalable, extensible, and production-grade software applications, then Python polymorphism is a basic design principle.

In simple words, polymorphism means “same interface, different behavior,” as it enables developers to write flexible code where Python determines the behavior at runtime (rather than compile time).

As you have learned till now, Python also supports various forms of polymorphism:

• Function polymorphism

• Class-based polymorphism

• Inheritance-based method overriding

• Operator overloading

• Duck typing

You have also learned that if you apply polymorphism correctly, then it also eliminates fragile if-else chains and reduces defects as well.

One thing to make sure is that it must be used with discipline because unnecessary inheritance or inconsistent method contracts can create hidden complexity as well.

My advice is, if you want to master polymorphism, then one should design systems in such a way that they should be resilient to change, safe for extension, and stable in production as well.