Inheritance

Intermediate ~30 min read

Inheritance is a fundamental OOP concept that allows you to create new classes based on existing ones. The child class inherits attributes and methods from the parent class, enabling code reuse and establishing logical hierarchies between related classes.

Key Terms

Parent class (base class, superclass): The class being inherited from
Child class (derived class, subclass): The class that inherits
super(): Function to call parent class methods
Override: Redefining a parent method in the child

Basic Inheritance

To create a child class, put the parent class name in parentheses after the class name. The child automatically inherits all attributes and methods from the parent.

# Inheritance Basics

print("=== Basic Inheritance ===\n")

# 1. Parent class (also called base class or superclass)
print("1. Parent class:")

class Animal:
    """Base class representing a generic animal."""

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

def speak(self):
        return f"{self.name} makes a sound"

def describe(self):
        return f"I am {self.name}"

# Create a parent class instance
generic = Animal("Generic")
print(f"   {generic.speak()}")
print(f"   {generic.describe()}")
print()

# 2. Child class (also called derived class or subclass)
print("2. Child classes inheriting from Animal:")

class Dog(Animal):
    """Dog inherits from Animal."""

def speak(self):
        """Override parent method."""
        return f"{self.name} says: Woof!"

class Cat(Animal):
    """Cat inherits from Animal."""

def speak(self):
        """Override parent method."""
        return f"{self.name} says: Meow!"

# Child classes automatically get parent's __init__ and describe()
dog = Dog("Buddy")
cat = Cat("Whiskers")

print(f"   {dog.speak()}")
print(f"   {dog.describe()}")  # Inherited from Animal
print(f"   {cat.speak()}")
print(f"   {cat.describe()}")  # Inherited from Animal
print()

# 3. isinstance() and issubclass()
print("3. Type checking with inheritance:")

print(f"   dog is Dog: {isinstance(dog, Dog)}")
print(f"   dog is Animal: {isinstance(dog, Animal)}")  # True - Dog inherits Animal
print(f"   cat is Dog: {isinstance(cat, Dog)}")

print(f"   Dog is subclass of Animal: {issubclass(Dog, Animal)}")
print(f"   Cat is subclass of Animal: {issubclass(Cat, Animal)}")
print(f"   Animal is subclass of Animal: {issubclass(Animal, Animal)}")  # True
print()

# 4. Inheritance chain
print("4. Inheritance chain (all classes inherit from object):")

print(f"   Dog MRO: {Dog.__mro__}")
print(f"   All Python classes inherit from 'object'")
print()

# 5. Adding new methods in child class
print("5. Child classes can add new methods:")

class Bird(Animal):
    """Bird with new method."""

def speak(self):
        return f"{self.name} says: Tweet!"

def fly(self):
        """New method only in Bird."""
        return f"{self.name} is flying!"

bird = Bird("Tweety")
print(f"   {bird.speak()}")
print(f"   {bird.fly()}")  # Only Bird has this
# print(dog.fly())  # Would raise AttributeError - Dog doesn't have fly()

Output

Click Run to execute your code

Use isinstance() for Type Checking

With inheritance, isinstance(dog, Animal) returns True because Dog inherits from Animal. This is better than type(dog) == Dog which doesn't account for inheritance.

The super() Function

When a child class defines its own __init__, it overrides the parent's. Use super() to call the parent's __init__ and ensure proper initialization.

# The super() Function

print("=== Using super() ===\n")

# 1. Why we need super()
print("1. Problem: Child __init__ hides parent __init__:")

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

class StudentBad(Person):
    def __init__(self, name, age, student_id):
        # Without calling parent __init__, name and age aren't set!
        self.student_id = student_id

# Uncomment to see the error:
# bad = StudentBad("Alice", 20, "S123")
# print(bad.name)  # AttributeError: 'StudentBad' has no attribute 'name'
print("   Without super(), parent attributes aren't initialized!")
print()

# 2. Solution: Use super() to call parent
print("2. Using super() to call parent __init__:")

class Student(Person):
    def __init__(self, name, age, student_id):
        super().__init__(name, age)  # Call parent's __init__
        self.student_id = student_id

student = Student("Alice", 20, "S123")
print(f"   Name: {student.name}")  # From Person
print(f"   Age: {student.age}")    # From Person
print(f"   ID: {student.student_id}")  # From Student
print()

# 3. super() with methods
print("3. Using super() with other methods:")

class Animal:
    def speak(self):
        return "Some generic sound"

class Dog(Animal):
    def speak(self):
        # Call parent method AND add to it
        parent_sound = super().speak()
        return f"{parent_sound}... actually, Woof!"

