Inheritance

Inheritance is a fundamental OOP concept that allows a class (child/derived class) to inherit attributes and methods from another class (parent/base class). This promotes code reusability and establishes a relationship between classes.

Basic Inheritance

In Python, inheritance is achieved by passing the parent class as an argument to the child class definition:

1
class Animal:
2
    def __init__(self, name):
3
        self.name = name
4

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

8
class Dog(Animal):
9
    def speak(self):
10
        return f"{self.name} barks"
11

12
class Cat(Animal):
13
    def speak(self):
14
        return f"{self.name} meows"
15

16
dog = Dog("Buddy")
17
cat = Cat("Whiskers")
18

19
print(dog.speak())  # Buddy barks
20
print(cat.speak())  # Whiskers meows

Types of Inheritance

Single Inheritance

A child class inherits from a single parent class:

1
class Vehicle:
2
    def __init__(self, brand, model):
3
        self.brand = brand
4
        self.model = model
5

6
    def start(self):
7
        return f"{self.brand} {self.model} started"
8

9
class Car(Vehicle):
10
    def __init__(self, brand, model, doors):
11
        super().__init__(brand, model)
12
        self.doors = doors
13

14
    def honk(self):
15
        return "Beep beep!"
16

17
car = Car("Toyota", "Camry", 4)
18
print(car.start())  # Toyota Camry started
19
print(car.honk())   # Beep beep!

Multiple Inheritance

A child class inherits from multiple parent classes:

1
class Flyable:
2
    def fly(self):
3
        return "Flying high!"
4

5
class Swimmable:
6
    def swim(self):
7
        return "Swimming deep!"
8

9
class Duck(Flyable, Swimmable):
10
    def __init__(self, name):
11
        self.name = name
12

13
    def quack(self):
14
        return f"{self.name} says quack!"
15

16
duck = Duck("Donald")
17
print(duck.fly())    # Flying high!
18
print(duck.swim())   # Swimming deep!
19
print(duck.quack())  # Donald says quack!

Multilevel Inheritance

A class inherits from a child class, creating a chain:

1
class Animal:
2
    def __init__(self, name):
3
        self.name = name
4

5
class Mammal(Animal):
6
    def give_birth(self):
7
        return f"{self.name} gives birth to live young"
8

9
class Dog(Mammal):
10
    def bark(self):
11
        return f"{self.name} barks"
12

13
dog = Dog("Buddy")
14
print(dog.name)          # Buddy (from Animal)
15
print(dog.give_birth())  # Buddy gives birth to live young (from Mammal)
16
print(dog.bark())        # Buddy barks (from Dog)

Hierarchical Inheritance

Multiple child classes inherit from a single parent class:

1
class Shape:
2
    def __init__(self, name):
3
        self.name = name
4

5
    def area(self):
6
        return 0
7

8
class Rectangle(Shape):
9
    def __init__(self, name, length, width):
10
        super().__init__(name)
11
        self.length = length
12
        self.width = width
13

14
    def area(self):
15
        return self.length * self.width
16

17
class Circle(Shape):
18
    def __init__(self, name, radius):
19
        super().__init__(name)
20
        self.radius = radius
21

22
    def area(self):
23
        return 3.14159 * self.radius ** 2
24

25
rect = Rectangle("Rectangle", 5, 3)
26
circle = Circle("Circle", 4)
27

28
print(f"{rect.name} area: {rect.area()}")    # Rectangle area: 15
29
print(f"{circle.name} area: {circle.area()}") # Circle area: 50.26544

Method Overriding

Method overriding occurs when a child class provides its own implementation of a method that exists in the parent class:

1
class Animal:
2
    def make_sound(self):
3
        return "Some generic sound"
4

5
class Dog(Animal):
6
    def make_sound(self):
7
        return "Woof!"
8

9
class Cat(Animal):
10
    def make_sound(self):
11
        return "Meow!"
12

13
animal = Animal()
14
dog = Dog()
15
cat = Cat()
16

17
print(animal.make_sound())  # Some generic sound
18
print(dog.make_sound())     # Woof!
19
print(cat.make_sound())     # Meow!

