Learn Polymorphism in Python with Examples.pdf

www.datacademy.ai
Knowledge world
Learn Polymorphism in Python with Examples
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”)

www.datacademy.ai
Knowledge world
class Lizard():
def animal_kingdom(self):
print(“Mammal”)
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

www.datacademy.ai
Knowledge world
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()

www.datacademy.ai
Knowledge world
vehicle.mode_of_transport()
Output
4
Private usually
8
Public usually
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.

www.datacademy.ai
Knowledge world
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 wheel(self):
print(8)
obj_vehicle = Vehicle()
obj_car = car()
obj_bus = bus()
obj_vehicle.desc()
obj_vehicle.wheels()

www.datacademy.ai
Knowledge world
obj_car.desc()
obj_car.wheels()
obj_bus.desc()
obj_bus.wheels()
Output
So many categories of vehicle
Differs according to the vehicle category
4
Differs according to the vehicle category
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

www.datacademy.ai
Knowledge world
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:

www.datacademy.ai
Knowledge world
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)

www.datacademy.ai
Knowledge world
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.

Learn Polymorphism in Python with Examples.pdf

More Related Content

Similar to Learn Polymorphism in Python with Examples.pdf (20)

More from Datacademy.ai (16)

Recently uploaded (20)

Learn Polymorphism in Python with Examples.pdf