Single Inheritance and Method Overriding

15 min · Beginner

Inheritance allows a new class (subclass or child class) to inherit attributes and methods from an existing class (base class or parent class). It enables code reuse and models "is-a" relationships.

Single Inheritance Syntax

Inheritance is a way to build a new class (the child) on top of an existing class (the parent). The child gets the parent's attributes and methods and can add or change its own.

To inherit from a parent class, put the parent class name in parentheses after the child class name.

Python

1class Vehicle:2    def __init__(self, brand):3        self.brand = brand4
5    def move(self):6        return "Moving forward"7
8class Bicycle(Vehicle):9    def ring_bell(self):10        return "Ring ring!"11
12bike = Bicycle("Trek")13print(bike.brand)       # Inherited attribute14print(bike.move())        # Inherited method15print(bike.ring_bell())    # Subclass method

Example 1 · A child reuses and extends a parent

Python

1class Employee:2    def __init__(self, name, salary):3        self.name = name4        self.salary = salary5
6    def monthly_pay(self):7        return self.salary / 128
9class Manager(Employee):10    def monthly_pay(self):11        return self.salary / 12 + 500012
13staff = Employee("Ravi", 600000)14lead = Manager("Anita", 900000)15print(staff.name, staff.monthly_pay())16print(lead.name, lead.monthly_pay())

Output

Ravi 50000.0
Anita 80000.0

What this code does

Manager has no __init__, so it uses the one from Employee.
Manager replaces only monthly_pay(). Everything else is inherited.

Bicycle inherits all public and protected attributes and methods from Vehicle.

Method Overriding

Method overriding is writing a method in a child class with the same name as a method in its parent. Python then runs the child's version for child objects.

A child class can provide its own specialized implementation of a method defined in its parent.

Python

1class ElectricCar(Vehicle):2    def move(self):3        return "Cruising silently on battery power"4
5ev = ElectricCar("Tesla")6print(ev.move())

Python looks in the child first, then upward.

Example 2 · Overriding in a loop

Python

1class Animal:2    def speak(self):3        return "Some generic sound"4
5class Cat(Animal):6    def speak(self):7        return "Meow!"8
9animals = [Animal(), Cat()]10for a in animals:11    print(a.speak())

Output

Some generic sound
Meow!

What this code does

Cat overrides speak().
Iterating over the list invokes the specialized method polymorphically.

Example 3 · The parent calls the child's override

Python

1class Report:2    def title(self):3        return "Report"4
5    def render(self):6        return f"== {self.title()} =="7
8class SalesReport(Report):9    def title(self):10        return "Sales"11
12print(Report().render())13print(SalesReport().render())

Output

== Report ==
== Sales ==

What this code does

render() is written once, in the parent, and calls self.title().
For a SalesReport, self is the child, so Python finds the child's title() first.

When ev.move() is called, Python finds the method in ElectricCar and executes it, overriding Vehicle.move().

Type Checking with isinstance and issubclass

Use isinstance(obj, Class) to check object types, and issubclass(Child, Parent) to check class hierarchies.

Python

print(isinstance(ev, ElectricCar))  # Trueprint(isinstance(ev, Vehicle))      # True (is-a Vehicle)print(issubclass(ElectricCar, Vehicle))  # True

Example 4 · isinstance follows the hierarchy, type does not

Python

1class Payment:2    pass3
4class CardPayment(Payment):5    pass6
7p = CardPayment()8print(type(p) == Payment)9print(isinstance(p, Payment))10print(isinstance(p, (CardPayment, int)))

Output

False
True
True

What this code does

type(p) is exactly CardPayment, so comparing it with Payment gives False.
isinstance accepts a tuple of classes and is true if the object matches any of them.

isinstance respects the entire inheritance hierarchy, unlike direct type comparison type(obj) == Class.

The Liskov Substitution Principle (LSP)

Liskov Substitution Principle says code written for a parent class must keep working when it receives any child object. A child may add behaviour but must not break what the parent promised.

Code written for a parent must work with any child. A child keeps the same parameters, returns compatible values, and never removes a guarantee the parent gave.

Example 5 · A child that breaks the parent contract

Python

1class Discount:2    def apply(self, price):3        return price4
5class Seasonal(Discount):6    def apply(self, price):7        return price * 0.98
9class Coupon(Discount):10    def apply(self, price, code):11        return price - 10012
13def checkout(discount, price):14    return discount.apply(price)15
16print(checkout(Seasonal(), 1000))17try:18    print(checkout(Coupon(), 1000))19except TypeError as error:20    print("Broke the contract:", error)

Output

900.0
Broke the contract: Coupon.apply() missing 1 required positional argument: 'code'

What this code does

checkout was written for any Discount, and it calls apply(price) with one argument.
Coupon demands an extra required argument, so substituting it fails. That is a Liskov violation.

Next step

Check your understanding

11 quick questions

1class Vehicle:2 def __init__(self, brand):3 self.brand = brand4 5 def move(self):6 return "Moving forward"7 8class Bicycle(Vehicle):9 def ring_bell(self):10 return "Ring ring!"11 12bike = Bicycle("Trek")13print(bike.brand) # Inherited attribute14print(bike.move()) # Inherited method15print(bike.ring_bell()) # Subclass method

1class Employee:2 def __init__(self, name, salary):3 self.name = name4 self.salary = salary5 6 def monthly_pay(self):7 return self.salary / 128 9class Manager(Employee):10 def monthly_pay(self):11 return self.salary / 12 + 500012 13staff = Employee("Ravi", 600000)14lead = Manager("Anita", 900000)15print(staff.name, staff.monthly_pay())16print(lead.name, lead.monthly_pay())

1class Animal:2 def speak(self):3 return "Some generic sound"4 5class Cat(Animal):6 def speak(self):7 return "Meow!"8 9animals = [Animal(), Cat()]10for a in animals:11 print(a.speak())

1class Report:2 def title(self):3 return "Report"4 5 def render(self):6 return f"== {self.title()} =="7 8class SalesReport(Report):9 def title(self):10 return "Sales"11 12print(Report().render())13print(SalesReport().render())

The Liskov Substitution Principle (LSP)

Liskov Substitution Principle says code written for a parent class must keep working when it receives any child object. A child may add behaviour but must not break what the parent promised.

Code written for a parent must work with any child. A child keeps the same parameters, returns compatible values, and never removes a guarantee the parent gave.

1class Discount:2 def apply(self, price):3 return price4 5class Seasonal(Discount):6 def apply(self, price):7 return price * 0.98 9class Coupon(Discount):10 def apply(self, price, code):11 return price - 10012 13def checkout(discount, price):14 return discount.apply(price)15 16print(checkout(Seasonal(), 1000))17try:18 print(checkout(Coupon(), 1000))19except TypeError as error:20 print("Broke the contract:", error)