dog = Dog()
print(f"   {dog.speak()}")
print()

# 4. Extending parent methods
print("4. Extending parent behavior:")

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

def get_info(self):
        return f"Name: {self.name}, Salary: ${self.salary:,}"

class Manager(Employee):
    def __init__(self, name, salary, department):
        super().__init__(name, salary)  # Initialize Employee part
        self.department = department
        self.team = []

def get_info(self):
        # Extend parent's get_info
        base_info = super().get_info()
        return f"{base_info}, Department: {self.department}, Team size: {len(self.team)}"

def add_to_team(self, employee):
        self.team.append(employee)

mgr = Manager("Bob", 75000, "Engineering")
emp = Employee("Alice", 50000)
mgr.add_to_team(emp)

print(f"   Employee: {emp.get_info()}")
print(f"   Manager: {mgr.get_info()}")
print()

# 5. Why super() instead of ParentClass.method()?
print("5. super() vs explicit parent call:")

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

class B(A):
    def greet(self):
        # Old way - hardcodes parent class name
        # return A.greet(self) + ", and B"

# Better - uses super(), works with multiple inheritance
        return super().greet() + ", and B"

b = B()
print(f"   {b.greet()}")
print()
print("   super() advantages:")
print("   - Doesn't hardcode parent class name")
print("   - Works correctly with multiple inheritance")
print("   - Follows Method Resolution Order (MRO)")

Output

Click Run to execute your code

Always Call super().init() First

If your child class has its own __init__, call super().__init__() at the beginning to properly initialize the parent's attributes. Forgetting this is a common source of AttributeError bugs.

Method Overriding

Child classes can override parent methods by defining a method with the same name. You can either replace the method entirely or extend it by calling the parent's version.

# Method Overriding

print("=== Method Overriding ===\n")

# 1. Basic method overriding
print("1. Basic overriding - replace parent method:")

class Shape:
    def area(self):
        return 0

def describe(self):
        return "I am a shape"

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

def area(self):
        """Override: Replace parent's area method completely."""
        return self.width * self.height

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

def area(self):
        """Override: Different calculation for circles."""
        import math
        return math.pi * self.radius ** 2

rect = Rectangle(5, 3)
circle = Circle(4)

print(f"   Rectangle area: {rect.area()}")
print(f"   Circle area: {circle.area():.2f}")
print(f"   Rectangle describe: {rect.describe()}")  # Inherited, not overridden
print()

# 2. Extending vs replacing methods
print("2. Extending vs Replacing:")

class Logger:
    def log(self, message):
        print(f"   LOG: {message}")

class TimestampLogger(Logger):
    def log(self, message):
        """Replace: Completely new implementation."""
        from datetime import datetime
        timestamp = datetime.now().strftime("%H:%M:%S")
        print(f"   [{timestamp}] {message}")

class PrefixLogger(Logger):
    def __init__(self, prefix):
        self.prefix = prefix

def log(self, message):
        """Extend: Add prefix, then use parent."""
        prefixed = f"{self.prefix}: {message}"
        super().log(prefixed)

basic = Logger()
ts_logger = TimestampLogger()
prefix_logger = PrefixLogger("ERROR")

basic.log("Basic message")
ts_logger.log("With timestamp")
prefix_logger.log("Extended message")
print()

# 3. Calling parent method from override
print("3. Calling parent from override:")

class Vehicle:
    def __init__(self, brand):
        self.brand = brand

def start(self):
        return f"{self.brand} engine starting..."

class ElectricCar(Vehicle):
    def __init__(self, brand, battery_capacity):
        super().__init__(brand)
        self.battery_capacity = battery_capacity

def start(self):
        # First do parent's start, then add our own behavior
        parent_start = super().start()
        return f"{parent_start} Battery at {self.battery_capacity}%"

car = ElectricCar("Tesla", 85)
print(f"   {car.start()}")
print()

# 4. Override with different signature
print("4. Override can change method signature:")

class BaseNotifier:
    def notify(self, message):
        print(f"   Notification: {message}")

class EmailNotifier(BaseNotifier):
    def notify(self, message, recipient="user@example.com"):
        """Override with additional optional parameter."""
        print(f"   Emailing to {recipient}: {message}")

class SlackNotifier(BaseNotifier):
    def notify(self, message, channel="#general"):
        """Override with different default."""
        print(f"   Slack {channel}: {message}")

email = EmailNotifier()
slack = SlackNotifier()

email.notify("Hello!")
email.notify("Important!", "admin@example.com")
slack.notify("Team update", "#engineering")
print()

# 5. Preventing override (convention)
print("5. Convention: Use underscore to indicate 'private':")

