How To Apply Polymorphism to Classes in Python 3

Updated on August 20, 2021
How To Apply Polymorphism to Classes in Python 3


Polymorphism is the ability to leverage the same interface for different underlying forms such as data types or classes. This permits functions to use entities of different types at different times.

For object-oriented programming in Python, this means that a particular object belonging to a particular class can be used in the same way as if it were a different object belonging to a different class.

Polymorphism allows for flexibility and loose coupling so that code can be extended and easily maintained over time.

This tutorial will go through applying polymorphism to classes in Python.


You should have Python 3 installed and a programming environment set up on your computer or server. If you don’t have a programming environment set up, you can refer to the installation and setup guides for a local programming environment or for a programming environment on your server appropriate for your operating system (Ubuntu, CentOS, Debian, etc.)

What Is Polymorphism?

Polymorphism is an important feature of class definition in Python that is utilized when you have commonly named methods across classes or subclasses. This allows functions to use objects of any of these polymorphic classes without needing to be aware of distinctions across the classes.

Polymorphism can be carried out through inheritance, with subclasses making use of base class methods or overriding them.

Python’s duck typing, a special case of dynamic typing, uses techniques characteristic of polymorphism, including late binding and dynamic dispatch. The term “duck typing” is derived from a quote of writer James Whitcomb Riley: “When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.” Appropriated by Italian computer engineer Alex Martelli in a message to the comp.lang.python newsgroup, the use of duck typing is concerned with establishing the suitability of an object for a specific purpose. When using normal typing this suitability is determined by the type of an object alone, but with duck typing the presence of methods and properties are used to determine suitability rather than the actual type of the object in question. That is to say, you check whether the object quacks like a duck and walks like a duck rather than asking whether the object is a duck.

When several classes or subclasses have the same method names, but different implementations for these same methods, the classes are polymorphic because they are using a single interface to use with entities of different types. A function will be able to evaluate these polymorphic methods without knowing which classes are invoked.

Creating Polymorphic Classes

To make use of polymorphism, we’re going to create two distinct classes to use with two distinct objects. Each of these distinct classes need to have an interface that is in common so that they can be used polymorphically, so we will give them methods that are distinct but that have the same name.

Info: To follow along with the example code in this tutorial, open a Python interactive shell on your local system by running the python3 command. Then you can copy, paste, or edit the examples by adding them after the >>> prompt.

We’ll create a Shark class and a Clownfish class, each of which will define methods for swim(), swim_backwards(), and skeleton().

class Shark():
    def swim(self):
        print("The shark is swimming.")

    def swim_backwards(self):
        print("The shark cannot swim backwards, but can sink backwards.")

    def skeleton(self):
        print("The shark's skeleton is made of cartilage.")

class Clownfish():
    def swim(self):
        print("The clownfish is swimming.")

    def swim_backwards(self):
        print("The clownfish can swim backwards.")

    def skeleton(self):
        print("The clownfish's skeleton is made of bone.")

In the code above, both the Shark and Clownfish class have three methods with the same name in common. However, each of the functionalities of these methods differ for each class.

Let’s instantiate these classes into two objects:

sammy = Shark()

casey = Clownfish()

When we run the program with the python polymorphic_fish.py command, we can see that each object behaves as expected:

The shark's skeleton is made of cartilage. The clownfish's skeleton is made of bone.

Now that we have two objects that make use of a common interface, we can use the two objects in the same way regardless of their individual types.

Polymorphism with Class Methods

To show how Python can use each of these different class types in the same way, we can first create a for loop that iterates through a tuple of objects. Then we can call the methods without being concerned about which class type each object is. We will only assume that these methods actually exist in each class.

sammy = Shark()

casey = Clownfish()

for fish in (sammy, casey):

We have two objects, sammy of the Shark class, and casey of the Clownfish class. Our for loop iterates through these objects, calling the swim(), swim_backwards(), and skeleton() methods on each.

When we run the program, the output will be as follows:

The shark is swimming. The shark cannot swim backwards, but can sink backwards. The shark's skeleton is made of cartilage. The clownfish is swimming. The clownfish can swim backwards. The clownfish's skeleton is made of bone.

The for loop iterated first through the sammy instantiation of the Shark class, then the casey object of the Clownfish class, so we see the methods related to the Shark class first, then the Clownfish class.

