Python Inheritance

3. Parent Class and Child Class (Core Concepts)

In this program, class A contains common functionality that is shared across the hierarchy.

Class B and C both inherit from class A, which is hierarchical inheritance, because multiple child classes come from the same parent class.

Also, class D is inherited from class B and C, which is multiple inheritance.

So, in the above program, we are using hierarchical inheritance with multiple inheritance.

So the overall structure is called hybrid inheritance.

When obj.show_a() is called, Method Resolution Order (MRO) is followed by Python and it checks classes in the following order:

D → B → C → A → Object

• D doesn’t have show_a()

• B doesn’t have show_a()

• C doesn’t have show_a()

• A does, so Python calls A.show_a()

So, Python calls the method from class A (not from B or C).

This step-by-step lookup is defined by MRO and it ensures that Python always finds the method in a clean and predictable way.

class Parent:
    def my_method(self):
        print("This is the parent method")

class Child(Parent):
    def my_method(self):
        print("This is the child method")

obj = Child()
obj.my_method()

Output :-

This is the child method

Explanation:-

In this example, first we have defined a parent class with a my_method() method.

Next, the child class is defined which overrides the same method with its own implementation.

After that, an object of child class is created and my_method() is called using that object, then the child class method is executed.

This is how method overriding works in Python when a child class provides its own behavior for a parent class method.

Example 2:- Method Overriding in Python

class Report:
    def generate(self):
        print("Generating basic report")

class SalesReport(Report):
    def generate(self):
        super().generate()
        print("Adding sales data to report")

report = SalesReport()
report.generate()

Output:-

Generating basic report
Adding sales data to report

Explanation:-

When we create an object of SalesReport class and call generate() method, Python first looks for the generate() method in the child class.

Since the SalesReport class has its own generate() method, that is executed first.

Inside the child method, super().generate() method is called, so Python first executes the generate() method of parent class (Report).

Once the parent method finishes, Python sends control back to the child class method.

At last, child class adds its own logic and method execution is finished.

This example shows how method overriding with super() method allows a child class to extend parent behavior in a controlled and predictable way.

8. Method Overloading vs Method Overriding in Python

Method overloading means defining multiple methods with the same name but different parameters.

Python doesn’t support traditional overloading like in Java or C++.

If multiple methods with the same name are defined, the last definition overrides earlier ones.

In Python language, you can achieve similar behavior with default arguments or variable length arguments.

Important line: Python does not perform compile-time method selection. The behavior is controlled at runtime inside the method body.

Example 1:- Simple Method Overloading

class A:
    def print_data(self, data=None):
        if data is None:
            print("No data to print")
        else:
            print("Printing:", data)

obj = A()
obj.print_data()
obj.print_data("Report")

Output :-

No data to print
Printing: Report

Explanation:-

In the above program, first we have created a class A.

Inside class A, we have defined a method print_data() with one parameter as data and its default value is set to None.

If we don’t pass any value, then default value data = None is used.

That is why first output is:

No data to print

In next method call, we pass the argument "Report", so the output becomes:

Printing: Report

In brief, in the above example, method behavior changes based on arguments.

As Python doesn’t support true method overloading, that is why we have simulated it using default parameters.

Let us now look at another practical example of method overloading using default arguments in Python.

This time, we will see how the same method can be used for logging messages with different log levels.

Example 2 :- Method Overloading

class Logger:
    def log(self, message, level='INFO'):
        print(f"[{level}] {message}")

obj = Logger()
obj.log("System started")
obj.log("Disk space low", "WARNING")

Output :-

[INFO] System started
[WARNING] Disk space low

Explanation:-

In this example, log() method behaves differently based on the number of arguments.

This is a commonly used real-world pattern which is used to simulate method overloading in Python.

Senior developers prefer this approach and they don’t like writing multiple methods with the same name.

Note:-

See section 7 for Method Overriding.

Method Overloading vs Method Overriding in Python (Key Difference)

9. Access Modifiers in Python

It is a very important topic in Python. Access modifiers in Python are used to control how class variables and methods are accessed from outside a class.

They help in three ways:

• data hiding

• security

• clean object-oriented design

If you want to write maintainable and professional Python code, then you must understand it.

class Employee:
    def __init__(self, name, salary, bonus):
        self.name = name          # public
        self._salary = salary     # protected
        self.__bonus = bonus      # private

emp = Employee("Amit", 40000, 5000)

# Accessing variables from outside the class
print(emp.name)        # public access
print(emp._salary)     # protected access
# print(emp.__bonus)   # This will cause an error

Output: -

Amit
40000

Explanation: -

In the above example, name is a public variable.

That is why emp.name is accessible from outside the class.

Next, _salary is a protected variable.

Python allows accessing it outside the class, but the single underscore is a warning to developers, which means that the protected variable is intended for internal use or subclass use.

Next, __bonus is a private variable, hence it can’t be accessed outside the class.

If you try to access it outside the class, it will show an error (AttributeError).

Example 2: -

class Employee:
    def __init__(self, name, salary, bonus):
        self.name = name          # public
        self._salary = salary     # protected
        self.__bonus = bonus      # private

    def show_details(self):
        print("Name:", self.name)
        print("Salary:", self._salary)
        print("Bonus:", self.__bonus)

class Manager(Employee):
    def show_salary(self):
        print("Manager Salary:", self._salary)

# object creation
emp = Employee("Amit", 50000, 5000)
emp.show_details()

