Inheritance in Python

"""
================================================================================
File: 03_inheritance.py
Topic: Inheritance in Python
================================================================================
 
This file demonstrates inheritance in Python, a fundamental OOP concept that
allows classes to inherit attributes and methods from other classes. This
promotes code reuse and establishes relationships between classes.
 
Key Concepts:
- Single inheritance
- Method overriding
- super() function
- Multiple inheritance
- Method Resolution Order (MRO)
- Abstract base classes
 
================================================================================
"""
 
# -----------------------------------------------------------------------------
# 1. Basic Inheritance
# -----------------------------------------------------------------------------
# Child class inherits from parent class
 
print("--- Basic Inheritance ---")
 
class Animal:
    """Base class for all animals."""
    
    def __init__(self, name):
        """Initialize animal with a name."""
        self.name = name
    
    def speak(self):
        """Make a generic sound."""
        return "Some generic sound"
    
    def describe(self):
        """Describe the animal."""
        return f"I am {self.name}"
 
class Dog(Animal):
    """Dog class inheriting from Animal."""
    pass  # Inherits everything from Animal
 
# Dog has all Animal's methods
buddy = Dog("Buddy")
print(buddy.describe())
print(f"Says: {buddy.speak()}")
print(f"Dog is instance of Animal: {isinstance(buddy, Animal)}")
 
# -----------------------------------------------------------------------------
# 2. Method Overriding
# -----------------------------------------------------------------------------
# Child class can override parent methods
 
print("\n--- Method Overriding ---")
 
class Cat(Animal):
    """Cat class with overridden method."""
    
    def speak(self):
        """Cats meow instead of generic sound."""
        return "Meow!"
 
class Cow(Animal):
    """Cow class with overridden method."""
    
    def speak(self):
        """Cows moo."""
        return "Moo!"
 
# Each animal speaks differently
animals = [Dog("Rex"), Cat("Whiskers"), Cow("Bessie")]
 
print("Each animal speaks:")
for animal in animals:
    print(f"  {animal.name}: {animal.speak()}")
 
# -----------------------------------------------------------------------------
# 3. Extending Parent Class with super()
# -----------------------------------------------------------------------------
# Use super() to call parent methods
 
print("\n--- Using super() ---")
 
class Bird(Animal):
    """Bird class extending Animal."""
    
    def __init__(self, name, can_fly=True):
        """Initialize bird with flying ability."""
        super().__init__(name)  # Call parent's __init__
        self.can_fly = can_fly
    
    def speak(self):
        """Birds chirp."""
        return "Chirp!"
    
    def describe(self):
        """Extend parent's describe method."""
        base = super().describe()  # Get parent's description
        fly_status = "can fly" if self.can_fly else "cannot fly"
        return f"{base} and I {fly_status}"
 
sparrow = Bird("Sparrow", can_fly=True)
penguin = Bird("Penny", can_fly=False)
 
print(sparrow.describe())
print(penguin.describe())
 
# -----------------------------------------------------------------------------
# 4. Inheritance Chain
# -----------------------------------------------------------------------------
# Classes can inherit from other child classes
 
print("\n--- Inheritance Chain ---")
 
class Vehicle:
    """Base vehicle class."""
    
    def __init__(self, brand):
        self.brand = brand
    
    def start(self):
        return "Vehicle starting..."
 
class Car(Vehicle):
    """Car inherits from Vehicle."""
    
    def __init__(self, brand, model):
        super().__init__(brand)
        self.model = model
    
    def start(self):
        return f"{self.brand} {self.model} engine starting..."
 
class ElectricCar(Car):
    """ElectricCar inherits from Car."""
    
    def __init__(self, brand, model, battery_kw):
        super().__init__(brand, model)
        self.battery_kw = battery_kw
    
    def start(self):
        return f"{self.brand} {self.model} powering up silently... (Battery: {self.battery_kw}kW)"
    
    def charge(self):
        return f"Charging {self.battery_kw}kW battery..."
 
