Introduction to Polymorphism in Python

Introduction to Polymorphism

Welcome back! We're continuing our journey into object-oriented programming (OOP) with a new and exciting topic: Polymorphism . You've already learned about classes, objects, and inheritance, which are essential building blocks of OOP. Now, it's time to explore how polymorphism can make your code more flexible and reusable.

Understanding Polymorphism

Polymorphism in Python allows you to call derived class methods through a base class reference. This can make your code more dynamic and general. Essentially, polymorphism enables methods to do different things based on the object it is acting upon, even if they share the same name. When a method in a derived class has the same name as a method in its base class, the derived class method overrides the method in the base class. This ensures that the call to the method runs the derived class's version of the method, allowing the same method call to perform different tasks depending on the object it is acting upon.

Method Overriding

As we briefly touched on in the previous lesson, method overriding occurs when a derived class provides a specific implementation of a method that is already defined in its base class. The method in the derived class overrides the corresponding method in the base class. This allows the derived class to offer a specific behavior while still maintaining the same method signature. Imagine different animals like birds, fish, and dogs. Each animal can eat(), move(), and speak() . Even though these actions have the same name for each animal, the implementation for eating, moving, and speaking can vary: Bird : Moving might involve flying. Fish : Moving might involve swimming. Dog : Moving might involve running. Despite these differences, a single interface (move() method) allows us to handle all animal types polymorphically. Here’s an example: Python class Animal: def speak(self): print("Animal speaks") class Dog(Animal): def speak(self): print("Dog barks") if __name__ == "__main__": generic_animal = Animal() generic_animal.speak() # Output: Animal speaks dog = Dog() dog.speak() # Output: Dog barks In this snippet, the Dog class overrides the speak method of the Animal class. When the speak method is called on an instance of Dog, the overridden method in Dog is executed instead of the method in Animal . In contrast to the previous lesson's example, we do not call super().speak() here because we intend to completely override the method from the parent class.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Updated Example with Polymorphism:

Let's expand our initial Person, Student, and Teacher example to include a function that can accept any Person object and demonstrate polymorphism:

Python

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def display(self):
        print(f"Name: {self.name}, Age: {self.age}")

class Student(Person):
    def __init__(self, name, age, major):
        super().__init__(name, age)
        self.major = major

    def display(self):
        super().display()
        print(f"Major: {self.major}")

class Teacher(Person):
    def __init__(self, name, age, subject):
        super().__init__(name, age)
        self.subject = subject

    def display(self):
        super().display()
        print(f"Subject: {self.subject}")

def show_person_info(person):
    person.display()

if __name__ == "__main__":
    student = Student("Alice", 30, "Computer Science")
    teacher = Teacher("Bob", 25, "Mathematics")

    show_person_info(student)
    # Output:
    # Name: Alice, Age: 30
    # Major: Computer Science
    
    show_person_info(teacher)
    # Output:
    # Name: Bob, Age: 25
    # Subject: Mathematics

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def display(self):
        print(f"Name: {self.name}, Age: {self.age}")

class Student(Person):
    def __init__(self, name, age, major):
        super().__init__(name, age)
        self.major = major

    def display(self):
        super().display()
        print(f"Major: {self.major}")

class Teacher(Person):
    def __init__(self, name, age, subject):
        super().__init__(name, age)
        self.subject = subject

    def display(self):
        super().display()
        print(f"Subject: {self.subject}")

def show_person_info(person):
    person.display()

if __name__ == "__main__":
    student = Student("Alice", 30, "Computer Science")
    teacher = Teacher("Bob", 25, "Mathematics")

    show_person_info(student)
    # Output:
    # Name: Alice, Age: 30
    # Major: Computer Science
    
    show_person_info(teacher)
    # Output:
    # Name: Bob, Age: 25
    # Subject: Mathematics

In this updated example, we defined a function show_person_info that takes an instance of Person as a parameter. This function calls the display method on the person parameter. Thanks to polymorphism, this function can accept both Student and Teacher objects (which are derived from Person). When show_person_info is called with a Student or Teacher object, the appropriate display method defined in the derived class is executed, demonstrating polymorphism in action.

Introduction to Polymorphism in Python