Python Inheritance


About inheritance

  • Aquiring methods and attributes/properties from other class to the current class.
  • say class B inherit class A then
    • A is parent/base class to class B and
    • B is child/derived class to class A

When to use inheritance?

  • when you have common properties and/or methods
  • It's mostly for code reusability

Quck example

  • Let's say in an organization we have HR, Engineer, Legal Advisor
  • All all employees of the organization so, they share common properties like name, id, address, dob, salary, etc.
  • But, they will have different designation
  • They also share common behaviours like profile/details, etc.
  • Let's write the code.
class Employee:
    def __init__(self, uid, name, role, salary):
        self.uid = uid = name
        self.role = role
        self.salary = salary

    def get_details(self):
        data = {
            "id": self.uid,
            "role": self.role
        return data

class HR(Employee):
    def __init__(self, uid, name):
        role = "HR"
        salary = 50000
        super().__init__(uid, name, role, salary)

class Engineer(Employee):
    def __init__(self, uid, name):
        role = "Engineer"
        salary = 40000
        super().__init__(uid, name, role, salary)

class Advisor(Employee):
    def __init__(self, uid, name):
        role = "Advisor"
        salary = 60000
        super().__init__(uid, name, role, salary)

# let's create objects
hr = HR("AB1", "John")
engineer = Engineer("AB2", "Akshaya")
advisor = Advisor("AB3", "Shiva")

for emp in [hr, engineer, advisor]:
  • Above code gives the below output
{'id': 'AB1', 'name': 'John', 'role': 'HR'}
{'id': 'AB2', 'name': 'Akshaya', 'role': 'Engineer'}
{'id': 'AB3', 'name': 'Shiva', 'role': 'Advisor'}
  • If you look at the above code we have written most of the code in parent/base class Employee and inherited it in all child classes like HR, Engineer, Advisor.
  • we reused parent class methods __init__, get_details in the child classes
  • "super" allows us to call the parent/base class methods.

Take aways

  • Code reusability

  • Less code

  • Readability

  • Maintainability [i.e less code modifications for common feature]

Types of inheritance

  1. Single inheritance
  2. Multi-level inheritance
  3. Multiple inheritance
  4. Hierarchical Inheritance
  5. Hybrid inheritance

Single inheritance

  • A derived class is created from a single base class.
class A:

class B(A):

Multi-level inheritance

  • a derived class is created from another derived class.
class A:

class B(A):

class C(B):
  • In above code, A inherits B and C inherits B
  • B will have properties of A
  • C will have properties of both A and B

Multiple inheritance

  • A derived class is created from more than one base class.
class A:

class B:

class C(A, B):
  • In above code, A and B are base classes
  • C aquires properties from both A and B
  • No dependency between A and B

Hierarchical Inheritance

  • More than one derived class is created from a single base class and further child classes act as parent classes for more than one child class.
class A:

class B(A):

class C(A):

class D(B):

class E(B):

class F(C):

class G(C):
  • From the above code, class A has two children B and C. Further, B and C both are having two children D and E; and F and G respectively.
  • It forms a tree like structure.

Hybrid inheritance

  • It's a combination of more than one inheritance.
  • Hence, it may be a combination of Multilevel and Multiple or Hierarchical and Multilevel or Hierarchical, Multilevel and Multiple inheritances.
  • Try avoid this kind of inheritance.
  • Keep your code simple and loosely coupled.

Method Resolution Order - MRO

This case occurs when we inherit multiple classes with same attibutes and/or methods then the order of method/attributes execution priority changes as below

child class > first inherited class > next inherited class > ...

Let's look at an example

class A:
    def who_are_you(self):
        print("I'm A")

class B:
    def who_are_you(self):
        print("I'm B")

class C:
    def who_are_you(self):
        print("I'm C")

class D(B, C, A):

class E(B, C, A):
    def who_are_you(self):
        print("I'm E")

class F(A, B, C):

d = D()
# ouput: I'm B
e = E()
# ouput: I'm E
f = F()
# ouput: I'm A
  • from the above code we can see that child class has high priority over inherited classes.
  • first inherited class will have the next priority and so on.