# Create instances
regular_car = Car("Toyota", "Camry")
electric_car = ElectricCar("Tesla", "Model 3", 75)
 
print(regular_car.start())
print(electric_car.start())
print(electric_car.charge())
 
# Check inheritance
print(f"\nElectricCar is Car: {isinstance(electric_car, Car)}")
print(f"ElectricCar is Vehicle: {isinstance(electric_car, Vehicle)}")
 
# -----------------------------------------------------------------------------
# 5. Multiple Inheritance
# -----------------------------------------------------------------------------
# A class can inherit from multiple parent classes
 
print("\n--- Multiple Inheritance ---")
 
class Flyable:
    """Mixin class for flying ability."""
    
    def fly(self):
        return f"{self.name} is flying!"
    
    def land(self):
        return f"{self.name} has landed."
 
class Swimmable:
    """Mixin class for swimming ability."""
    
    def swim(self):
        return f"{self.name} is swimming!"
    
    def dive(self):
        return f"{self.name} dives underwater."
 
class Duck(Animal, Flyable, Swimmable):
    """Duck can do everything!"""
    
    def speak(self):
        return "Quack!"
 
# Duck has methods from all parent classes
duck = Duck("Donald")
print(f"{duck.name} says: {duck.speak()}")
print(duck.fly())
print(duck.swim())
print(duck.describe())
 
# -----------------------------------------------------------------------------
# 6. Method Resolution Order (MRO)
# -----------------------------------------------------------------------------
# Python determines method lookup order
 
print("\n--- Method Resolution Order (MRO) ---")
 
class A:
    def method(self):
        return "A"
 
class B(A):
    def method(self):
        return "B"
 
class C(A):
    def method(self):
        return "C"
 
class D(B, C):
    pass
 
class E(B, C):
    def method(self):
        return "E"
 
# Check MRO
print("MRO for class D:")
for cls in D.__mro__:
    print(f"  {cls.__name__}")
 
d = D()
e = E()
print(f"\nd.method(): {d.method()}")  # Returns "B" (first in MRO after D)
print(f"e.method(): {e.method()}")    # Returns "E" (overridden)
 
# -----------------------------------------------------------------------------
# 7. Calling Methods from Specific Parent
# -----------------------------------------------------------------------------
 
print("\n--- Calling Specific Parent Methods ---")
 
class Parent1:
    def greet(self):
        return "Hello from Parent1"
 
class Parent2:
    def greet(self):
        return "Hello from Parent2"
 
class Child(Parent1, Parent2):
    def greet(self):
        return "Hello from Child"
    
    def greet_all(self):
        """Call all parent greet methods."""
        return [
            f"Child: {self.greet()}",
            f"Parent1: {Parent1.greet(self)}",
            f"Parent2: {Parent2.greet(self)}"
        ]
 
child = Child()
print("Calling all greet methods:")
for greeting in child.greet_all():
    print(f"  {greeting}")
 
# -----------------------------------------------------------------------------
# 8. Abstract Base Classes
# -----------------------------------------------------------------------------
# Define interfaces that must be implemented
 
print("\n--- Abstract Base Classes ---")
 
from abc import ABC, abstractmethod
 
class Shape(ABC):
    """Abstract base class for shapes."""
    
    @abstractmethod
    def area(self):
        """Calculate area - must be implemented."""
        pass
    
    @abstractmethod
    def perimeter(self):
        """Calculate perimeter - must be implemented."""
        pass
    
    def describe(self):
        """Non-abstract method - can be used as-is."""
        return f"A shape with area {self.area():.2f}"
 
class Rectangle(Shape):
    """Concrete rectangle class."""
    
    def __init__(self, width, height):
        self.width = width
        self.height = height
    
    def area(self):
        return self.width * self.height
    
    def perimeter(self):
        return 2 * (self.width + self.height)
 
