What is a polymorphism in Python?

What is a polymorphism in Python?

I'd be happy to explain polymorphism in Python!

Polymorphism is the ability of an object (or a function) to take on multiple forms, depending on the context in which it's used. In other words, polymorphism allows for objects or functions of different classes to be treated as if they were of the same class.

In Python, this can occur through method overriding or method overloading. Let's dive deeper into each:

Method Overriding:

When you override a method, you're essentially providing a new implementation of that method for a specific subclass. This means that when an object of the subclass is called with a particular method, Python will execute the overridden method instead of the original one.

Here's a simple example to illustrate this:

class Animal:
def sound(self):
print("The animal makes a sound.")
class Dog(Animal):
def sound(self):
print("The dog barks.")
my_dog = Dog()
my_dog.sound()  # Output: The dog barks.

In this example, the sound method is overridden in the Dog class. When we create an instance of Dog (i.e., my_dog) and call the sound method on it, Python will execute the overridden sound method from the Dog class instead of the original one from the Animal class.

Method Overloading:

When you overload a method in Python, you're essentially providing multiple implementations of that method for different types or amounts of input. This is useful when you want to perform similar actions based on varying parameters or conditions.

Here's an example of method overloading:

class Calculator:
def add(self, x, y):
print(f"The sum is {x + y}.")
def add(self, x):
print(f"Adding {x}...")
calculator = Calculator()
calculator.add(2)  # Output: Adding 2...
calculator.add(2, 3)  # Output: The sum is 5.

In this example, the add method is overloaded to handle different numbers and combinations of inputs. When we call the add method with just one argument (e.g., calculator.add(2)), Python will execute the version of the add method that takes one argument. If we provide two arguments (e.g., calculator.add(2, 3)), Python will execute the version of the add method that takes two arguments.

In conclusion, polymorphism in Python allows for objects or functions to behave in different ways depending on the context and type of input. This enables you to write more flexible, reusable code that can handle a wide range of scenarios and use cases.

So, there you have it! That's polymorphism in Python – a powerful feature that can simplify your coding life by allowing for greater flexibility and reuseability of code.

Python polymorphism w3schools example

Here's an explanation of Python polymorphism with a w3schools-style example:

What is Polymorphism?

In Python, polymorphism is the ability of an object to take on multiple forms. This means that an object can behave like different types of objects, even if they are not exactly the same type. For example, you could have a function that works with both integers and strings.

Example: A Shape Class

Let's create a Shape class in Python:

class Shape:
def area(self):
pass
def perimeter(self):
pass

We'll create two sub-classes, Rectangle and Circle, that inherit from Shape. Each will override the area method with their own implementation.

Rectangle

class Rectangle(Shape):
def init(self, width, height):
self.width = width
self.height = height
def area(self):
return self.width * self.height

Circle

class Circle(Shape):
def init(self, radius):
self.radius = radius
def area(self):
return 3.14 * (self.radius ** 2)

Now we can create a list of shapes and call the area method on each one:

shapes = [Rectangle(4, 5), Circle(3)]
for shape in shapes:
print(f"The area is: {shape.area()}")

This will output:

The area is: 20
The area is: 28.26

As you can see, the area method works correctly for both the Rectangle and Circle objects, even though they are different types of shapes.

Why is this Polymorphism?

In this example, the Shape class serves as a base or parent class that defines an interface (or contract) for calculating areas. The Rectangle and Circle classes, being subclasses, inherit this interface and add their own implementations. This means we can treat both Rectangle and Circle objects as if they were of type Shape, which is polymorphism.

Polymorphism allows us to write code that can work with different types of data or objects without having to know the specific details about each one beforehand. It's a powerful feature in Python (and many other programming languages!) that enables more flexible and reusable code.

Hope this helps! Let me know if you have any questions or need further clarification.