class BankAccount:
    def __init__(self, balance):
        self._balance = balance  # Protected by convention

def _validate_amount(self, amount):
        """Method that probably shouldn't be overridden."""
        return amount > 0

def deposit(self, amount):
        if self._validate_amount(amount):
            self._balance += amount
            return True
        return False

print("   _method means: 'please don't override unless you know what you're doing'")
print("   Python doesn't enforce this, but it's a strong convention")

Output

Click Run to execute your code

Extend vs Replace

Replace: Define method without calling super() - completely new behavior
Extend: Call super().method() inside your override - add to parent behavior

Extending is often preferred because it preserves parent functionality while adding child-specific behavior.

Multiple Inheritance

Python supports inheriting from multiple parent classes. While powerful, this requires understanding the Method Resolution Order (MRO) to know which method gets called.

# Multiple Inheritance

print("=== Multiple Inheritance ===\n")

# 1. Basic multiple inheritance
print("1. Basic multiple inheritance:")

class Flyable:
    def fly(self):
        return "Flying through the air!"

class Swimmable:
    def swim(self):
        return "Swimming through water!"

class Duck(Flyable, Swimmable):
    """Duck inherits from both Flyable and Swimmable."""

def quack(self):
        return "Quack!"

duck = Duck()
print(f"   {duck.fly()}")    # From Flyable
print(f"   {duck.swim()}")   # From Swimmable
print(f"   {duck.quack()}")  # Duck's own method
print()

# 2. The diamond problem and MRO
print("2. Method Resolution Order (MRO):")

class A:
    def method(self):
        return "A"

class B(A):
    def method(self):
        return "B"

class C(A):
    def method(self):
        return "C"

class D(B, C):
    pass

d = D()
print(f"   d.method() returns: '{d.method()}'")  # Returns 'B'
print(f"   MRO: {[cls.__name__ for cls in D.__mro__]}")
print("   Python uses C3 linearization to determine order")
print()

# 3. super() with multiple inheritance
print("3. super() follows MRO:")

class A:
    def greet(self):
        return "A"

class B(A):
    def greet(self):
        return f"B -> {super().greet()}"

class C(A):
    def greet(self):
        return f"C -> {super().greet()}"

class D(B, C):
    def greet(self):
        return f"D -> {super().greet()}"

d = D()
print(f"   d.greet(): {d.greet()}")
print("   Call chain: D -> B -> C -> A (follows MRO!)")
print()

# 4. Mixins - practical multiple inheritance
print("4. Mixins pattern:")

class JSONMixin:
    """Mixin that adds JSON serialization."""
    def to_json(self):
        import json
        return json.dumps(self.__dict__)

class LogMixin:
    """Mixin that adds logging capability."""
    def log(self, message):
        print(f"   [{self.__class__.__name__}] {message}")

class User(JSONMixin, LogMixin):
    def __init__(self, name, email):
        self.name = name
        self.email = email

user = User("Alice", "alice@example.com")
print(f"   JSON: {user.to_json()}")
user.log("User created successfully")
print()

# 5. When to use multiple inheritance
print("5. Multiple inheritance best practices:")
print("""
   USE for:
   - Mixins (small, focused functionality)
   - Interface-like classes (only methods, no __init__)
   - Composition of orthogonal features

AVOID when:
   - Classes have complex __init__ logic
   - There are conflicting method names
   - Inheritance hierarchy gets confusing

Alternative: Composition over inheritance
""")

# Example of composition alternative
print("6. Alternative - Composition:")

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

class Wheels:
    def __init__(self, count):
        self.count = count

def roll(self):
        return f"Rolling on {self.count} wheels"

class Car:
    """Uses composition instead of multiple inheritance."""
    def __init__(self):
        self.engine = Engine()    # Has an engine
        self.wheels = Wheels(4)   # Has wheels

def drive(self):
        return f"{self.engine.start()}... {self.wheels.roll()}"

car = Car()
print(f"   {car.drive()}")

Output

Click Run to execute your code

Prefer Mixins or Composition

Instead of complex multiple inheritance, consider using mixins (small classes with focused functionality) or composition (having objects as attributes rather than inheriting). These patterns are easier to understand and maintain.

Common Mistakes

1. Forgetting to call super().init()

# Wrong - parent attributes not initialized
class Student(Person):
    def __init__(self, name, age, grade):
        self.grade = grade  # name and age are missing!

# Correct - call super() first
class Student(Person):
    def __init__(self, name, age, grade):
        super().__init__(name, age)
        self.grade = grade

2. Hardcoding parent class name

