Inheritance in Python

Inheritance allows a child class to inherit attributes and methods from a parent class to promote code reuse.

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

class Child(Parent):
    pass

obj = Child()
obj.greet()  # Output: Hello from Parent

class Child(Parent):
    pass

• Single inheritance
• Multiple inheritance
• Multilevel inheritance
• Hierarchical inheritance
• Hybrid inheritance

A child class inherits from one parent class.

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

class Dog(Animal):
    pass

When a child class provides a new implementation for a method already defined in the parent class.

class Parent:
    def show(self):
        print("Parent method")

class Child(Parent):
    def show(self):
        print("Child method")

obj = Child()
obj.show()  # Output: Child method

class Child(Parent):
    def show(self):
        super().show()  # Calls Parent's method
        print("Child method")

The child class inherits and uses the parent class's method.

Yes, any method from the parent class can be overridden.

Yes, but it can be overridden.

class Parent:
    def __init__(self):
        print("Parent Constructor")

class Child(Parent):
    def __init__(self):
        super().__init__()  # Calls Parent constructor
        print("Child Constructor")

The parent class?s __init__ method is called automatically.

class Parent:
    def __init__(self, name):
        print(f"Parent {name}")

class Child(Parent):
    def __init__(self, name):
        super().__init__(name)

No, Python does not support multiple constructors, but default arguments can be used.

A child class inherits from multiple parent classes.

class A:
    def method_A(self):
        print("Method A")

class B:
    def method_B(self):
        print("Method B")

class C(A, B):
    pass

The Method Resolution Order (MRO) determines which method is executed first.

Using C3 Linearization (MRO), which follows Depth First, Left to Right order.

print(C.mro())

A chain of inheritance where a child class inherits from another child class.

class GrandParent:
    pass

class Parent(GrandParent):
    pass

class Child(Parent):
    pass

Increases complexity and can introduce tight coupling.

Yes, each level can override and modify methods.

class Parent:
    def final_method(self):
        raise NotImplementedError("Cannot be overridden")

Yes, it will call the nearest superclass method.

One parent class has multiple child classes.

class Parent:
    pass

class Child1(Parent):
    pass

class Child2(Parent):
    pass

A combination of multiple types of inheritance.

MRO conflicts can arise.

Using super() and checking mro()

Yes, but use cautiously to avoid complexity.

It allows calling methods from a parent class inside a child class.

Public

class Parent:
    def __private_method(self):
        print("Private Method")

No, private methods (__method()) are not inherited.

isinstance(obj, Parent)

issubclass(Child, Parent)

No, only one __init__ method is used.

Use NotImplementedError in the constructor.

A child class calls a parent class method instead of overriding.

No, a class cannot be its own parent.

Composition uses objects within objects, while inheritance extends a class.

Using helper classes to add extra functionality.

Calling multiple methods using super().

Yes, but inheritance is unnecessary in such cases.

The ability to use the same method name with different implementations.

If an object behaves like a type, it is treated as that type.

They enforce method overriding.

Yes, called hierarchical inheritance.

When there are many levels of subclasses

Overuse can increase coupling and reduce flexibility.