Object-Oriented Programming

# Define a class (blueprint)
class Dog:
    # This runs when we create a Dog object
    def __init__(self, name, breed):
        self.name  = name    # store name on this object
        self.breed = breed   # store breed on this object

    # A method (a function inside a class)
    def bark(self):
        return f"{self.name} says: Woof!"

    def info(self):
        return f"{self.name} is a {self.breed}"

# Create objects (instances) from the class
dog1 = Dog("Rex",   "Labrador")
dog2 = Dog("Max",   "Pug")
dog3 = Dog("Bella", "Husky")

# Use the objects
print(dog1.bark())    # Rex says: Woof!
print(dog2.info())    # Max is a Pug
print(dog3.name)      # Bella

# Each object is independent
dog1.name = "Rocky"   # only dog1 changes
print(dog1.name)      # Rocky
print(dog2.name)      # Max   (unchanged)

# Check type
print(type(dog1))               # <class '__main__.Dog'>
print(isinstance(dog1, Dog))    # True

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        # For humans: nice and clean
        return f"Point({self.x}, {self.y})"

    def __repr__(self):
        # For developers: shows how to recreate it
        return f"Point(x={self.x}, y={self.y})"

p = Point(3, 4)

# __str__ used by print and f-strings
print(p)              # Point(3, 4)
print(f"Location: {p}")   # Location: Point(3, 4)
print(str(p))         # Point(3, 4)

# __repr__ used in REPL and repr()
print(repr(p))        # Point(x=3, y=4)

# Without __str__, Python falls back to __repr__
class Bare:
    def __repr__(self):
        return "I am Bare"

b = Bare()
print(b)              # I am Bare  (__repr__ used as fallback)
print(repr(b))        # I am Bare

# In a list, __repr__ is used for each item
pts = [Point(1,2), Point(3,4)]
print(pts)
# [Point(x=1, y=2), Point(x=3, y=4)]  -- uses __repr__ inside list

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

    def eat(self):
        return f"{self.name} is eating"

    def sleep(self):
        return f"{self.name} is sleeping"

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

class Dog(Animal):   # Dog inherits from Animal
    def __init__(self, name, breed):
        super().__init__(name)   # call Animal's __init__
        self.breed = breed       # add extra attribute

    def bark(self):              # new method (only for Dog)
        return f"{self.name} says: Woof!"

    def sound(self):             # OVERRIDE: replace Animal's version
        return f"{self.name} says: Woof!"

class Cat(Animal):
    def __init__(self, name, indoor):
        super().__init__(name)
        self.indoor = indoor

    def sound(self):             # OVERRIDE: Cat's own version
        return f"{self.name} says: Meow!"

dog = Dog("Rex", "Lab")
cat = Cat("Whiskers", True)

# Inherited methods work
print(dog.eat())     # Rex is eating
print(cat.sleep())   # Whiskers is sleeping

# Overridden method: each uses its own version
print(dog.sound())   # Rex says: Woof!
print(cat.sound())   # Whiskers says: Meow!

# New method only in Dog
print(dog.bark())    # Rex says: Woof!
# cat.bark()         # AttributeError: Cat has no bark()

# isinstance check
print(isinstance(dog, Dog))     # True
print(isinstance(dog, Animal))  # True (Dog IS an Animal)
print(isinstance(cat, Dog))     # False

class Shape:
    def __init__(self, colour):
        self.colour = colour

    def describe(self):
        return f"I am a {self.colour} shape"

class Circle(Shape):
    def __init__(self, colour, radius):
        super().__init__(colour)   # runs Shape's __init__
        self.radius = radius

    def describe(self):
        # Call parent's describe, then add more info
        base = super().describe()  # "I am a red shape"
        return f"{base} (circle, radius={self.radius})"

    def area(self):
        return 3.14159 * self.radius ** 2

class Square(Shape):
    def __init__(self, colour, side):
        super().__init__(colour)
        self.side = side

    def area(self):
        return self.side ** 2

