Python Polymorphism Examples Tutorial – Complete Guide

Welcome to an exciting journey into the world of Python programming. In this tutorial, we’ll delve into the realm of polymorphism, a crucial concept in the object-oriented programming paradigm. Here, we aim to make learning engaging, straightforward and powerful as we metabolize complex ideas using simple game mechanics and relatable examples.

What is Polymorphism?

Polymorphism, derived from the Greek words ‘poly’, meaning ‘many’, and ‘morph’, meaning ‘form’, is a principle in object-oriented programming (OOP) that allows objects to take on many forms. This principle enables us to use a single type of interface with different underlying forms such as data types or classes, thus enhancing the flexibility and interactivity of our codes.

Why is Polymorphism Important?

Understanding and implementing polymorphism offers several advantages:

  • The ability to implement objects in a manner that they can take-on multiple forms increases the versatility of your code.
  • Code maintainability and readability are improved. This can be particularly useful when working on large-scale projects or collaborating with other programmers.
  • Polymorphism promotes reusability, a key factor in efficient software development. As code can be more generic and versatile, it can be reused across multiple programming contexts.

In essence, polymorphism is a powerful tool in a programmer’s toolkit that enhances code efficiency, readability, and reusability, hence it’s an essential concept to understand and apply in your coding journey. Let’s start putting this concept into practice in the next section of this tutorial.

Getting Started with Polymorphism

To begin our exploration of polymorphism, let’s consider a simple game mechanism, a generic game character. All game characters may have a common action like ‘attack’, but the type of attack varies based on the character class – it could be a ‘wizard’, ‘warrior’, or ‘archer’.

#Defining the game character classes
class Wizard:
    def attack(self):
        return "The wizard casts a spell!"

class Warrior:
    def attack(self):
        return "The warrior swings his sword!"

class Archer:
    def attack(self):
        return "The archer fires an arrow!"

Each character class is defined with an ‘attack’ method. However, as per their specific class, they perform this common action in a different way. This is a basic example of polymorphism, where the ‘attack’ method takes multiple forms based on the class context in which it is called.

In the next section, we’ll continue our exploration of polymorphism, diving deeper with more examples. We’ll also introduce you to ‘method overriding’ and ‘operator overloading’, two powerful applications of polymorphism in Python. Stay with us on this exciting journey.

CTA Small Image
FREE COURSES AT ZENVA
LEARN GAME DEVELOPMENT, PYTHON AND MORE
ACCESS FOR FREE
AVAILABLE FOR A LIMITED TIME ONLY

Sure, let’s continue our Python adventure with deeper explorations into polymorphism. In this part of the tutorial, we shall excavate some real-world examples, showcasing how polymorphism is applied in Python.

Method Overriding in Python

Method overriding is a concept where the child class provides a different implementation of a method that is already present in its parent class. In polymorphism, method overriding is used to alter or extend the default behavior parent’s method.

#Defining the parent class
class Animal:
    def sound(self):
        return "The animal makes a sound"
        
#Defining the child classes with overriding methods
class Dog(Animal):
    def sound(self):
        return "The dog barks"

class Cat(Animal):
    def sound(self):
        return "The cat meows"

In the above example, the `sound` method in the `Animal` class is overridden by the `Dog` and `Cat` classes to provide their specific sounds.

Method Overloading in Python

In Python, method overloading is a bit tricky compared to other languages. To implement method overloading, we could either use optional or default arguments, or we can even work with variable-length arguments (*args or **kwargs).

class Circle:
    def area(self, rad, pi=3.14):
        return pi * rad**2

In this example, we ‘overloaded’ the area method in Circle class by making the `pi` parameter optional, thus allowing to obtain the area for both ‘exact’ pi and ‘approximate’ pi.

Polymorphism in Built-In Python Functions

Built-in Python functions too incorporate the principle of polymorphism. The `len()` function, for example, can be used to get the length of different data types.

#Length of a list
print(len([1, 2, 3, 4]))

#Length of a string
print(len('Python'))

To summarize

Polymorphism in Python, like in other object-oriented programming languages, allows us to have more dynamic interactions with objects, thus enabling us to create more flexible and maintainable code. Through the power of method overriding, method overloading, and even in built-in functions, the principle of polymorphism holds strong, making it a cornerstone to leverage in your Python programming journey.

Stay tuned. In the next section, we’ll provide even more illuminating examples of polymorphism, along with some practice exercises to try your hands at this building block of object-oriented programming.Sure, let’s delve deeper into the realm of polymorphism with some enlightening examples and experiences. Our focus in this section will be on using the Python’s `super()` function, multiple inheritance, and at last, we’ll see polymorphism in action with a real-world example.

