Introduction to Python Polymorphism
Python Polymorphism
Polymorphism is a fundamental concept in object-oriented programming that allows objects of different classes to be treated as objects of a common superclass.
It enables you to write code that can work with objects of different types but perform the appropriate actions based on the specific type of the object.
There are two main forms of polymorphism in Python: method overriding and duck typing.
Method Overriding
Method overriding is a form of polymorphism that occurs when a subclass defines a method with the same name as a method in its superclass.
The subclass's method overrides the implementation of the superclass's method. When the method is called on an object of the subclass, the overridden method in the subclass is executed instead of the superclass's method.
As an example:
class Animal:
def sound(self):
print("Animal makes a sound.")
class Dog(Animal):
def sound(self):
print("Dog barks!")
class Cat(Animal):
def sound(self):
print("Cat meows!")
# Polymorphic behavior
def make_sound(animal):
animal.sound()
dog = Dog()
cat = Cat()
make_sound(dog) # Output: Dog barks!
make_sound(cat) # Output: Cat meows!
In this example:
- The Animal class defines a
sound()
method. - The
Dog
andCat
classes inherit fromAnimal
and override thesound()
method with their own implementations. - The
make_sound()
function accepts anAnimal
object as an argument and calls itssound()
method. - When the
make_sound()
function is called with a Dog object or a Cat object, the appropriate implementation of thesound()
method is executed based on the object's actual type.
Duck Typing
Duck typing is a concept in Python that focuses on the behavior of objects rather than their types.
According to the duck typing principle, "If it walks like a duck and quacks like a duck, then it must be a duck."
In other words, if an object supports a specific set of methods or attributes, it can be considered as having a certain type, regardless of its actual class or inheritance hierarchy.
As an example:
class Duck:
def sound(self):
print("Duck quacks!")
class Car:
def sound(self):
print("Car engine revs!")
# Polymorphic behavior
def make_sound(obj):
obj.sound()
duck = Duck()
car = Car()
make_sound(duck) # Output: Duck quacks!
make_sound(car) # Output: Car engine revs!
In this example:
- The
Duck
andCar
classes have asound()
method. - The
make_sound()
function takes an object as an argument and calls itssound()
method. - As long as an object has a
sound()
method, it can be passed to themake_sound()
function, regardless of its specific class. - This demonstrates duck typing, where the behavior of the object determines its compatibility with the function, rather than its class or inheritance.