# Bad - hardcodes parent class name
class Child(Parent):
    def method(self):
        Parent.method(self)  # What if parent changes?

# Good - use super() for flexibility
class Child(Parent):
    def method(self):
        super().method()  # Works with any parent

3. Wrong argument passing to super()

# Wrong - passing arguments incorrectly
class Student(Person):
    def __init__(self, name, age, grade):
        super().__init__()  # Missing arguments!

# Wrong - passing self explicitly (Python 2 style)
class Student(Person):
    def __init__(self, name, age, grade):
        super(Student, self).__init__(name, age)  # Verbose

# Correct (Python 3) - super() figures it out
class Student(Person):
    def __init__(self, name, age, grade):
        super().__init__(name, age)  # Clean!

4. Overriding without understanding

# Wrong - accidentally breaking parent functionality
class SafeList(list):
    def append(self, item):
        print(f"Adding: {item}")
        # Forgot to actually append! List stays empty.

# Correct - call parent to preserve functionality
class SafeList(list):
    def append(self, item):
        print(f"Adding: {item}")
        super().append(item)  # Actually add the item

5. Confusing MRO in multiple inheritance

# Confusing - which method gets called?
class A:
    def method(self): return "A"

class B(A):
    def method(self): return "B"

class C(A):
    def method(self): return "C"

class D(B, C):  # Which method does D use?
    pass

d = D()
d.method()  # Returns "B" - follows MRO: D -> B -> C -> A

# Check MRO to understand:
print(D.__mro__)  # Shows the lookup order

Exercise: Employee Hierarchy

Task: Create a class hierarchy for employees using inheritance.

Requirements:

Manager class: inherits from Employee, adds department and team management
Developer class: inherits from Employee, adds programming languages
TechLead class: inherits from both Developer and Manager (multiple inheritance)
Override describe() in each child class to include additional info

Output

Click Run to execute your code

Show Solution

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

    def get_annual_salary(self):
        return self.salary * 12

    def describe(self):
        return f"{self.name}, Salary: ${self.salary:,}/month"


class Manager(Employee):
    def __init__(self, name, salary, department):
        super().__init__(name, salary)
        self.department = department
        self.team = []

    def add_report(self, employee):
        self.team.append(employee)

    def describe(self):
        base = super().describe()
        return f"{base}, Dept: {self.department}, Team: {len(self.team)}"


class Developer(Employee):
    def __init__(self, name, salary, languages=None):
        super().__init__(name, salary)
        self.programming_languages = languages or []

    def add_language(self, language):
        self.programming_languages.append(language)

    def describe(self):
        base = super().describe()
        langs = ", ".join(self.programming_languages)
        return f"{base}, Languages: [{langs}]"


class TechLead(Developer, Manager):
    def __init__(self, name, salary, department, languages=None):
        # Need to handle multiple inheritance carefully
        Employee.__init__(self, name, salary)
        self.department = department
        self.team = []
        self.programming_languages = languages or []

    def describe(self):
        langs = ", ".join(self.programming_languages)
        return (f"{self.name}, ${self.salary:,}/month, "
                f"Dept: {self.department}, Team: {len(self.team)}, "
                f"Languages: [{langs}]")


# Test
dev1 = Developer("Alice", 6000, ["Python", "JavaScript"])
mgr = Manager("Carol", 8000, "Engineering")
mgr.add_report(dev1)
lead = TechLead("David", 9000, "Platform", ["Python", "Go"])
lead.add_report(dev1)
lead.add_language("Rust")

print(dev1.describe())
print(mgr.describe())
print(lead.describe())

Summary

Inheritance syntax: class Child(Parent): creates a child class
super() calls parent class methods, essential for __init__
Method overriding lets children replace or extend parent behavior
isinstance() checks if an object is an instance of a class or its parent
Multiple inheritance: class Child(Parent1, Parent2): - use MRO to understand method lookup
Mixins and composition are often better alternatives to complex inheritance

What's Next?

Now that you understand inheritance, learn about Encapsulation - controlling access to attributes and methods using Python's naming conventions for public, protected, and private members.

Previous Methods

Next Encapsulation

Key Terms

Basic Inheritance

Use isinstance() for Type Checking

The super() Function

Always Call super().__init__() First

Method Overriding

Extend vs Replace

Multiple Inheritance

Prefer Mixins or Composition

Common Mistakes

1. Forgetting to call super().__init__()

2. Hardcoding parent class name

3. Wrong argument passing to super()

4. Overriding without understanding

5. Confusing MRO in multiple inheritance

Exercise: Employee Hierarchy

Summary

What's Next?

Enjoying these tutorials?

Always Call super().init() First

1. Forgetting to call super().init()