c = Circle("red", 5)
s = Square("blue", 4)

print(c.describe())   # I am a red shape (circle, radius=5)
print(s.describe())   # I am a blue shape  (from parent)
print(c.area())       # 78.53975
print(s.area())       # 16

class TaxRate:
    def calculate(self, amount):
        return amount * 0.05  # Base default rate (5%)

class LuxuryTaxRate(TaxRate):
    def calculate(self, amount):
        return amount * 0.18  # OVERRIDE: Replace parent rate entirely

# --------------------------------------------------------------
# Framework Extension using super()
# --------------------------------------------------------------
class Report:
    def generate(self):
        return "Base Report Content"

class EncryptedReport(Report):
    def generate(self):
        # 1. Fetch data from base parent framework using super()
        raw_data = super().generate()
        # 2. Add specific child modification layer
        return f"[ENCRYPTED] {raw_data}"

# --- Testing Replacement Overriding ---
standard = TaxRate()
luxury = LuxuryTaxRate()

print(standard.calculate(1000))  # Output: 50.0
print(luxury.calculate(1000))    # Output: 180.0 (Parent calculation is skipped)

# --- Testing Extended Overriding ---
secure_doc = EncryptedReport()
print(secure_doc.generate())      # Output: [ENCRYPTED] Base Report Content

class Vehicle:
    """Tier 1: The Grandparent Class"""
    def __init__(self, brand):
        self.brand = brand

    def start(self):
        return f"{self.brand} engine started."

class Car(Vehicle):
    """Tier 2: The Parent Class"""
    def __init__(self, brand, doors):
        super().__init__(brand) # Forward to Vehicle constructor
        self.doors = doors

    def drive(self):
        return f"Driving the {self.brand} car with {self.doors} doors."

class ElectricCar(Car):
    """Tier 3: The Child Class"""
    def __init__(self, brand, doors, battery_kwh):
        super().__init__(brand, doors) # Forward to Car constructor
        self.battery_kwh = battery_kwh

    def charge(self):
        return f"Charging the {self.battery_kwh}kWh battery pack."

# --- Testing the Multi-Tier Blueprint ---
tesla = ElectricCar(brand="Tesla", doors=4, battery_kwh=75)

# Accessing methods accumulated from all 3 structural tiers
print(tesla.start())   # Tier 1 Grandparent Method
print(tesla.drive())   # Tier 2 Parent Method
print(tesla.charge())  # Tier 3 Child Method

# --- Verifying Method Resolution Order (MRO) ---
print([cls.__name__ for cls in ElectricCar.__mro__])
# Output: ['ElectricCar', 'Car', 'Vehicle', 'object']

class BankAccount:
    def __init__(self, owner, balance, pin):
        self.owner    = owner          # public: ok to read
        self._balance = balance        # "please don't touch"
        self.__pin    = pin            # name mangled: hard to access

    def deposit(self, amount):
        if amount > 0:
            self._balance += amount
            return f"Deposited {amount}. Balance: {self._balance}"

    def withdraw(self, amount, pin):
        if pin != self.__pin:
            return "Wrong PIN!"
        if amount > self._balance:
            return "Not enough money"
        self._balance -= amount
        return f"Withdrew {amount}. Balance: {self._balance}"

    @property
    def balance(self):               # read-only access via property
        return self._balance

acc = BankAccount("Alice", 10000, 1234)

# Public attribute: accessible
print(acc.owner)           # Alice

# Protected: accessible but convention says don't
print(acc._balance)        # 10000  (works but bad style)

# Name-mangled: acc.__pin fails
try:
    print(acc.__pin)       # AttributeError!
except AttributeError as e:
    print(e)               # 'BankAccount' object has no attribute '__pin'

# But you can still reach it this way (don't do this!)
print(acc._BankAccount__pin)   # 1234  (mangled name)

# Use the methods properly
print(acc.deposit(5000))       # Deposited 5000. Balance: 15000
print(acc.withdraw(2000, 9999)) # Wrong PIN!
print(acc.withdraw(2000, 1234)) # Withdrew 2000. Balance: 13000
print(acc.balance)              # 13000  (via property)