The `super()` Function

The super() function allows you to call methods from the parent class. It’s particularly useful in constructors:

1
class Person:
2
    def __init__(self, name, age):
3
        self.name = name
4
        self.age = age
5

6
    def display(self):
7
        return f"Name: {self.name}, Age: {self.age}"
8

9
class Student(Person):
10
    def __init__(self, name, age, student_id):
11
        super().__init__(name, age)  # Call parent constructor
12
        self.student_id = student_id
13

14
    def display(self):
15
        parent_info = super().display()  # Call parent method
16
        return f"{parent_info}, Student ID: {self.student_id}"
17

18
student = Student("Alice", 20, "S12345")
19
print(student.display())  # Name: Alice, Age: 20, Student ID: S12345

Using `super()` with Multiple Inheritance

With multiple inheritance, super() follows the Method Resolution Order (MRO):

1
class A:
2
    def method(self):
3
        return "A"
4

5
class B(A):
6
    def method(self):
7
        return f"B -> {super().method()}"
8

9
class C(A):
10
    def method(self):
11
        return f"C -> {super().method()}"
12

13
class D(B, C):
14
    def method(self):
15
        return f"D -> {super().method()}"
16

17
obj = D()
18
print(obj.method())  # D -> B -> C -> A

Method Resolution Order (MRO)

Method Resolution Order (MRO) determines the order in which Python searches for methods in inheritance hierarchies. Python uses the C3 linearization algorithm.

You can view the MRO using the __mro__ attribute or mro() method:

1
class A:
2
    pass
3

4
class B(A):
5
    pass
6

7
class C(A):
8
    pass
9

10
class D(B, C):
11
    pass
12

13
print(D.__mro__)
14
# (<class '__main__.D'>, <class '__main__.B'>,
15
#  <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)
16

17
print(D.mro())
18
# Same output as above

Understanding MRO in Multiple Inheritance

1
class First:
2
    def method(self):
3
        return "First"
4

5
class Second:
6
    def method(self):
7
        return "Second"
8

9
class Third(First, Second):
10
    pass
11

12
class Fourth(Second, First):
13
    pass
14

15
obj1 = Third()
16
obj2 = Fourth()
17

18
print(obj1.method())  # First (First comes before Second in MRO)
19
print(obj2.method())  # Second (Second comes before First in MRO)
20

21
print(Third.__mro__)
22
# (<class '__main__.Third'>, <class '__main__.First'>,
23
#  <class '__main__.Second'>, <class 'object'>)

The `isinstance()` and `issubclass()` Functions

isinstance(obj, class): Checks if an object is an instance of a class or its subclasses
issubclass(class1, class2): Checks if a class is a subclass of another class

1
class Animal:
2
    pass
3

4
class Dog(Animal):
5
    pass
6

7
class Cat(Animal):
8
    pass
9

10
dog = Dog()
11
cat = Cat()
12

13
print(isinstance(dog, Dog))      # True
14
print(isinstance(dog, Animal))   # True (Dog inherits from Animal)
15
print(isinstance(dog, Cat))      # False
16

17
print(issubclass(Dog, Animal))   # True
18
print(issubclass(Cat, Animal))   # True
19
print(issubclass(Dog, Cat))      # False

Accessing Parent Class Attributes

You can access parent class attributes directly or through super():

1
class Parent:
2
    class_var = "Parent class variable"
3

4
    def __init__(self):
5
        self.instance_var = "Parent instance variable"
6

7
class Child(Parent):
8
    class_var = "Child class variable"
9

10
    def __init__(self):
11
        super().__init__()
12
        self.instance_var = "Child instance variable"
13

14
    def show_parent_class_var(self):
15
        return Parent.class_var  # Access parent class variable directly
16

17
    def show_parent_instance_var(self):
18
        return super().instance_var  # Access parent instance variable
19

20
child = Child()
21
print(child.instance_var)              # Child instance variable
22
print(child.show_parent_instance_var()) # Parent instance variable
23
print(child.class_var)                  # Child class variable
24
print(child.show_parent_class_var())    # Parent class variable

