Python Object Oriented Programming

Inheritance

Course 3

← → to navigate

Course Curriculum

Where we are in the journey

0. Introduction to the course
1. Classes vs. Objects
2. Encapsulation & Access Control
3. Inheritance
4. Polymorphism
5. Composition & Aggregation
6. SOLID Principles
7. UML & Design Patterns
8. Design Patterns (2nd part)
9. Exception Handling & Logging
10. Testing & TDD
11. Libraries & Frameworks
12. Recap & Consultation

Recap

Classes: The Blueprint

A class defines attributes (color, size) and methods (make_call, take_photo)
It doesn't represent a tangible item until we create an Object from it
Creating an object = instantiation

class Smartphone:
    def __init__(self, brand, color):
        self.__brand = brand
        self.__color = color

    def make_call(self, number):
        return f"Calling {number}..."

The self Parameter

A way for an object to refer to itself

self is the first parameter in any method defined within a class
It lets the method access the instance's attributes and other methods
When you call person1.compare_age(person2), self = person1

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

    def compare_age(self, other):
        if self.age > other.age:
            print(f"{self.name} is older")

person1 = Person("Alice", 30)
person2 = Person("Bob", 25)
person1.compare_age(person2)
# Alice is older

Recap

Access Control

Public

Accessible from anywhere outside the class. No underscores.

self.engine_status = "Off"

def start_engine(self):
    self.engine_status = "On"

Protected _single

Accessible within class and subclasses. Convention, not enforced.

self._fuel_level = 50

def _check_fuel(self):
    return self._fuel_level > 0

Private __double

Accessible within class only. Name mangling prevents outside access.

self.__owner = "John"

def __display_owner(self):
    print(self.__owner)

Recap

Abstraction

Hiding complexity, exposing only what matters

Think of a car — you turn the key and it works. You don't need to understand the engine internals.
In OOP, abstraction means showing only the essential features of an object
The interface is simple, the implementation is hidden
Users interact with what an object does, not how it does it

The 4 Characteristics of Behaviors

Abstraction

The most essential, impressive, stable thing of an object

Encapsulation

Behavior hides internal details

Inheritance

Behaviors are inheritable

Polymorphism

Behaviors are polymorphic

Today's focus: Inheritance — how behaviors pass from parent to child classes

Agenda for Today

Recap

Classes, objects & self
Access control & abstraction
Magic methods & OOP benefits

Inheritance

5 types of inheritance
super() & constructors
Method overriding & overloading
Abstract classes & properties
Composition vs inheritance

Practice

Quiz questions
Live coding: Employee System

Inheritance

Real-world hierarchies map to code

A Vehicle can be a wheeled vehicle or a boat
A Car and a Bicycle are both wheeled vehicles
A Truck and Sports Car are both cars
Each level inherits from the one above and adds its own specifics

Another Example: Mammals

Mammals is the base class
Humans, Cats, Dogs inherit from Mammals
Lions, Tigers, Leopards inherit from Cats
Each child gains parent's traits while adding its own

Terminology

Base Class (Superclass)

The class from which properties and methods are inherited. Also known as a "parent" class.

Derived Class (Subclass)

The class that inherits from another class. Can add new properties or modify existing ones. Also known as a "child" class.

Inheritance

Allows creation of a new class that is a modified version of an existing class.

Terminology in Code

class Animal: # Parent class
    def eat(self):
        print("This animal is eating")

class Dog(Animal): # Child class
    def bark(self):
        print("The dog barks")

class Cat(Animal): # Child class
    def meow(self):
        print("The cat meows")

rex = Dog()
rex.eat()   # This animal is eating
rex.bark()  # The dog barks

class Dog(Animal) — the parentheses declare the inheritance relationship

`isinstance()` & `issubclass()`

Checking inheritance relationships at runtime

isinstance(obj, class)

Is this object an instance of this class or its parents?

class Animal: pass
class Dog(Animal): pass

rex = Dog()
print(isinstance(rex, Dog))     # True
print(isinstance(rex, Animal))  # True!

issubclass(child, parent)

Is this class a subclass of another class?

