Python Multilevel Inheritance

Introduction

Multilevel inheritance is a type of inheritance in which a class (called the child or subclass) inherits from another class (called the parent or superclass), which in turn inherits from another class. This creates a chain of inheritance, where each class inherits attributes and methods from its predecessor.

Key Concepts

Grandparent Class

The top-most class in the inheritance chain.

Parent Class

The class that inherits from the grandparent class.

Child Class

The class that inherits from the parent class.

Multilevel Inheritance

Description: A class (child class) inherits from another class (parent class), which in turn inherits from another class (grandparent class).

  +---------+
  | Class A |
  +---------+
       |
       |
  +---------+
  | Class B |
  +---------+
       |
       |
  +---------+
  | Class C |
  +---------+

Syntax

Defining a Grandparent Class

class GrandparentClass:
    def __init__(self, attribute1):
        self.attribute1 = attribute1

    def method1(self):
        return "This is method1 from GrandparentClass"

Defining a Parent Class

class ParentClass(GrandparentClass):
    def __init__(self, attribute1, attribute2):
        super().__init__(attribute1)  # Inheriting from GrandparentClass
        self.attribute2 = attribute2

    def method2(self):
        return "This is method2 from ParentClass"

Defining a Child Class

class ChildClass(ParentClass):
    def __init__(self, attribute1, attribute2, attribute3):
        super().__init__(attribute1, attribute2)  # Inheriting from ParentClass
        self.attribute3 = attribute3

    def method3(self):
        return "This is method3 from ChildClass"

Example

Let’s consider a real-world example of a family hierarchy, where the Grandparent, Parent, and Child classes represent three generations.

Grandparent Class: Grandparent

class Grandparent:
    def __init__(self, name):
        self.name = name

    def get_name(self):
        return f"Grandparent: {self.name}"

Parent Class: Parent

class Parent(Grandparent):
    def __init__(self, name, occupation):
        super().__init__(name)  # Inheriting from Grandparent
        self.occupation = occupation

    def get_occupation(self):
        return f"Occupation: {self.occupation}"

Child Class: Child

class Child(Parent):
    def __init__(self, name, occupation, school):
        super().__init__(name, occupation)  # Inheriting from Parent
        self.school = school

    def get_school(self):
        return f"School: {self.school}"

Creating and Using Objects

# Creating an object of the Child class
child = Child("Ramesh", "Engineer", "Greenwood High")

# Displaying information using methods from all three classes
print(child.get_name())         # Output: Grandparent: Ramesh
print(child.get_occupation())   # Output: Occupation: Engineer
print(child.get_school())       # Output: School: Greenwood High

Explanation

1. Grandparent Class (Grandparent): Defines an attribute (name) and a method (get_name).
2. Parent Class (Parent): Inherits from Grandparent, adds an attribute (occupation), and a method (get_occupation).
3. Child Class (Child): Inherits from Parent, adds an attribute (school), and a method (get_school).

Real-World Example: Company Hierarchy

Let’s consider a real-world example of a company hierarchy, where we have an Employee class, a Manager class that inherits from Employee, and a Director class that inherits from Manager.

Grandparent Class: Employee

class Employee:
    def __init__(self, name, employee_id):
        self.name = name
        self.employee_id = employee_id

    def get_details(self):
        return f"Employee Name: {self.name}, ID: {self.employee_id}"

Parent Class: Manager

class Manager(Employee):
    def __init__(self, name, employee_id, department):
        super().__init__(name, employee_id)  # Inheriting from Employee
        self.department = department

    def get_department(self):
        return f"Department: {self.department}"

Child Class: Director

class Director(Manager):
    def __init__(self, name, employee_id, department, region):
        super().__init__(name, employee_id, department)  # Inheriting from Manager
        self.region = region

    def get_region(self):
        return f"Region: {self.region}"

Creating and Using Objects

# Creating an object of the Director class
director = Director("Sita", "D001", "Engineering", "North America")

# Displaying information using methods from all three classes
print(director.get_details())      # Output: Employee Name: Sita, ID: D001
print(director.get_department())   # Output: Department: Engineering
print(director.get_region())       # Output: Region: North America

Explanation

1. Grandparent Class (Employee): Defines common attributes (name, employee_id) and a method (get_details) for all employees.
2. Parent Class (Manager): Inherits from Employee, adds an attribute (department), and a method (get_department).
3. Child Class (Director): Inherits from Manager, adds an attribute (region), and a method (get_region).

Conclusion

Multilevel inheritance in Python allows a class to inherit attributes and methods from a parent class, which in turn inherits from another class. This creates a hierarchy of classes that promotes code reusability and logical structure. By understanding and utilizing multilevel inheritance, you can design more organized and maintainable object-oriented systems. The provided examples of a family hierarchy and a company hierarchy demonstrate how multilevel inheritance can be effectively applied in real-world scenarios.