Learn Polymorphism in Python with Examples

Polymorphism in Python

Main Features Of Python include:

• Beginner-friendly Language – Python is easy to learn, maintain, implement and read. It is interactive in nature.
• Object-Oriented – Python encapsulates code within objects by supporting the Object-Oriented programming approach or style or approach.
• Industry-oriented – Python is extendable, portable, scalable, cross-platform friendly with a standard library, and has support for GUI applications and interactive mode.

What is Polymorphism in Python?

In Python, polymorphisms refer to the occurrence of something in multiple forms. As part of polymorphism, a Python child class has methods with the same name as a parent class method. This is an essential part of programming. A single type of entity is used to represent a variety of types in different contexts (methods, operators, objects, etc.)

Polymorphism may be used in Python in various ways. Polymorphism can be defined using numerous functions, class methods, and objects. So, let us deep-dive into each of these ways.

Polymorphism With Function and Objects

To induce polymorphism using a function, we need to create such a function that can take any object. Here is an example of Polymorphism using functions and objects:

Code

class Dog(): 
    def animal_kingdom(self): 
        print("Mammal") 

    def legs(self):
        print("Four") 

class Lizard(): 
    def animal_kingdom(self): 
        print("Reptile") 

    def legs(self): 
        print("Four") 

def function1(obj): 
    obj.animal_kingdom() 
    obj.legs()

obj_dog = Dog() 
obj_lizard = Lizard() 

function1(obj_dog) 
function1(obj_lizard)

Output

Mammal

Four

Mammal

Four

In the above example, the function, function1() takes in an object named obj, which in turn lets the functions call the methods, animal_kingdom() and legs() of both the classes, Dog and Lizard. To do this, we must create the instances of both classes.

Polymorphism With Class Methods

Let us discuss how to implement Polymorphism in Python using Class Methods. 

In the same way, Python makes use of two separate class types. For this, we design a for loop that iterates through an item tuple. After that, we need to perform method calling without regard for the class type of each object. We take it for granted that these methods have their existence in each of the classes.

A perfect example depicting Polymorphism with Class Methods using Python:

Code

class Car():
    def wheels(self):
        print(4)

    def mode_of_transport(self):
        print("Private usually")

class Bus():
    def wheels(self):
        print(8)

    def mode_of_transport(self):
        print("Public usually") 

obj_car = Car()
obj_bus = Bus()

for vehicle in (obj_car, obj_bus):
    vehicle.wheels()
    vehicle.mode_of_transport()

Output:

4
Private usually
8
Public usually

When we run the code, it will first print “4” and “Private usually” for the Car object and then “8” and “Public usually” for the Bus object.

In the above example, class methods wheels(), mode_of_transport(), which belong to Car and Bus classes, are directly invoked using the instances of these two classes in the for loop, which loops through both the class methods.

Polymorphism With Inheritance

Polymorphism, a child class method is allowed to have the same name as the class methods in the parent class. In inheritance, the methods belonging to the parent class are passed down to the child class. It’s also possible to change a method that a child class has inherited from its parent.

This is typically used whenever a parent class inherited method is not appropriate for the child class. To rectify this situation, we use Method Overriding, which enables re-implementing of a method in a child class.

What Is Method Overriding?

Method overriding is an object-oriented programming technique that lets us change the function implementation of a parent class in the child class. Method overriding is basically a child class’s ability to implement change in any method given by one of its parent classes.

Conditions of Method Overriding:

• There should be inheritance. Within a class, function overriding is not possible, therefore a child class is derived from a parent class.
• A function of the child class should have the same number of parameters as that of the parent class.

We know that in inheritance, a child class gets access to the protected and public methods and variables of the parent class whenever it inherits it. We exploit this concept to implement Polymorphism using Inheritance as well.

A perfect example of Method Overriding and Polymorphism with Inheritance is:

Code

class Vehicle:
    def desc(self):
        print("So many categories of vehicle")

    def wheels(self):
        print("Differs according to the vehicle category")

class car(Vehicle):
    def wheels(self):
        print(4)

class bus(Vehicle):
    def wheels(self):
        print(8)

obj_vehicle = Vehicle()
obj_car = car()
obj_bus = bus()

obj_vehicle.desc()
obj_vehicle.wheels()

obj_car.desc()
obj_car.wheels()

obj_bus.desc()
obj_bus.wheels()

Output:

So many categories of vehicle
Differs according to the vehicle category
So many categories of vehicle
4
So many categories of vehicle
8

In the above code, there is a Vehicle class and two subclasses car and bus which inherit from the Vehicle class. The Vehicle class has two methods desc() and wheels(), where desc() prints a message about different categories of vehicles and wheels() prints a message about the number of wheels which differ according to the vehicle category.

The car class overrides the wheels() method and prints the number of wheels as 4. Similarly, the bus class also overrides the wheels() method and prints the number of wheels as 8.

In the main code, objects of Vehicle, car, and bus are created and their respective methods are called using those objects. The output shows the appropriate messages printed by each method.

Polymorphism is a concept in object-oriented programming where a single function or method can operate on multiple types of objects. In Python, polymorphism can be achieved through the use of inheritance and interfaces.

Here is an example of polymorphism using inheritance:

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        pass


class Dog(Animal):
    def speak(self):
        return "Woof"class Cat(Animal):
    def speak(self):
        return "Meow"def animal_speak(animal):
    print(animal.speak())


dog = Dog("Fido")
cat = Cat("Whiskers")


animal_speak(dog) # "Woof"
animal_speak(cat) # "Me

In this example, the animal_speak function can take an object of any class that inherits from the Animal class, and it will correctly call the speak() method for that class.

You can also achieve polymorphism through the use of interfaces or abstract base classes. Here’s an example:

from abc import ABC, abstractmethod


class Shape(ABC):
    @abstractmethoddef area(self):
        passclass Square(Shape):
    def __init__(self, side):
        self.side = side

    def area(self):
        return self.side * self.side


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


    def area(self):
        return 3.14 * (self.radius ** 2)


def get_shape_area(shape: Shape):
    print(shape.area())


square = Square(4)
circle = Circle(5)


get_shape_area(square) #16
get_shape_area(circle)

In this example, the get_shape_area function can take any object that is an instance of the Shape class or any class that inherits from it, regardless of their specific implementation of the area() method, and it will correctly call the area() method for that class.