Python Inheritance¶

Prerequisite¶

Python Class

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
        self.name = name
        self.role = role
        self.salary = salary

    def get_details(self):
        data = {
            "id": self.uid,
            "name": self.name,
            "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]:
    print(emp.get_details())

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¶

Single inheritance
Multi-level inheritance
Multiple inheritance
Hierarchical Inheritance
Hybrid inheritance

Single inheritance¶

A derived class is created from a single base class.

class A:
    pass

class B(A):
    pass

Multi-level inheritance¶

a derived class is created from another derived class.

class A:
    pass

class B(A):
    pass

class C(B):
    pass

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:
    pass

class B:
    pass

class C(A, B):
    pass

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:
    pass

class B(A):
    pass

class C(A):
    pass

class D(B):
    pass

class E(B):
    pass

class F(C):
    pass

class G(C):
    pass

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):
    pass

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

class F(A, B, C):
    pass

d = D()
d.who_are_you()
# ouput: I'm B
e = E()
e.who_are_you()
# ouput: I'm E
f = F()
f.who_are_you()
# 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.