Inheritance / super() / Multiple Inheritance

# Inheritance
class ChildClass(ParentClass):
    def __init__(self, ...):
        super().__init__(...)    # Call the parent __init__

# Method override
    def method(self):
        super().method()         # Also call the parent method if needed
        # Additional logic

# Multiple inheritance
class ChildClass(Parent1, Parent2):
    pass

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

    def speak(self):
        return f"{self.name} is making a sound"

    def __str__(self):
        return f"{self.__class__.__name__}({self.name})"

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)      # Call the parent __init__
        self.breed = breed          # Attribute specific to the child class

    def speak(self):                # Override the parent method
        return f"{self.name} says Woof!"

    def fetch(self):                # Method specific to the child class
        return f"{self.name} fetched the ball!"

class Cat(Animal):
    def speak(self):
        return f"{self.name} says Meow!"

d = Dog('Buddy', 'Shiba Inu')
c = Cat('Whiskers')

print(d.speak())    # Buddy says Woof!
print(c.speak())    # Whiskers says Meow!
print(d.fetch())    # Buddy fetched the ball!
print(d.breed)      # Shiba Inu

# Check inheritance relationships with isinstance
print(isinstance(d, Dog))       # True
print(isinstance(d, Animal))    # True (Dog inherits from Animal)

# Override a method while still calling the parent version via super()
class GuideDog(Dog):
    def speak(self):
        base = super().speak()  # Call Dog's speak
        return f"{base} (guide dog)"

gd = GuideDog('Lab', 'Labrador')
print(gd.speak())   # Lab says Woof! (guide dog)

# Multiple inheritance and MRO (C3 linearization algorithm)
class Flyable:
    def move(self):
        return "Flying"

class Swimmable:
    def move(self):
        return "Swimming"

class Duck(Flyable, Swimmable):
    pass

duck = Duck()
print(duck.move())          # Flying (Flyable is resolved first)
print(Duck.__mro__)         # Check the MRO order
# (<class 'Duck'>, <class 'Flyable'>, <class 'Swimmable'>, <class 'object'>)

The MRO (Method Resolution Order) determines the order in which Python searches for a method. Python resolves the inheritance tree using the C3 linearization algorithm. You can inspect it with Class.__mro__, which shows which class's method takes priority in a multiple inheritance scenario.

When you define __init__() in a child class, you should generally call the parent's __init__() via super(). If you skip this call, the parent class is not initialized, its instance variables are never set, and calling any parent method that relies on them will raise an error.

Multiple inheritance increases code complexity. Where possible, the "composition over inheritance" pattern (delegation instead of subclassing) is recommended as an alternative. Using a class purely as a Mixin — a parent class that adds a specific, self-contained feature — is a case where multiple inheritance is genuinely useful.