print(issubclass(Dog, Animal))  # True
print(issubclass(Animal, Dog))  # False
print(issubclass(Dog, Dog))     # True

Every class is considered a subclass of itself

1

Single Inheritance

A class inherits from only one parent

class Animal:
    def eat(self):
        print("This animal is eating")

class Dog(Animal):
    def bark(self):
        print("The dog barks")

Dog inherits from Animal, gaining eat()

2

Hierarchical Inheritance

Multiple classes inherit from a single parent

class Animal:
    def eat(self):
        print("This animal is eating")

class Dog(Animal):
    def bark(self): ...

class Cat(Animal):
    def meow(self): ...

3

Multiple Inheritance

A class inherits from more than one base class

class Father:
    def gardening(self):
        print("Enjoys gardening")

class Mother:
    def cooking(self):
        print("Enjoys cooking")

class Child(Father, Mother):
    pass

child = Child()
child.gardening()  # From Father
child.cooking()    # From Mother

Method conflicts? Python searches left-to-right: class Child(Father, Mother) checks Father first, then Mother

4

Multilevel Inheritance

An inheritance chain — class derived from a class derived from another

class Grandparent:
    def walking(self):
        print("Enjoys walking")

class Parent(Grandparent):
    def reading(self):
        print("Enjoys reading")

class Child(Parent):
    def playing(self):
        print("Enjoys playing")

5

Hybrid Inheritance

A combination of two or more types

Diamond inheritance: a derived class inherits from two classes that both inherit from the same base class
Python handles this with the MRO (Method Resolution Order)

Inheritance in Practice: Vehicles

Let's build this hierarchy in code

Vehicle has make, model, year + display_info()
Car adds max_speed + show_speed()
Boat adds max_knots + show_knots()
Amphibious inherits from both Car and Boat

This example combines single, hierarchical, and multiple inheritance

Vehicle Hierarchy: Code

class Vehicle:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year

    def display_info(self):
        print(f"{self.make} {self.model}, {self.year}")

class Car(Vehicle):
    def __init__(self, make, model, year, max_speed):
        super().__init__(make, model, year)
        self.max_speed = max_speed

    def show_speed(self):
        print(f"Max: {self.max_speed} mph")

class Boat(Vehicle):
    def __init__(self, make, model, year, max_knots):
        super().__init__(make, model, year)
        self.max_knots = max_knots

    def show_knots(self):
        print(f"Max: {self.max_knots} knots")

class AmphibiousVehicle(Car, Boat):
    def __init__(self, make, model, year,
                 max_speed, max_knots):
        Car.__init__(self, make, model, year, max_speed)
        Boat.__init__(self, make, model, year, max_knots)

`init` in Inheritance

How constructors chain through the hierarchy

The Problem

Child's __init__ overrides parent's. Parent attributes are lost!

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

class Dog(Animal):
    def __init__(self, name, breed):
        self.breed = breed  # name is LOST!

rex = Dog("Rex", "Labrador")
print(rex.breed)  # Labrador
print(rex.name)   # AttributeError!

The Solution

Call super().__init__() to chain constructors

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

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

rex = Dog("Rex", "Labrador")
print(rex.name)   # Rex ✔
print(rex.breed)  # Labrador ✔

Rule: Always call super().__init__() when overriding the constructor

Constructor Chaining

Each level initializes its own attributes, then delegates upward

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

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

class Puppy(Dog):
    def __init__(self, name, breed, toy):
        print("Puppy init")
        super().__init__(name, breed)
        self.toy = toy

p = Puppy("Max", "Beagle", "Ball")

Output order:

Puppy init    # 1. Puppy starts
Dog init      # 2. Delegates to Dog
Animal init   # 3. Delegates to Animal

Execution flows down (Puppy → Dog → Animal) but initialization chains upward via super()

p.name = "Max"
p.breed = "Beagle"
p.toy = "Ball"

Understanding Method Overriding

A subclass provides a specific implementation for a method already defined in its superclass

Customization

Subclasses tailor or modify inherited behavior without altering the superclass code

Extensibility

Subclasses can extend behavior by adding steps and calling super()

Polymorphism

A single interface can represent different underlying forms

Overriding in Action

