Inheritance & Polymorphism

# Parent class (base class)
class Animal:
    def __init__(self, name, species):
        self.name    = name
        self.species = species
        self.energy  = 100

    def eat(self, food):
        self.energy += 10
        return f"{self.name} eats {food}. Energy: {self.energy}"

    def speak(self):
        return "..."

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


# Child class — inherits everything from Animal
class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name, "Canis lupus")  # call parent __init__
        self.breed = breed   # dog-specific attribute

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

    # New method — only on Dog
    def fetch(self, item):
        self.energy -= 15
        return f"{self.name} fetches the {item}! Energy: {self.energy}"


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

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


dog = Dog("Rex", "German Shepherd")
cat = Cat("Luna")

print(dog)                   # Rex (Canis lupus) — uses Animal.__str__
print(dog.speak())           # Rex says: Woof! 🐶
print(dog.eat("kibble"))    # inherited from Animal
print(dog.fetch("ball"))    # Dog-only method
print(cat.speak())           # Luna says: Meow! 🐱

# isinstance checks
print(isinstance(dog, Dog))    # True
print(isinstance(dog, Animal)) # True  — Dog IS AN Animal
print(isinstance(cat, Dog))    # False

# Polymorphism — one function, many types
def animal_concert(animals):
    """Make every animal speak — works for any Animal subclass."""
    for animal in animals:
        print(animal.speak())   # each responds differently

class Bird(Animal):
    def __init__(self, name):
        super().__init__(name, "Aves")
    def speak(self):
        return f"{self.name} says: Tweet! 🐦"

zoo = [Dog("Rex", "Lab"), Cat("Luna"), Bird("Tweety")]
animal_concert(zoo)
# Rex says: Woof! 🐶
# Luna says: Meow! 🐱
# Tweety says: Tweet! 🐦

# Polymorphism with built-in operators
class Vector:
    def __init__(self, x, y):
        self.x, self.y = x, y
    def __add__(self, other):
        return Vector(self.x+other.x, self.y+other.y)
    def __str__(self):
        return f"Vector({self.x}, {self.y})"

v1 = Vector(1, 2)
v2 = Vector(3, 4)
print(v1 + v2)  # Vector(4, 6) — + works on custom class!

from abc import ABC, abstractmethod

class Shape(ABC):
    """Abstract base — every shape MUST implement area and perimeter."""

    @abstractmethod
    def area(self):
        pass

    @abstractmethod
    def perimeter(self):
        pass

    # Non-abstract method — available to all subclasses
    def describe(self):
        return f"{type(self).__name__}: area={self.area():.2f}, perimeter={self.perimeter():.2f}"


class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
    def area(self):      return 3.14159 * self.radius ** 2
    def perimeter(self): return 2 * 3.14159 * self.radius


class Rectangle(Shape):
    def __init__(self, w, h):
        self.w, self.h = w, h
    def area(self):      return self.w * self.h
    def perimeter(self): return 2 * (self.w + self.h)


# Shape()  ← TypeError: Can't instantiate abstract class

shapes = [Circle(5), Rectangle(4, 6), Circle(3)]
for s in shapes:
    print(s.describe())
# Circle: area=78.54, perimeter=31.42
# Rectangle: area=24.00, perimeter=20.00
# Circle: area=28.27, perimeter=18.85

# Total area — polymorphic sum!
total = sum(s.area() for s in shapes)
print(f"Total area: {total:.2f}")

class Flyable:
    def move(self): return "Flying ✈️"
    def describe(self): return "I can fly"

class Swimmable:
    def move(self): return "Swimming 🏊"
    def describe(self): return "I can swim"

class Duck(Flyable, Swimmable):  # Flyable listed first → takes priority
    def speak(self): return "Quack! 🦆"

d = Duck()
print(d.move())     # Flying ✈️  — Flyable wins (listed first)
print(d.speak())    # Quack! 🦆

# Inspect the MRO
print(Duck.__mro__)
# (, , , )

# Mixin pattern — most practical use of multiple inheritance
class JSONMixin:
    """Add JSON serialisation to any class."""
    def to_json(self):
        import json
        return json.dumps(self.__dict__)

class ReprMixin:
    """Auto __repr__ from __dict__."""
    def __repr__(self):
        attrs = ", ".join(f"{k}={v!r}" for k, v in self.__dict__.items())
        return f"{type(self).__name__}({attrs})"

class Product(JSONMixin, ReprMixin):
    def __init__(self, name, price):
        self.name = name
        self.price= price

p = Product("Python Book", 1500)
print(p)             # Product(name='Python Book', price=1500)
print(p.to_json())   # {"name": "Python Book", "price": 1500}