class Circle(Shape):
    """Concrete circle class."""
    
    def __init__(self, radius):
        self.radius = radius
    
    def area(self):
        import math
        return math.pi * self.radius ** 2
    
    def perimeter(self):
        import math
        return 2 * math.pi * self.radius
 
# Cannot instantiate abstract class
# shape = Shape()  # TypeError!
 
# Concrete classes work fine
rect = Rectangle(5, 3)
circle = Circle(4)
 
print(f"Rectangle: area={rect.area()}, perimeter={rect.perimeter()}")
print(f"Circle: area={circle.area():.2f}, perimeter={circle.perimeter():.2f}")
print(rect.describe())
 
# -----------------------------------------------------------------------------
# 9. Using isinstance() and issubclass()
# -----------------------------------------------------------------------------
 
print("\n--- Type Checking ---")
 
class Mammal(Animal):
    pass
 
class Reptile(Animal):
    pass
 
class DogV2(Mammal):
    def speak(self):
        return "Woof!"
 
class Snake(Reptile):
    def speak(self):
        return "Hiss!"
 
dog = DogV2("Rex")
snake = Snake("Slinky")
 
# isinstance() checks if object is instance of class
print("isinstance checks:")
print(f"  dog isinstance of DogV2: {isinstance(dog, DogV2)}")
print(f"  dog isinstance of Mammal: {isinstance(dog, Mammal)}")
print(f"  dog isinstance of Animal: {isinstance(dog, Animal)}")
print(f"  dog isinstance of Reptile: {isinstance(dog, Reptile)}")
 
# issubclass() checks class relationships
print("\nissubclass checks:")
print(f"  DogV2 issubclass of Mammal: {issubclass(DogV2, Mammal)}")
print(f"  DogV2 issubclass of Animal: {issubclass(DogV2, Animal)}")
print(f"  DogV2 issubclass of Reptile: {issubclass(DogV2, Reptile)}")
 
# -----------------------------------------------------------------------------
# 10. Practical Example: Employee Hierarchy
# -----------------------------------------------------------------------------
 
print("\n--- Practical Example: Employee Hierarchy ---")
 
class Employee:
    """Base employee class."""
    
    def __init__(self, name, employee_id, salary):
        self.name = name
        self.employee_id = employee_id
        self._salary = salary
    
    @property
    def salary(self):
        return self._salary
    
    def get_annual_salary(self):
        return self._salary * 12
    
    def __str__(self):
        return f"{self.name} (ID: {self.employee_id})"
 
class Manager(Employee):
    """Manager with team and bonus."""
    
    def __init__(self, name, employee_id, salary, team_size=0):
        super().__init__(name, employee_id, salary)
        self.team_size = team_size
    
    def get_annual_salary(self):
        # Managers get bonus based on team size
        base = super().get_annual_salary()
        bonus = self.team_size * 1000  # $1000 per team member
        return base + bonus
    
    def __str__(self):
        return f"Manager {super().__str__()} - Team: {self.team_size}"
 
class Developer(Employee):
    """Developer with tech stack."""
    
    def __init__(self, name, employee_id, salary, languages):
        super().__init__(name, employee_id, salary)
        self.languages = languages
    
    def get_annual_salary(self):
        # Developers get extra for each language
        base = super().get_annual_salary()
        language_bonus = len(self.languages) * 500  # $500 per language
        return base + language_bonus
    
    def __str__(self):
        langs = ", ".join(self.languages)
        return f"Developer {super().__str__()} - Languages: {langs}"
 
# Create employees
manager = Manager("Alice", "M001", 8000, team_size=5)
dev1 = Developer("Bob", "D001", 6000, ["Python", "JavaScript", "SQL"])
dev2 = Developer("Charlie", "D002", 5500, ["Python"])
 
employees = [manager, dev1, dev2]
 
print("Employee Details:")
for emp in employees:
    print(f"  {emp}")
    print(f"    Annual Salary: ${emp.get_annual_salary():,}")