class Animal:
    def speak(self):
        print("Animal speaks")

class Dog(Animal):
    def speak(self):
        print("Dog barks")

class Cat(Animal):
    def speak(self):
        print("Cat meows")

dog = Dog()
dog.speak()  # Dog barks
cat = Cat()
cat.speak()  # Cat meows

Rules for Method Overriding

1. Method Signature

Same name and parameters as the superclass method. Return type should be the same or a subtype.

2. Access Level

Cannot be more restrictive than the method in the superclass.

3. super() Invocation

The overridden method can still be accessed using super().

class Dog(Animal):
    def speak(self):
        super().speak()          # calls Animal.speak()
        print("Dog barks")       # adds Dog-specific behavior

Property Inheritance

@property decorators are inherited and can be overridden

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

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, value):
        if not value:
            raise ValueError("Empty!")
        self._name = value

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

# Dog inherits the property!
rex = Dog("Rex", "Labrador")
print(rex.name)    # Rex

rex.name = "Buddy" # Setter works!
rex.name = ""       # ValueError!

Properties with validation logic carry their rules to all child classes automatically

The super() Function

Access superclass methods — ensures proper initialization

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

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

super() can call any method from the parent class, not just the constructor.

Access superclass methods that have been overridden
Ensures the superclass is properly initialized
Allows subclasses to extend rather than replace behavior
Respects the class hierarchy and MRO

Best Practices with super()

Consistency: Use super() consistently to avoid unexpected behaviors, especially when extending class hierarchies
Always use super() in inherited methods: Ensures your class hierarchy remains flexible and maintainable
Be mindful in multiple inheritance: Understand the MRO and how it affects method calls in complex hierarchies

If a subclass does not define its own constructor, the parent's constructor is called automatically.
If it does define one, you must explicitly call super().__init__() to initialize the parent.

Class vs Instance Attributes

Same class, two kinds of data

class Employee:
    raise_pct = 1.05       # class attribute

    def __init__(self, name):
        self.name = name  # instance attribute

class Developer(Employee):
    raise_pct = 1.10       # overrides class attr

e1 = Employee("Alice")
e2 = Employee("Bob")
d1 = Developer("Carol")

print(e1.name)       # Alice
print(e2.name)       # Bob
print(e1.raise_pct)  # 1.05
print(e2.raise_pct)  # 1.05 (same!)
print(d1.raise_pct)  # 1.10 (overridden)

Class attribute raise_pct

Shared by all instances. Defined outside __init__. Child classes can override it without affecting the parent.

Instance attribute name

Unique to each object. Set in __init__ via self. Every employee has their own name.

How Access Modifiers Affect Inheritance

Public

Subclasses freely inherit and access public methods and properties

self.public_var = "Public"
# accessible everywhere

Protected

Accessible within class and subclasses. Allows safe modification without exposure.

self._protected_var = "Prot"
# convention, not enforced

Private

Not directly accessible to subclasses. Name mangling prevents direct access, but parent methods using them still work.

self.__private_var = "Priv"
# raises AttributeError

Overloading vs Overriding

Method Overloading

Same name, different parameters

Within one class:

class Calculator:
    def add(self, *args):
        return sum(args)

calc.add(1, 2)      # 3
calc.add(1, 2, 3)   # 6

Across inheritance:

class Animal:
    def eat(self):
        print("Eating")

class Dog(Animal):
    def eat(self, food="meat"):
        print(f"Eating {food}")

Python simulates this with default args / *args

Method Overriding

Subclass redefines a parent method with same signature

class Animal:
    def speak(self):
        print("Animal sound")

class Dog(Animal):
    def speak(self):
        print("Dog barks")

pet = Dog()
pet.speak()  # Dog barks

Straightforward in Python

Overriding Example: Shapes

class Shape:
    def __init__(self):
        pass

    def area(self):
        return 0

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

    def area(self):
        return self.__width * self.__height

import math

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

    def area(self):
        return math.pi * self.__radius**2

Both Rectangle and Circle override area() with their own formula

Common Mistakes

Pitfalls to watch out for

Forgetting super().init()

