A Complete Guide - Python Programming Inheritance and Method Overriding

Last Updated: 03 Jul, 2025

YOU NEED ANY HELP? THEN SELECT ANY TEXT.

Python Programming: Inheritance and Method Overriding

Introduction to Inheritance

Benefits of Inheritance

Code Reusability: Child classes can reuse code from their parent classes.
Extensibility: You can extend the functionality of existing classes without modifying them.
Hierarchical Classification: Helps in creating a clear hierarchical structure for the codebase.
Maintainability: Simplifies debugging and maintenance when code is organized through inheritance.

Creating Base Class

To create a base class, you simply define a class with its properties and methods. Here's an example:

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

    def speak(self):
        raise NotImplementedError("Subclasses must implement abstract method")

In this code, the Animal class serves as a base class with a constructor and a generic speak() method which is not implemented, indicating that subclasses should provide their own version of this method.

Creating Subclass

A subclass inherits from the base class using the syntax class DerivedClassName(BaseClass). Here’s how you can create a subclass in Python:

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)
        self.breed = breed

    def speak(self):
        return f"{self.name} barks."

Dog is a subclass of Animal.
super().__init__(name) calls the constructor of the parent class Animal, passing the argument name to it.
The speak() method in the Dog class performs an action specific to Dog objects, overriding the speak() method in the Animal base class.

Types of Inheritance in Python

Single Inheritance: A derived class inherits from only one base class.
Multiple Inheritance: A derived class inherits from more than one base class.
Multilevel Inheritance: A derived class inherits from another derived class, forming a chain.
Hierarchical Inheritance: Multiple derived classes inherit from a single base class.

Example of Hierarchical Inheritance:

class Cat(Animal):
    def __init__(self, name, color):
        super().__init__(name)
        self.color = color

    def speak(self):
        return f"{self.name} meows."

Here both Dog and Cat are subclasses of Animal, demonstrating hierarchical inheritance.

Method Overriding

Method overriding occurs when a method in a derived class has the same name as a method in its parent class. The overridden method in the derived class completely replaces the method in the base class.

# Example from above
class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)
        self.breed = breed

    def speak(self):
        return f"{self.name} barks."

In this snippet, Dog subclasses Animal and overrides the speak method to add dog-specific functionality. This allows each subclass to have its unique behavior while maintaining consistency with the base class interface.

Key Points to Remember

Constructor Inheritance: Use super().__init__() to initialize base class attributes.
Abstract Methods: The base class might define abstract methods using the NotImplementedError or ABC module, which must be overridden by subclasses.
Duck Typing: Python emphasizes duck typing meaning whether a function works depends on the presence of method/attribute rather than explicit type inheritance.
Polymorphism: The ability to have different methods with the same name is an important concept in polymorphism within Python.

Real-world Examples

Suppose you're creating a game and have a Character class for all game entities. You could then create subclasses like Hero, Enemy, NPC that each share common attributes and methods but override specifics:

class Character:
    def __init__(self, name, health):
        self.name = name
        self.health = health

    def describe(self):
        return f"{self.name}, health: {self.health}"

class Hero(Character):
    def __init__(self, name, health, armor):
        super().__init__(name, health)
        self.armor = armor

    def describe(self):
        return f"Hero {self.name}, health: {self.health}, armor: {self.armor}"

class Enemy(Character):
    def __init__(self, name, health, power):
        super().__init__(name, health)
        self.power = power

    def describe(self):
        return f"Enemy {self.name}, health: {self.health}, power: {self.power}"

Different types of characters, heroes, and enemies, all inheriting from a general Character base class yet having distinct behaviors through method overriding.

Applications of Inheritance and Method Overriding

Framework Design: Libraries and frameworks often use inheritance to provide standardized behavior that can be customized by users.
Game Development: Different game entities can share common functionality, with specific behaviors defined in subclasses.
Simulation Models: Simulating real-world systems where components follow a shared interface but exhibit different behaviors.
GUI Toolkits: Creating custom components by extending widgets provided in GUI toolkits.

Online Code run

🔔 Note: Select your programming language to check or run code at

💻 Run Code Compiler

Step-by-Step Guide: How to Implement Python Programming Inheritance and Method Overriding

Step 1: Define the Base Class

First, we will define a base class named Animal. This class will have some common attributes and methods that can be shared by any animal:

class Animal:
    def __init__(self, species):
        self.species = species
    
    def speak(self):
        return f"An {self.species} makes a generic sound."

Step 2: Create Derived Classes with Inheritance

Now, we will create two derived classes Dog and Cat, which inherit from the Animal class.

class Dog(Animal):
    def __init__(self, name):
        # Call the superclass constructor
        super().__init__("Dog")
        self.name = name
    
    # Override the speak method
    def speak(self):
        return f"{self.name} barks."

class Cat(Animal):
    def __init__(self, name):
        super().__init__("Cat")
        self.name = name
    
    # Override the speak method
    def speak(self):
        return f"{self.name} meows."

Step 3: Create Instances and Test Inheritance and Method Overriding

Next, we will create instances of the derived classes and call their methods to see how inheritance and method overriding work.

# Creating instances of Dog and Cat
dog_instance = Dog("Buddy")
cat_instance = Cat("Whiskers")

# Testing the speak method from the base class
print(dog_instance.speak())  # Output: Buddy barks.
print(cat_instance.speak())  # Output: Whiskers meows.

# Testing the superclass attribute access
print(dog_instance.species)  # Output: Dog
print(cat_instance.species)  # Output: Cat

# Testing the constructor and additional attributes
print(f"My dog's name is {dog_instance.name}.")  # Output: My dog's name is Buddy.
print(f"My cat's name is {cat_instance.name}.")  # Output: My cat's name is Whiskers.

Explanation

Base Class (Animal): The Animal class has an __init__ method that initializes with a species attribute and a speak method that returns a string containing the generic sound made by the animal.
Derived Classes (Dog and Cat): Both Dog and Cat classes inherit from Animal. They provide their own __init__ methods, which not only call the constructor of the superclass to set the species but also add an additional name attribute specific to each instance (dog or cat). Each class overrides the speak method to provide a more specific sound related to their species.
Using super(): The super() function in the constructors of Dog and Cat allows the instances of these classes to call the __init__ method of the Animal class, setting up the species attribute without needing to rewrite code.

Conclusion

By creating the derived classes Dog and Cat that inherit from the Animal class and override the speak method, we can extend the functionality provided by the base class while customizing it to meet specific needs. Inheritance helps avoid code duplication, promotes reusability, and supports hierarchical classifications.