Inheritance

Introduction

Inheritance is an advanced Python concept that you probably won’t use when starting out. Most beginner programs work perfectly fine without it. However, as your projects grow, inheritance can make your code much cleaner by avoiding repetition.

Don’t worry if inheritance feels complex at first. Focus on understanding basic classes, and come back to inheritance when you find yourself writing similar classes with shared functionality.

What is inheritance?

Inheritance lets you create new classes based on existing ones. The new class (child) gets everything from the parent class, plus can add its own stuff. Think of it like this:

All dogs are animals (dogs inherit from animals)
Dogs have everything animals have, plus dog-specific things

Basic inheritance example

# Parent class - general animal
class Animal:
    def __init__(self, name):
        self.name = name
    
    def eat(self):
        return f"{self.name} is eating"
    
    def sleep(self):
        return f"{self.name} is sleeping"

# Child class - specific animal
class Dog(Animal):
    def bark(self):
        return f"{self.name} says woof!"

# Create a dog - using positional argument
my_dog = Dog("Buddy")
# Or with named argument
my_dog2 = Dog(name="Max")

# Dog can do animal things (inherited)
print(my_dog.eat())    # Buddy is eating
print(my_dog.sleep())  # Buddy is sleeping

# Dog can also do dog things
print(my_dog.bark())   # Buddy says woof!

Adding attributes in child classes

Child classes can have their own attributes too:

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

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)  # Pass name to parent's __init__
        self.breed = breed      # Dog-specific attribute
    
    def describe(self):
        return f"{self.name} is a {self.breed}"

# Create dogs with breeds - positional arguments
golden = Dog("Buddy", "Golden Retriever")

# Or with named arguments (clearer)
poodle = Dog(name="Max", breed="Poodle")

print(golden.describe())  # Buddy is a Golden Retriever
print(golden.is_pet)      # True (inherited from Animal)

super().__init__() calls the parent class’s __init__ method. This ensures the parent class sets up its attributes properly before the child class adds its own.

Overriding methods

Child classes can change how parent methods work:

class Animal:
    def __init__(self, name):
        self.name = name
    
    def make_sound(self):
        return f"{self.name} makes a sound"

class Dog(Animal):
    def make_sound(self):  # Override parent method
        return f"{self.name} barks: Woof!"

class Cat(Animal):
    def make_sound(self):  # Override parent method
        return f"{self.name} meows: Meow!"

# Different animals, different sounds
generic = Animal(name="Something")
dog = Dog(name="Buddy")
cat = Cat(name="Whiskers")

print(generic.make_sound())  # Something makes a sound
print(dog.make_sound())      # Buddy barks: Woof!
print(cat.make_sound())      # Whiskers meows: Meow!

Real-world use case

Here’s a practical example for AI applications:

class BaseModel:
    def __init__(self, model_name):
        self.model_name = model_name
        self.is_loaded = False
    
    def load(self):
        print(f"Loading {self.model_name}...")
        self.is_loaded = True

class TextModel(BaseModel):
    def __init__(self, model_name, max_length=1000):
        super().__init__(model_name)
        self.max_length = max_length
    
    def process_text(self, text):
        if not self.is_loaded:
            self.load()
        # Truncate if needed
        if len(text) > self.max_length:
            text = text[:self.max_length]
        return f"Processed: {text}"

# Use the model - with named arguments
model = TextModel(model_name="gpt-3.5-turbo", max_length=100)

# Call method - notice no 'self' parameter needed
result = model.process_text(text="Hello world")
print(result)  # Loading gpt-3.5-turbo...
               # Processed: Hello world

Types of Inheritance in Python

Python is extremely versatile and supports five primary types of inheritance:

Single Inheritance: A child class inherits from a single parent class. (e.g., class Dog(Animal))
Multiple Inheritance: A child class inherits from more than one parent class. (e.g., class SmartDevice(Camera, Phone))
Multilevel Inheritance: A child class inherits from a parent class, which in turn inherits from another class. (e.g., class Puppy(Dog) where Dog inherits from Animal)
Hierarchical Inheritance: Multiple child classes inherit from a single parent class. (e.g., both Dog and Cat inherit from Animal)
Hybrid Inheritance: A combination of two or more of the above inheritance types.

Conflict Resolution & Method Resolution Order (MRO)

In Multiple Inheritance, a conflict arises if two parent classes define the same method or attribute. How does Python decide which one to execute?

The MRO Resolution Rules:

Python resolves conflicts using the Method Resolution Order (MRO), which follows the C3 Linearization algorithm. The order is determined by:

Looking at the class itself first.
Looking at parent classes from left to right as specified in the class definition (e.g., class Child(ParentA, ParentB) looks at ParentA before ParentB).
Moving up the hierarchy without visiting the same class twice (depth-first, left-to-right, but keeping shared base classes for last).

Visualizing MRO:

You can print the MRO of any class using the .mro() method or the __mro__ attribute.

class ParentA:
    def greet(self):
        return "Hello from Parent A"

class ParentB:
    def greet(self):
        return "Hello from Parent B"

# Child inherits from both (ParentA is listed FIRST/LEFT)
class Child(ParentA, ParentB):
    pass

c = Child()
print(c.greet())  # Output: Hello from Parent A

# Inspect the resolution order
print(Child.mro())
# Output: [<class 'Child'>, <class 'ParentA'>, <class 'ParentB'>, <class 'object'>]

If you swap the order: class Child(ParentB, ParentA), then c.greet() will output "Hello from Parent B".

When to use inheritance

Use inheritance when:

You have an “is a” relationship (Dog is an Animal)
Child classes share most behavior with parent
You want to extend functionality, not replace it

Don’t use inheritance when:

Classes are only slightly related
You just want to reuse one or two methods
The relationship feels forced

Common mistakes

Forgetting to call super().__init__()

# Wrong - parent's __init__ not called
class Child(Parent):
    def __init__(self, name):
        self.name = name  # Parent attributes missing!

# Right - call parent's __init__
class Child(Parent):
    def __init__(self, name):
        super().__init__()
        self.name = name

Wrong inheritance relationship

# Wrong - Rectangle is not a Square!
class Square:
    def __init__(self, size):
        self.size = size

class Rectangle(Square):  # Doesn't make sense
    def __init__(self, width, height):
        self.width = width
        self.height = height

# Better - they're both shapes
class Shape:
    pass

class Square(Shape):
    def __init__(self, size):
        self.size = size

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

What’s next?

Let’s explore when to use classes and when to keep things simple.

When to use classes

Best practices and guidelines

Functions

Classes

Error handling

Modules & Packages

Extending Python

Introduction

What is inheritance?

Basic inheritance example

Adding attributes in child classes

Overriding methods

Real-world use case

Types of Inheritance in Python

Conflict Resolution & Method Resolution Order (MRO)

The MRO Resolution Rules:

Visualizing MRO:

When to use inheritance

Common mistakes

What’s next?

When to use classes

​Introduction

​What is inheritance?

​Basic inheritance example

​Adding attributes in child classes

​Overriding methods

​Real-world use case

​Types of Inheritance in Python

​Conflict Resolution & Method Resolution Order (MRO)

​The MRO Resolution Rules:

​Visualizing MRO:

​When to use inheritance

​Common mistakes

​What’s next?

When to use classes

Introduction

What is inheritance?

Basic inheritance example

Adding attributes in child classes

Overriding methods

Real-world use case

Types of Inheritance in Python

Conflict Resolution & Method Resolution Order (MRO)

The MRO Resolution Rules:

Visualizing MRO:

When to use inheritance

Common mistakes

What’s next?