class Dog(Animal):
    def __init__(self, breed):
        # Missing super().__init__()!
        self.breed = breed

rex = Dog("Lab")
rex.name  # AttributeError!

Mutable Class Attributes

class Animal:
    tricks = []  # SHARED!

class Dog(Animal): pass
class Cat(Animal): pass

Dog().tricks.append("fetch")
print(Cat().tricks)
# ['fetch'] -- oops!

Too Deep Hierarchies

# Don't do this:
Animal
  Mammal
    Carnivore
      Canine
        DomesticDog
          Labrador
            ChocolateLab
# Keep it 2-3 levels!

Inheritance: Why Do We Care?

Reuse code — avoid duplicating code that's needed in multiple places
Organized code — group related code together, more manageable structure
Flexible code — change behavior of a section without many changes across the codebase
Readable code — easier for other developers to understand what is going on
Maintainable code — easy to read = easy to maintain = easy to keep up-to-date

Quiz Time!

What does this code print?

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

class B(A):
    def greet(self):
        print("Hello from B")

class C(B):
    pass

obj = C()
obj.greet()

A) Hello from A

B) Hello from B

C) Error

D) Nothing

C has no greet(), so Python follows the MRO: C → B → finds it in B

Quiz Time!

What's the output?

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

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

car = Car(120, "Toyota")
print(car.speed)

A) 120

B) AttributeError

C) None

D) Toyota

Car's __init__ overrides Vehicle's but never calls super().__init__(speed) — so speed is never set!

Quiz Time!

Identify the inheritance type

class Flyable:
    def fly(self): print("Flying")

class Swimmable:
    def swim(self): print("Swimming")

class Duck(Flyable, Swimmable):
    def quack(self): print("Quack!")

A) Single

B) Hierarchical

C) Multiple

D) Multilevel

Duck inherits from two unrelated parent classes — that's multiple inheritance

Hands-on

Live Coding Session

Employee Management System

What we'll build

Employee base class
Developer — single inheritance
Manager — method overriding
TechLead — multiple inheritance

Concepts covered

super().__init__() chaining
Method overriding & super()
isinstance() & MRO
Polymorphism in action

Key Takeaways

Inheritance lets child classes receive attributes and methods from parent classes
5 types: Single Hierarchical Multiple Multilevel Hybrid
Method overriding customizes inherited behavior in subclasses
super() accesses parent methods — use it consistently
In multiple inheritance, Python searches left-to-right for methods

Next up: Polymorphism

Please use a larger screen

Inheritance

Course Curriculum

Classes: The Blueprint

The self Parameter

Access Control

Public

Protected _single

Private __double

Abstraction

The 4 Characteristics of Behaviors

Abstraction

Encapsulation

Inheritance

Polymorphism

Agenda for Today

Recap

Inheritance

Practice

Inheritance

Another Example: Mammals

Terminology

Base Class (Superclass)

Derived Class (Subclass)

Inheritance

Terminology in Code

isinstance() & issubclass()

isinstance(obj, class)

issubclass(child, parent)

Single Inheritance

Hierarchical Inheritance

Multiple Inheritance

Multilevel Inheritance

Hybrid Inheritance

Inheritance in Practice: Vehicles

Vehicle Hierarchy: Code

__init__ in Inheritance

The Problem

The Solution

Constructor Chaining

Output order:

Understanding Method Overriding

Customization

Extensibility

Polymorphism

Overriding in Action

Rules for Method Overriding

1. Method Signature

2. Access Level

3. super() Invocation

Property Inheritance

The super() Function

Best Practices with super()

Class vs Instance Attributes

Class attribute raise_pct

Instance attribute name

How Access Modifiers Affect Inheritance

Public

Protected

Private

Overloading vs Overriding

Method Overloading

Method Overriding

Overriding Example: Shapes

Common Mistakes

Forgetting super().__init__()

Mutable Class Attributes

Too Deep Hierarchies

Inheritance: Why Do We Care?

Quiz Time!

Quiz Time!

Quiz Time!

Live Coding Session

What we'll build

Concepts covered

Key Takeaways

`isinstance()` & `issubclass()`

`init` in Inheritance

Forgetting super().init()