Overriding Special Methods

You can override special methods (magic methods) in child classes:

1
class Animal:
2
    def __init__(self, name):
3
        self.name = name
4

5
    def __str__(self):
6
        return f"Animal: {self.name}"
7

8
class Dog(Animal):
9
    def __init__(self, name, breed):
10
        super().__init__(name)
11
        self.breed = breed
12

13
    def __str__(self):
14
        return f"Dog: {self.name} ({self.breed})"
15

16
dog = Dog("Buddy", "Golden Retriever")
17
print(dog)  # Dog: Buddy (Golden Retriever)

Complete Example: Employee Hierarchy

1
class Employee:
2
    company_name = "Tech Corp"
3
    employee_count = 0
4

5
    def __init__(self, name, employee_id):
6
        self.name = name
7
        self.employee_id = employee_id
8
        Employee.employee_count += 1
9

10
    def get_info(self):
11
        return f"ID: {self.employee_id}, Name: {self.name}"
12

13
    @classmethod
14
    def get_employee_count(cls):
15
        return cls.employee_count
16

17
class Manager(Employee):
18
    def __init__(self, name, employee_id, department):
19
        super().__init__(name, employee_id)
20
        self.department = department
21

22
    def get_info(self):
23
        base_info = super().get_info()
24
        return f"{base_info}, Department: {self.department}, Role: Manager"
25

26
class Developer(Employee):
27
    def __init__(self, name, employee_id, programming_language):
28
        super().__init__(name, employee_id)
29
        self.programming_language = programming_language
30

31
    def get_info(self):
32
        base_info = super().get_info()
33
        return f"{base_info}, Language: {self.programming_language}, Role: Developer"
34

35
class SeniorDeveloper(Developer):
36
    def __init__(self, name, employee_id, programming_language, years_experience):
37
        super().__init__(name, employee_id, programming_language)
38
        self.years_experience = years_experience
39

40
    def get_info(self):
41
        base_info = super().get_info()
42
        return f"{base_info}, Experience: {self.years_experience} years, Level: Senior"
43

44
manager = Manager("Alice", "M001", "Engineering")
45
dev1 = Developer("Bob", "D001", "Python")
46
dev2 = SeniorDeveloper("Charlie", "D002", "Python", 5)
47

48
print(manager.get_info())
49
# ID: M001, Name: Alice, Department: Engineering, Role: Manager
50

51
print(dev1.get_info())
52
# ID: D001, Name: Bob, Language: Python, Role: Developer
53

54
print(dev2.get_info())
55
# ID: D002, Name: Charlie, Language: Python, Role: Developer, Experience: 5 years, Level: Senior
56

57
print(f"Total employees: {Employee.get_employee_count()}")  # 3

Diamond Problem in Multiple Inheritance

Python handles the diamond problem (when a class inherits from two classes that both inherit from the same base class) using MRO:

1
class A:
2
    def method(self):
3
        return "A"
4

5
class B(A):
6
    def method(self):
7
        return f"B -> {super().method()}"
8

9
class C(A):
10
    def method(self):
11
        return f"C -> {super().method()}"
12

13
class D(B, C):
14
    def method(self):
15
        return f"D -> {super().method()}"
16

17
obj = D()
18
print(obj.method())  # D -> B -> C -> A
19

20
print(D.__mro__)
21
# (<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>,
22
#  <class '__main__.A'>, <class 'object'>)

Notice that A appears only once in the MRO, preventing the diamond problem.

Exercises

Exercise 1: Basic Inheritance

Create a parent class Vehicle with brand and model attributes, and a start() method that returns “Vehicle started”. Create a child class Car that inherits from Vehicle and adds a honk() method. Read brand and model, create a Car object, and call both methods.

Answer:

1
class Vehicle:
2
    def __init__(self, brand, model):
3
        self.brand = brand
4
        self.model = model
5

6
    def start(self):
7
        return "Vehicle started"
8

9
class Car(Vehicle):
10
    def honk(self):
11
        return "Beep beep!"
