Learn Python Programming

Python Inheritance

Inheritance lets a class (child) reuse and extend the behavior of another class (parent). The child inherits all attributes and methods, and can override or add new ones.

Basic Inheritance

# Parent (base) class
class Animal:
    def __init__(self, name, sound):
        self.name = name
        self.sound = sound

    def speak(self):
        return f"{self.name} says {self.sound}!"

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

# Child (derived) class — inherits from Animal
class Dog(Animal):
    def __init__(self, name, breed):
        # Call parent constructor
        super().__init__(name, sound="Woof")
        self.breed = breed  # new attribute

    def fetch(self, item):
        return f"{self.name} fetches the {item}!"

class Cat(Animal):
    def __init__(self, name, indoor=True):
        super().__init__(name, sound="Meow")
        self.indoor = indoor

    def purr(self):
        return f"{self.name} is purring..."

# Usage
dog = Dog("Rex", "Labrador")
cat = Cat("Whiskers")

print(dog.speak())   # Rex says Woof! (inherited method)
print(dog.fetch("ball"))  # Rex fetches the ball! (new method)
print(cat.speak())   # Whiskers says Meow!
print(cat.purr())    # Whiskers is purring...

Method Overriding

# Child classes can override parent methods
class Shape:
    def __init__(self, color="black"):
        self.color = color

    def area(self):
        raise NotImplementedError("Subclasses must implement area()")

    def describe(self):
        return f"{self.color} {type(self).__name__} with area {self.area():.2f}"

class Circle(Shape):
    def __init__(self, radius, color="red"):
        super().__init__(color)
        self.radius = radius

    def area(self):  # override parent method
        import math
        return math.pi * self.radius ** 2

class Rectangle(Shape):
    def __init__(self, width, height, color="blue"):
        super().__init__(color)
        self.width = width
        self.height = height

    def area(self):  # override parent method
        return self.width * self.height

# Usage
shapes = [Circle(5), Rectangle(3, 4, "green"), Circle(2, "yellow")]
for shape in shapes:
    print(shape.describe())
# red Circle with area 78.54
# green Rectangle with area 12.00
# yellow Circle with area 12.57

super() — Calling Parent Methods

# super() lets you call the parent version of a method
class Employee:
    def __init__(self, name, salary):
        self.name = name
        self.salary = salary

    def get_info(self):
        return f"{self.name} - ${self.salary:,}"

class Manager(Employee):
    def __init__(self, name, salary, department):
        super().__init__(name, salary)  # call parent __init__
        self.department = department
        self.reports = []

    def add_report(self, employee):
        self.reports.append(employee)

    def get_info(self):
        # Extend parent method instead of replacing it
        base_info = super().get_info()
        return f"{base_info} | Manages {self.department} ({len(self.reports)} reports)"

emp = Employee("Alice", 75000)
mgr = Manager("Bob", 95000, "Engineering")
mgr.add_report(emp)

print(emp.get_info())  # Alice - $75,000
print(mgr.get_info())  # Bob - $95,000 | Manages Engineering (1 reports)

isinstance() and issubclass()

# Check type relationships
print(isinstance(dog, Dog))     # True
print(isinstance(dog, Animal))  # True (Dog inherits Animal)
print(isinstance(cat, Dog))     # False

print(issubclass(Dog, Animal))  # True
print(issubclass(Animal, Dog))  # False

# Practical: handle different types
def process(obj):
    if isinstance(obj, Manager):
        print(f"Manager: {obj.department}")
    elif isinstance(obj, Employee):
        print(f"Employee: {obj.name}")
    else:
        print("Unknown type")

• Child classes inherit all methods and attributes from the parent class.
• Use super().__init__() to call the parent constructor and avoid duplicating code.
• Override methods in child classes to customize behavior while keeping the same interface.
• Use isinstance() to check if an object is an instance of a class or its subclasses.
• Raise NotImplementedError in base class methods that subclasses must implement.