mgr = Manager("Rahul", 80000, 10000)
mgr.show_salary()

Output: -

Name: Amit
Salary: 50000
Bonus: 5000
Manager Salary: 80000

Explanation: -

In this program, first we have created an Employee class with public, protected and private variables to demonstrate access modifiers in Python.

After that, Manager class inherits from Employee class (parent) and is able to access the protected variable _salary, but you cannot directly access the private variable __bonus.

Finally, we have created the objects of both classes and also called their methods to show the data.

10. Method Resolution Order (MRO) in Python

It defines the order in which Python looks for a method or attribute when it is called on an object.

It becomes very important to understand MRO when a class inherits from multiple parent classes.

Understanding MRO helps in three ways:

• It avoids confusion

• It prevents duplicate method calls

• It reduces hidden bugs in inheritance-based Python programs

Why MRO Exists (The Real Problem)

Based on my experience and understanding, MRO exists mainly to solve three practical problems in Python inheritance:

• To decide which method should be called first when multiple parent classes contain methods with the same name.

• To avoid confusion in complex inheritance structures like multiple and hybrid inheritance.

• To ensure a consistent and predictable order of method lookup so that logical bugs and duplicate method calls are prevented.

I have seen lots of bugs in production because developers don’t understand method lookup order.

Simple Example to Understand MRO

Example 1: -

class A:
    def show(self):
        print("Class A")

class B(A):
    def show(self):
        print("Class B")

class C(A):
    def show(self):
        print("Class C")

class D(B, C):
    pass

obj = D()
obj.show()

Output: -

Class B

class Engine:
    def start(self):
        print("Engine started")

class Car:
    def __init__(self):
        self.engine = Engine()   # Car has an Engine

obj = Car()
obj.engine.start()

Explanation: -

First, we define the Engine class and at this stage, no object is created.

At this time, Engine class has only one method start().

After that, we define Car class.

At this point, Python notes that whenever a Car class object is created, its __init__() method will run.

Next, we create an object (obj) of Car class and at this time, Python immediately calls the __init__() method of Car class.

Inside the __init__() method, self refers to Car object (obj) and Engine() creates a new Engine class object and that Engine object is stored inside Car object (obj) as engine.

So, you can say that car.engine refers to Engine class object.

Finally, when following statement is run:

obj.engine.start()

It calls the start() method of Engine object and start() method runs and prints the following message:

Engine started.

class BaseService:
    def __init__(self, service_name):
        self.service_name = service_name

    def execute(self):
        print(f"Starting {self.service_name}")
        self.process()
        print(f"Finished {self.service_name}")

    def process(self):
        raise NotImplementedError("Subclasses must implement this method")


class EmailService(BaseService):
    def __init__(self, service_name, recipient):
        super().__init__(service_name)
        self.recipient = recipient

    def process(self):
        print(f"Sending email to {self.recipient}")


class ReportService(BaseService):
    def __init__(self, service_name, report_type):
       super().__init__(service_name)
       self.report_type = report_type

    def process(self):
        print(f"Generating {self.report_type} report")


# Object Creation and Execution

email_service = EmailService("Email Service", "admin@example.com")
email_service.execute()

report_service = ReportService("Report Service", "Sales")
report_service.execute()

Output: -

Starting Email Service
Sending email to admin@example.com
Finished Email Service
Starting Report Service
Generating Sales report
Finished Report Service

Explanation: -

In this code, first we have defined a parent class named as BaseService, which represents a general service structure.

The __init__() method takes one parameter service_name and this value is stored inside self.service_name.

After that, we have defined an execute() method that defines a common workflow for all services. It performs three steps:

a) Prints: Starting service

b) Calls self.process()

c) Prints: Finished service

Note that process() method is intentionally incomplete and it raises an error:

“Subclasses must implement this method”

This is like an abstract method that forces child classes to implement their own logic.

The second-class name is EmailService which is a child class of BaseService (parent class).

Please note that this class inherits all methods from BaseService class.

Inside this child class, there is a constructor that takes two values as shown below:

def __init__(self, service_name, recipient):

super().__init__(service_name) method is used to call the base class parent class constructor to set service_name and self.recipient stores the email receiver.

You must note that this class adds extra data (recipient) on top of BaseService class.

Next, we have overridden process() method and this is the required implementation of process().

Now, it doesn’t raise an error, rather it prints:

Sending email to <recipient>

So, this is how overriding is done in real projects.

The third class name is ReportService which is also a child class of BaseService (parent class) and it also inherits everything from BaseService class.

This class also has a constructor __init__() that takes two values as shown below:

def __init__(self, service_name, report_type):

Again, super().__init__(service_name) is used to initialize parent part and self.report_type stores the type of report.

This child class has its own process() method version, so it prints:

Generating <report_type> report

Finally, we have created an object email of child class EmailService.

At this point, Python calls the __init__() method of EmailService and the constructor uses super() method to call the __init__() method of BaseService class and it finally initializes service_name and after that it initializes the recipient variable.

Next, we call email.execute() method, then Python runs the inherited execute() method which calls the overridden process() method of EmailService.

Similarly, we have created an object using:

report_service = ReportService("Report Service", "Sales")

and it also initializes service_name and report_type through __init__() method.

When we call report_service.execute() method, it runs the execute() method inherited from parent class (BaseService) and also calls the overridden process() method of ReportService (child class).

16. Frequently Asked Questions (FAQ) on Python Inheritance

17. Summary – Key Takeaways