Introduction

In this lesson, we will delve into advanced Python concepts focusing on inheritance and polymorphism, pivotal pillars of object-oriented programming (OOP). Building on your existing knowledge of classes and objects, we will explore how these principles enhance code reusability and flexibility, enabling developers to write clean, efficient, and scalable Python applications.

Understanding Inheritance in Python

Inheritance allows a class (known as a derived class) to inherit attributes and methods from another class (known as a base class), promoting the reuse of code and establishing a natural hierarchy between classes.

Types of Inheritance

1. Single Inheritance: A derived class inherits from one base class.

   class Vehicle:
       def move(self):
           print("Moving")
   
   class Car(Vehicle):
       pass
   
   c = Car()
   c.move()  # Output: Moving
   

2. Multiple Inheritance: A derived class can inherit from multiple base classes. This allows flexibility but requires careful management to avoid ambiguities.

   class Engine:
       def engine_type(self):
           print("Diesel Engine")
   
   class Wheels:
       def wheel_count(self):
           print("Four wheels")
   
   class Truck(Engine, Wheels):
       pass
   
   t = Truck()
   t.engine_type()  # Output: Diesel Engine
   t.wheel_count()  # Output: Four wheels
   

3. Multi-level Inheritance: A chain of inheritance, where a class inherits from a derived class, which in turn inherits from another base class.

   class Animal:
       def eat(self):
           print("Eating")
   
   class Mammal(Animal):
       def walk(self):
           print("Walking")
   
   class Dog(Mammal):
       def bark(self):
           print("Barking")
   
   d = Dog()
   d.eat()  # Output: Eating
   d.walk()  # Output: Walking
   d.bark()  # Output: Barking
   

Defining Base and Derived Classes

When defining derived classes, use the class DerivedClass(BaseClass): syntax. This allows the derived class to inherit all methods and properties from the base class, which can be overridden if required.

Method Overriding

Method overriding enables a derived class to provide a specific implementation of a method that is already defined in its base class.

class Bird:
    def sound(self):
        print("Chirp")

class Parrot(Bird):
    def sound(self):
        print("Squawk")

p = Parrot()
p.sound()  # Output: Squawk

In this example, Parrot overrides the sound() method of the Bird class.

Exploring Polymorphism in Python

Polymorphism allows methods to do different things based on the object it is acting upon, even if they share the same name. It is often achieved through method overriding and operator overloading.

Example of Polymorphism

Polymorphism can be utilized to streamline processes like iterating through objects in a list, executing methods appropriately:

class Cat:
    def sound(self):
        return "Meow"

class Dog:
    def sound(self):
        return "Woof"

animals = [Cat(), Dog()]

for animal in animals:
    print(animal.sound())  # Output: Meow Woof

In this example, although Cat and Dog both implement a sound method, their polymorphic behavior allows them to return different results when invoked.

Summary / Key Takeaways

By completing this lesson on inheritance and polymorphism in Python, you have accomplished:

• A clear understanding of inheritance, including single, multiple, and multi-level inheritance models.
• The ability to define base and derived classes in Python and their significance.
• Knowledge on how to override methods effectively in derived classes, improving code adaptability.
• Insight into the concept of polymorphism and its practical applications.
• Familiarity with implementing polymorphic behaviors using classes and objects in real-world scenarios.

These concepts are instrumental in structuring your codebase to be more organized, reusable, and scalable in larger software projects.