This shows that Python is using these methods in a way without knowing or caring exactly what class type each of these objects is. That is, using these methods in a polymorphic way.

Polymorphism with a Function

We can also create a function that can take any object, allowing for polymorphism.

Let’s create a function called in_the_pacific() which takes in an object we can call fish. Though we are using the name fish, any instantiated object will be able to be called into this function:

def in_the_pacific(fish):

Next, we’ll give the function something to do that uses the fish object we passed to it. In this case we’ll call the swim() methods, each of which is defined in the two classes Shark and Clownfish:

def in_the_pacific(fish):

Next, we’ll create instantiations of both the Shark and Clownfish classes if we don’t have them already. With those, we can call their action using the same in_the_pacific() function:

def in_the_pacific(fish):

sammy = Shark()

casey = Clownfish()


When we run the program, the output will be as follows:

The shark is swimming. The clownfish is swimming.

Even though we passed a random object (fish) into the in_the_pacific() function when defining it, we were still able to use it effectively for instantiations of the Shark and Clownfish classes. The casey object called the swim() method defined in the Clownfish class, and the sammy object called the swim() method defined in the Shark class.


By allowing different objects to leverage functions and methods in similar ways through polymorphism, making use of this Python feature provides greater flexibility and extendability of your object-oriented code.

Thanks for learning with the DigitalOcean Community. Check out our offerings for compute, storage, networking, and managed databases.

Learn more about our products

Tutorial Series: How To Code in Python

Python is a flexible and versatile programming language that can be leveraged for many use cases, with strengths in scripting, automation, data analysis, machine learning, and back-end development. It is a great tool for both new learners and experienced developers alike.

Tutorial Series: Object-Oriented Programming in Python 3

Object-oriented programming (OOP) focuses on creating reusable patterns of code, in contrast to procedural programming, which focuses on explicit sequenced instructions. When working on complex programs in particular, object-oriented programming lets you reuse code and write code that is more readable, which in turn makes it more maintainable.

About the authors

Still looking for an answer?

Ask a questionSearch for more help

Was this helpful?

This textbox defaults to using Markdown to format your answer.

You can type !ref in this text area to quickly search our full set of tutorials, documentation & marketplace offerings and insert the link!

i hope you realize that, 99% of people coming here are new to python…and you are litteraly missleading everybody whos reading this… not to mention other things one of the most horrible things to do while explaining this kind of thing to a newbie is using words like leverage and underlying, especially to somebody whos native language is not a english,since words you are using sometimes have different meannings in different languages. ignoring this fact makes you horrible teacher. please stop doing this and dont do crime against knowledge. knowledge is the freedom and you are against that. and if you dont want to stop atleast learn how to write not only for yourself.

Hi Lisa,

I am new to programming and completely new to Python. Your post here make it so easy to learn/follow even for a total beginner like me. I was wondering if you have already or have plan for the next advance addition to this tutoring?

One suggestion, maybe some practice assignments/tests related to the material covered.

Great tutoring material!!! Looking forward to more of your tutoring lessons.

IMO you are conflating the two distinct concepts of duck typing and polymorphism. What you have outlined in your examples strike me as just examples of the usage of duck typing and NOT polymorphism (and in python [not sure about other duck typed languages] I am not even sure if it even makes sense to describe polymorphism). In a language like C++, polymorphism was achieved vie inheritance and overriding parent methods in child objects. Doing the same in python strikes me just as simple inheritance. http://stackoverflow.com/questions/11502433/what-is-the-difference-between-polymorphism-and-duck-typing.

However… if the behavior quacks like polymorphism, walks like polymorphism… then…

Try DigitalOcean for free

Click below to sign up and get $200 of credit to try our products over 60 days!

Sign up

Join the Tech Talk
Success! Thank you! Please check your email for further details.

Please complete your information!

Featured on Community

Get our biweekly newsletter

Sign up for Infrastructure as a Newsletter.

Hollie's Hub for Good

Working on improving health and education, reducing inequality, and spurring economic growth? We'd like to help.

Become a contributor

Get paid to write technical tutorials and select a tech-focused charity to receive a matching donation.

Welcome to the developer cloud

DigitalOcean makes it simple to launch in the cloud and scale up as you grow — whether you're running one virtual machine or ten thousand.

Learn more
DigitalOcean Cloud Control Panel