Academy — Sanjib Sikder

The Problem: Repeated Structure

Suppose your application has different types of employees — regular employees, managers, and contractors. Each has a name and a salary. But managers also have a team. Contractors have an hourly rate and work a variable number of hours.

You could write three completely separate classes. But they would share a large amount of structure — the common attributes and methods would be duplicated across all three. Any change to the common parts would need to be made in three places.

Inheritance solves this. You define the shared behaviour once in a parent class (also called a base class or superclass), then create child classes (subclasses) that extend it.

A Parent Class

Python

Ctrl+Enter to run

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

    def describe(self):
        return f#22c55e">"{self.name} — Salary: ₹{self.salary:,}"

    def give_raise(self, amount):
        self.salary += amount
        print(f#22c55e">"{self.name} received a raise. New salary: ₹{self.salary:,}")

emp = Employee(#22c55e">"Arjun", 50000)
print(emp.describe())
emp.give_raise(5000)

A basic Employee class. Now let's extend it.

Creating a Child Class

Python

Ctrl+Enter to run

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

    def describe(self):
        return f#22c55e">"{self.name} — Salary: ₹{self.salary:,}"

    def give_raise(self, amount):
        self.salary += amount
        print(f#22c55e">"{self.name} received a raise. New salary: ₹{self.salary:,}")

class Manager(Employee):
def **init**(self, name, salary, team_size):
super().**init**(name, salary)
self.team_size = team_size

    def describe(self):
        return f#22c55e">"{self.name} — Salary: ₹{self.salary:,} — Team: {self.team_size} people"

mgr = Manager(#22c55e">"Priya", 90000, 8)
print(mgr.describe())
mgr.give_raise(10000)

class Manager(Employee) — the parentheses declare the parent class. Manager inherits everything from Employee.

super().__init__(name, salary) — super() refers to the parent class. Calling super().__init__() runs the parent's __init__, setting up name and salary. Then self.team_size = team_size adds the new attribute specific to managers.

mgr.give_raise(10000) — Manager didn't define give_raise, but it inherited it from Employee. It works exactly the same.

Method Overriding

Manager defines its own describe() — this overrides the parent's version. When you call mgr.describe(), Python finds describe in Manager first and uses that instead of Employee's version.

This is intentional. The manager's description includes team size; the base employee's doesn't. Same method name, different behaviour — appropriate to the type.

Overriding is always this simple: define a method with the same name in the child class.

Extending a Parent Method

Sometimes you want to override a method but still include what the parent does — not replace it entirely.

Python

Ctrl+Enter to run

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

    def give_raise(self, amount):
        self.salary += amount
        print(f#22c55e">"{self.name} received a raise. New salary: ₹{self.salary:,}")

class Manager(Employee):
def **init**(self, name, salary, team_size):
super().**init**(name, salary)
self.team_size = team_size

    def give_raise(self, amount):
        bonus = amount * 1.2   # Managers get a 20% bigger raise
        super().give_raise(bonus)

mgr = Manager(#22c55e">"Priya", 90000, 8)
mgr.give_raise(10000)

Manager.give_raise() calculates a bigger amount, then calls super().give_raise() to let the parent handle the actual salary update and message. You extend the behaviour rather than rewrite it.

`isinstance()` — Checking Types

Python

Ctrl+Enter to run

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

class Manager(Employee):
    pass

emp = Employee(#22c55e">"Arjun")
mgr = Manager(#22c55e">"Priya")

print(isinstance(mgr, Manager)) # True
print(isinstance(mgr, Employee)) # Also True — Manager IS an Employee
print(isinstance(emp, Manager)) # False

A child class instance is also an instance of the parent. A Manager is also an Employee — inheritance establishes an is-a relationship. isinstance() respects this hierarchy.

Polymorphism

Polymorphism means different types, same interface. When multiple classes share a method name, you can call that method on any of them without knowing or caring which specific type you have.

Python

Ctrl+Enter to run

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

    def monthly_pay(self):
        return self.salary / 12

class Contractor:
def **init**(self, name, hourly_rate, hours):
self.name = name
self.hourly_rate = hourly_rate
self.hours = hours

    def monthly_pay(self):
        return self.hourly_rate * self.hours

staff = [
Employee(#22c55e">"Arjun", 600000),
Employee(#22c55e">"Meera", 480000),
Contractor(#22c55e">"Dev", 800, 120),
]

for person in staff:
print(f#22c55e">"{person.name}: ₹{person.monthly_pay():,.2f}/month")

Employee and Contractor are completely separate classes with no inheritance relationship. But both define monthly_pay(). The loop calls monthly_pay() on each without knowing which type it's dealing with. Python finds the right version at runtime.

This is polymorphism — writing code that works with objects based on what they can do, not what they are.

A Complete Hierarchy

Python

Ctrl+Enter to run

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

    def speak(self):
        return #22c55e">"..."

    def __str__(self):
        return f#22c55e">"{self.name} ({self.__class__.__name__})"

class Dog(Animal):
def speak(self):
return #22c55e">"Woof!"

class Cat(Animal):
def speak(self):
return #22c55e">"Meow!"

class Duck(Animal):
def speak(self):
return #22c55e">"Quack!"

animals = [Dog(#22c55e">"Bruno"), Cat("Whiskers"), Duck("Donald")]

for animal in animals:
print(f#22c55e">"{animal} says: {animal.speak()}")

self.__class__.__name__ gives the actual class name of the object — "Dog", "Cat", "Duck" — without hardcoding it. A small but useful detail.

What You Have Learned

Inheritance lets you build specialised classes on top of general ones — reusing, extending, and replacing behaviour precisely where needed.

The key ideas:

class Child(Parent): declares inheritance
super().__init__(...) runs the parent's constructor — always call it when overriding __init__
Method overriding: define a method with the same name in the child to replace the parent's version
super().method() calls the parent's version of a method from within the child
A child instance is also an instance of the parent — isinstance() respects the hierarchy
Polymorphism: different classes sharing a method name, called uniformly through a common interface
Inheritance establishes an is-a relationship — use it when a child genuinely is a specialised form of the parent

In the final lesson of this series, you'll learn about iterators and generators — how Python's for loop really works, and how to build sequences that produce values lazily, one at a time.

Object-Oriented Programming — Inheritance

The Problem: Repeated Structure

A Parent Class

Creating a Child Class

Method Overriding

Extending a Parent Method

isinstance() — Checking Types

Polymorphism

A Complete Hierarchy

What You Have Learned

`isinstance()` — Checking Types