Polymorphism is a concept you will often find yourself implementing in code, especially in python. Polymorphism means essentially taking different forms. For example, a function implementing polymorphism might accept different types and not just a specific type.
There are different ways to show polymorphism in python. I will enumerate some here.
1. Python polymorphism with functions and objects.
In this implementation of polymorphism, a function can take objects belonging to different classes and carry out operations on them without any regard for the classes. One common example of this is the python len function, or what is called the python length function. You can read my blog post on the python length function here.
Here is an example of how the python length function implements polymorphism.
You can see from the above code that the python len function can take a str object as argument as well as a list object as argument. These two objects belong to different classes.
Now, not only can built-in functions exhibit polymorphism, we can use it in our custom classes.
I believe you have followed through with the earlier posts on python OOP so the example classes are self-explanatory. If not, you can get the links at the end of this post. I will just dwell on the print_talk function. You can see that we invoked the function in the for loop after creating the dog and person objects. Each time the print_talk function is invoked, different objects are passed to it and it successfully invoked their talk methods. Different objects but same function and different behavior.
2. Polymorphism with inheritance
Polymorphism with inheritance has been discussed in the python OOP inheritance post. I will just briefly highlight it here. It involves a method of the child class overriding the methods of the parent class. The code above shows it but let me point it out again. The method of the child class has the same name and arguments as the method of the parent class but the implementation of the method is different.
class Animal:
type = 'Animal'
def __init__(self, name):
''' name is a string '''
self.name = name
def talk(self):
print(f'My name is {self.name} and I can talk')
def walk(self):
print(f'My name is {self.name} and I can walk')
class Dog(Animal):
legs = 4
def __init__(self, name, bark):
Animal.__init__(self, name)
self.bark = bark
def talk(self):
print(f'My name is {self.name} and
I can bark: "{self.bark}"')
def walk(self):
print(f'My name is {self.name} and
I walk with {self.legs} legs')
From, the code above you can see that the Dog class inherits from the Animal class. The Dog class overrides the talk and walk methods of the Animal class and implements them differently. That is what polymorphism in inheritance is all about.
As your skill with python increases, you will find yourself implementing polymorphism in a lot of instances. It is a feature of python that is commonplace.
I hope you enjoyed my three part series on how OOP is implemented in python. The first part was on OOP in python classes and objects, the second part was on OOP in python class inheritance and this is the third part. I hope you have learned something new about python and will be determined to implement these features in your coding.
Happy pythoning.
No comments:
Post a Comment
Your comments here!