# Name mangling prevents child class collision
class SavingsAccount(BankAccount):
    def __init__(self, owner, balance, pin, interest_rate):
        super().__init__(owner, balance, pin)
        self.__pin = "child_pin"    # stored as _SavingsAccount__pin
                                     # does NOT overwrite BankAccount's __pin!

sa = SavingsAccount("Bob", 5000, 5678, 0.05)
print(sa.withdraw(1000, 5678))   # Withdrew 1000... (uses BankAccount's __pin)

from abc import ABC, abstractmethod
import math

class Shape(ABC):   # ABC makes this an abstract class
    """Every shape must have area() and perimeter()."""

    @abstractmethod
    def area(self):
        pass   # no body needed -- child must provide it

    @abstractmethod
    def perimeter(self):
        pass

    # Non-abstract method: shared by all shapes
    def describe(self):
        return (f"{self.__class__.__name__}: "
                f"area={self.area():.2f}, "
                f"perimeter={self.perimeter():.2f}")

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):              # MUST define
        return math.pi * self.radius ** 2

    def perimeter(self):         # MUST define
        return 2 * math.pi * self.radius

class Rectangle(Shape):
    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 Triangle(Shape):
    def __init__(self, a, b, c):
        self.a, self.b, self.c = a, b, c

    def area(self):
        s = (self.a + self.b + self.c) / 2   # semi-perimeter
        return math.sqrt(s*(s-self.a)*(s-self.b)*(s-self.c))

    def perimeter(self):
        return self.a + self.b + self.c

# Cannot create Shape directly
try:
    s = Shape()   # TypeError!
except TypeError as e:
    print(e)      # Can't instantiate abstract class Shape

# Can create concrete subclasses
c = Circle(5)
r = Rectangle(4, 6)
t = Triangle(3, 4, 5)

print(c.describe())   # Circle: area=78.54, perimeter=31.42
print(r.describe())   # Rectangle: area=24.00, perimeter=20.00
print(t.describe())   # Triangle: area=6.00, perimeter=12.00

# Use polymorphism: list of shapes
shapes = [Circle(3), Rectangle(2,5), Triangle(3,4,5)]
total_area = sum(s.area() for s in shapes)
print(f"Total area: {total_area:.2f}")   # Total area: 48.27

# Class that misses an abstract method
class BadShape(Shape):
    def area(self):
        return 0
    # forgot perimeter()!

try:
    b = BadShape()   # TypeError!
except TypeError as e:
    print(e)   # Can't instantiate abstract class BadShape
               # without an implementation for abstract method 'perimeter'

# Q1: Class variable shared -- what prints?
class Counter:
    count = 0
    def __init__(self):
        Counter.count += 1

a = Counter()
b = Counter()
c = Counter()
print(Counter.count)   # 3  (shared across all instances)

# Q2: Instance variable shadows class variable
class Dog:
    legs = 4
d = Dog()
d.legs = 3             # creates instance var, shadows class var
print(d.legs)          # 3
print(Dog.legs)        # 4  (class var unchanged)

# Q3: MRO -- which method runs?
class A:
    def hello(self): return "A"
class B(A):
    def hello(self): return "B"
class C(A):
    def hello(self): return "C"
class D(B, C):
    pass

print(D().hello())     # B  (MRO: D -> B -> C -> A)
print(D.__mro__)       # D, B, C, A, object

# Q4: super() chain
class X:
    def go(self): print("X")
class Y(X):
    def go(self): print("Y"); super().go()
class Z(Y):
    def go(self): print("Z"); super().go()
Z().go()   # Z / Y / X

# Q5: Property vs plain method
class Circle:
    def __init__(self, r): self.r = r
    @property
    def area(self): return 3.14 * self.r**2

c = Circle(5)
print(c.area)      # 78.5  (no parentheses -- it's a property)
# print(c.area())  # TypeError: 'float' is not callable