Using super() with Polymorphism

Python’s `super()` function allows us to call methods from the parent class inside a child class. It can be incredibly useful when using polymorphism, as it offers a way to take advantage of inherited methods while implementing custom behavior.

class Bird:
    def introduction(self):
        return "I am a bird."
    def whoisThis(self):
        return "Bird"

class Sparrow(Bird):
    def whoisThis(self):
        return super().whoisThis() + ", Sparrow"

sparrow1 = Sparrow()
print(sparrow1.introduction()) #Output: I am a bird.
print(sparrow1.whoisThis()) #Output: Bird, Sparrow

Multiple Inheritance and Polymorphism

Multiple inheritance is an integral feature of Python, where a class can be inherited from more than one parent class. It provides a great platform for the application of polymorphism.

#Defining the parent classes
class Employee:
    def designation(self):
        return "Employee"

class Person:
    def identity(self):
        return "Person"

#Defining the child class
class Manager(Employee, Person):
    def designation(self):
        return "Manager"
    def identity(self):
        return "Manager, " + super().identity()

#Using the child class
manager1 = Manager()
print(manager1.designation()) #Output: Manager
print(manager1.identity()) #Output: Manager, Person

Real-World Example: Vehicle Class

A typical example where polymorphism is used is in implementing a vehicle class. All vehicles share characteristics like having a type or the ability to move, but these characteristics could behave differently based on the specific vehicle.

class Vehicle:
    def type_of_vehicle(self):
        return "I am a vehicle."
    def movement(self):
        return "I can move."

class Car(Vehicle):
    def type_of_vehicle(self):
        return "I am a Car."
    def movement(self):
        return "I drive on roads."

class Boat(Vehicle):
    def type_of_vehicle(self):
        return "I am a Boat."
    def movement(self):
        return "I sail on water."

for vehicle in (Car(), Boat()):
    print(vehicle.type_of_vehicle())
    print(vehicle.movement())

In the above examples, we’ve put Python’s polymorphism into practical practice. The benefits of using polymorphism, especially the enhanced flexibility and structure it brings to your code, should be becoming clear.

Remember, learning any concept, especially as deep as polymorphism is like learning a new sport, your skills and understanding grow with practice. So, keep experimenting with codes, explore different examples, and most importantly, keep coding.

Where to go Next?

With the foundational knowledge of polymorphism now firmly rooted, you might ask, “What’s next on my Python voyage?”

For those looking to gain a comprehensive view of Python programming, our Python Mini-Degree offers a well-sorted curriculum. The mini-degree captures the A-Z of Python in an easy-to-follow format that encourages learning by doing.

While the collection does cover the basics, it has so much more to offer for those who’ve already gotten their feet wet in Python. Throughout the curriculum, you’ll engage in the creation of actual games, algorithms, and real-world apps ensuring your learning sticks and can be put into practical use straight away.

Python’s popularity in today’s world cannot be overstated. Its presence is vigorously felt in various industries like data science, machine learning, and robotics. The Python Mini-Degree ensures you’re well-equipped to navigate and excel in these sectors.

Also, explore our broader Python courses to diversify your learning. With over 250 supported courses, we have specific curricula that focus on precise goals and skillsets, providing you with the tailored learning experience you need to boost your career.

Keep Learning With Zenva

At Zenva, we are ardent about enabling anyone, regardless of their circumstance, to acquire the digital skills necessary to excel in their career. With us, you can go from beginner to professional, armed with a strong portfolio and a breadth of knowledge to impress. So, continue your journey with Zenva, and let’s write the future, one line of code at a time.

Conclusion

Mastering the Python language and understanding the object-oriented concepts like polymorphism can seem intimidating at first, but with Zenva by your side, you can rest assured that you’re on a well-trodden, practical, and rewarding path. The world of modern software development is influenced heavily by Python and, without a doubt, polymorphism is an integral part of it.

Remember, each line of code you write, every error you encounter and debug, and each concept you learn is a vital step forward in your learning journey. Encountering concepts like polymorphism means you’re delving deeper into the world of Python, honing your skills, and moving closer to your coding goals. Take a step further today by exploring our Python Mini-Degree. Let’s keep the learning journey ongoing and challenging. Your Python adventure has just started!

Did you come across any errors in this tutorial? Please let us know by completing this form and we’ll look into it!

FREE COURSES
Python Blog Image

FINAL DAYS: Unlock coding courses in Unity, Godot, Unreal, Python and more.