12

13
brand = input()
14
model = input()
15
car = Car(brand, model)
16
print(car.start())
17
print(car.honk())

Exercise 2: Method Overriding

Create a parent class Shape with an area() method that returns 0. Create child classes Rectangle and Circle that override area() to calculate their respective areas. Read values and create objects, then print their areas.

Answer:

1
import math
2

3
class Shape:
4
    def area(self):
5
        return 0
6

7
class Rectangle(Shape):
8
    def __init__(self, length, width):
9
        self.length = length
10
        self.width = width
11

12
    def area(self):
13
        return self.length * self.width
14

15
class Circle(Shape):
16
    def __init__(self, radius):
17
        self.radius = radius
18

19
    def area(self):
20
        return math.pi * self.radius ** 2
21

22
length = float(input())
23
width = float(input())
24
radius = float(input())
25

26
rect = Rectangle(length, width)
27
circle = Circle(radius)
28

29
print(f"Rectangle area: {rect.area()}")
30
print(f"Circle area: {circle.area():.2f}")

Exercise 3: Using super()

Create a parent class Person with name and age, and a display() method. Create a child class Student that adds student_id and overrides display() to include the student ID using super().

Answer:

1
class Person:
2
    def __init__(self, name, age):
3
        self.name = name
4
        self.age = age
5

6
    def display(self):
7
        return f"Name: {self.name}, Age: {self.age}"
8

9
class Student(Person):
10
    def __init__(self, name, age, student_id):
11
        super().__init__(name, age)
12
        self.student_id = student_id
13

14
    def display(self):
15
        return f"{super().display()}, Student ID: {self.student_id}"
16

17
name = input()
18
age = int(input())
19
student_id = input()
20

21
student = Student(name, age, student_id)
22
print(student.display())

Exercise 4: Multiple Inheritance

Create two parent classes: Flyable with a fly() method and Swimmable with a swim() method. Create a child class Duck that inherits from both and has a name attribute. Read the name and call all three methods.

Answer:

1
class Flyable:
2
    def fly(self):
3
        return "Flying high!"
4

5
class Swimmable:
6
    def swim(self):
7
        return "Swimming deep!"
8

9
class Duck(Flyable, Swimmable):
10
    def __init__(self, name):
11
        self.name = name
12

13
    def quack(self):
14
        return f"{self.name} says quack!"
15

16
name = input()
17
duck = Duck(name)
18
print(duck.fly())
19
print(duck.swim())
20
print(duck.quack())

Exercise 5: isinstance and issubclass

Create a parent class Animal and child classes Dog and Cat. Create a Dog object and use isinstance() to check if it’s an instance of Dog, Animal, and Cat. Use issubclass() to check if Dog and Cat are subclasses of Animal.

Answer:

1
class Animal:
2
    pass
3

4
class Dog(Animal):
5
    pass
6

7
class Cat(Animal):
8
    pass
9

10
dog = Dog()
11

12
print(isinstance(dog, Dog))
13
print(isinstance(dog, Animal))
14
print(isinstance(dog, Cat))
15
print(issubclass(Dog, Animal))
16
print(issubclass(Cat, Animal))

Inheritance

Table of Contents

Table of Contents

Course Progress

Inheritance

Basic Inheritance

Types of Inheritance

Single Inheritance

Multiple Inheritance

Multilevel Inheritance

Hierarchical Inheritance

Method Overriding

The `super()` Function

Using `super()` with Multiple Inheritance

Method Resolution Order (MRO)

Understanding MRO in Multiple Inheritance

The `isinstance()` and `issubclass()` Functions

Accessing Parent Class Attributes

Overriding Special Methods

Complete Example: Employee Hierarchy

Diamond Problem in Multiple Inheritance

Exercises

Exercise 1: Basic Inheritance

Basic Inheritance

Exercise 2: Method Overriding

Method Overriding

Exercise 3: Using super()

Using super()

Exercise 4: Multiple Inheritance

Multiple Inheritance

Exercise 5: isinstance and issubclass

isinstance and issubclass

Course Progress