Inheritance & Polymorphism (Expert) 🧬

# Step 1: Create the Parent (Base) class
class Animal:
    def __init__(self, name):
        self.name = name  # All animals have a name

    def speak(self):
        print(f"{self.name} makes a sound")

# Step 2: Create Child (Derived) classes that inherit from Animal
class Dog(Animal):  # Dog inherits from Animal
    def speak(self):  # Override the speak method
        print(f"{self.name} barks")

class Cat(Animal):  # Cat inherits from Animal
    def speak(self):  # Override the speak method
...

class Animal:
    def __init__(self, name):
        self.name = name  # Parent sets up 'name'
        print(f"Animal init: {name}")

class Dog(Animal):
    def __init__(self, name, breed):
        # Step 1: Call parent's __init__ FIRST
        super().__init__(name)   # ← This runs Animal.__init__
        
        # Step 2: Then add child-specific attributes
        self.breed = breed
        print(f"Dog init: {breed}")

# When we create a Dog, BOTH __init__ methods run!
dog = Dog("Buddy", "Gold
...

from datetime import datetime

class Logger:
    def log(self, msg):
        print(f"[LOG] {msg}")

class TimedLogger(Logger):
    def log(self, msg):
        timestamp = datetime.now().strftime("%H:%M:%S")
        super().log(f"{timestamp} — {msg}")  # extend

logger = TimedLogger()
logger.log("Application started")
logger.log("User logged in")

# Two separate parent classes
class Walker:
    def walk(self): print("Walking")

class Swimmer:
    def swim(self): print("Swimming")

# Duck inherits from BOTH Walker AND Swimmer!
class Duck(Walker, Swimmer):  # ← Multiple inheritance
    def quack(self): print("Quack!")

# Duck can do everything!
d = Duck()
d.walk()   # From Walker
d.swim()   # From Swimmer  
d.quack()  # Its own method

# See the order Python checks for methods:
print("\nMRO:", [c.__name__ for c in Duck.mro()])

# These classes have NO common parent!
class Dog:
    def speak(self): return "Woof!"

class Cat:
    def speak(self): return "Meow!"

class Duck:
    def speak(self): return "Quack!"

# But they ALL have .speak() - that's all we need!
def chorus(animals):
    for a in animals:
        print(a.speak())  # Works because they all have .speak()

# Python doesn't check types - it just calls the method
chorus([Dog(), Cat(), Duck()])

from abc import ABC, abstractmethod
import math

# Abstract class - can't be instantiated directly
class Shape(ABC):
    @abstractmethod  # ← This decorator means "child MUST implement this"
    def area(self) -> float: ...

# Concrete classes - MUST implement area()
class Rectangle(Shape):
    def __init__(self, w, h): self.w, self.h = w, h
    def area(self) -> float: return self.w * self.h  # ✅ Implemented!

class Circle(Shape):
    def __init__(self, r): self.r = r
    def area(self) -> floa
...

from typing import Protocol

class AreaLike(Protocol):
    def area(self) -> float: ...

def total_area(shapes: list) -> float:
    return sum(s.area() for s in shapes)

# Any class with .area() works, no inheritance needed!
class Square:
    def __init__(self, side): self.side = side
    def area(self): return self.side ** 2

class Triangle:
    def __init__(self, base, height): 
        self.base, self.height = base, height
    def area(self): return 0.5 * self.base * self.height

shapes = [Sq
...

# ✅ Composition - HAS-A relationship
class Logger:
    def log(self, msg):
        print(f"[LOG] {msg}")

class FancyFileLogger:
    def __init__(self, logger):
        self.logger = logger  # HAS-A
    
    def log(self, msg):
        self.logger.log(f"✨ {msg}")

base_logger = Logger()
fancy = FancyFileLogger(base_logger)
fancy.log("Hello World")

# Composition is easier to refactor and test!

import json

class JSONSerializableMixin:
    def to_json(self):
        return json.dumps(self.__dict__)

class TimestampMixin:
    def get_timestamp(self):
        from datetime import datetime
        return datetime.now().isoformat()

class User(JSONSerializableMixin, TimestampMixin):
    def __init__(self, name, email): 
        self.name = name
        self.email = email

user = User("Boopie", "boopie@example.com")
print(user.to_json())
print(user.get_timestamp())

from abc import ABC, abstractmethod
import math

class Shape(ABC):
    @abstractmethod
    def area(self) -> float: ...

class Rectangle(Shape):
    def __init__(self, w, h): self.w, self.h = w, h
    def area(self): return self.w * self.h
    def __repr__(self): return f"Rectangle({self.w}x{self.h})"

class Circle(Shape):
    def __init__(self, r): self.r = r
    def area(self): return math.pi * self.r**2
    def __repr__(self): return f"Circle(r={self.r})"

shapes = [Rectangle(3,4), Circle(2),
...

class Vector2:
    def __init__(self, x, y): 
        self.x, self.y = x, y
    
    def __add__(self, other):
        return Vector2(self.x + other.x, self.y + other.y)
    
    def __mul__(self, scalar):
        return Vector2(self.x * scalar, self.y * scalar)
    
    def __repr__(self): 
        return f"Vector2({self.x}, {self.y})"

v1 = Vector2(1, 2)
v2 = Vector2(3, 4)
print(f"{v1} + {v2} = {v1 + v2}")
print(f"{v1} * 3 = {v1 * 3}")

class CashPayment:
    def pay(self, amount): print(f"Paid £{amount} cash")

class CardPayment:
    def pay(self, amount): print(f"Charged £{amount} to card")

class CryptoPayment:
    def pay(self, amount): print(f"Sent £{amount} in crypto")

def checkout(amount, method):
    method.pay(amount)  # any object with .pay works

for m in (CashPayment(), CardPayment(), CryptoPayment()):
    checkout(9.99, m)

class Base:
    def __init__(self, **kw):
        super().__init__(**kw)
        self.base = True

class A(Base):
    def __init__(self, a, **kw):
        super().__init__(**kw)
        self.a = a

class B(Base):
    def __init__(self, b, **kw):
        super().__init__(**kw)
        self.b = b

class C(A, B):
    def __init__(self, a, b):
        super().__init__(a=a, b=b)

c = C(1, 2)
print(f"a={c.a}, b={c.b}, base={c.base}")
print("MRO:", [cls.__name__ for cls in C.mro()])