OOP Basics — Specification¶

class Point:
    def __init__(self, x: float, y: float):
        """Constructor: initializes state."""
        self.x = x          # Instance field
        self.y = y          # Instance field

    def distance_to(self, other: 'Point') -> float:
        """Instance method: operates on self."""
        return ((self.x - other.x)**2 + (self.y - other.y)**2) ** 0.5

    def __repr__(self) -> str:
        return f"Point({self.x}, {self.y})"

p1 = Point(0, 0)    # Step 1: allocate; Step 2: __init__
p2 = Point(3, 4)
print(p1.distance_to(p2))   # 5.0

class A: pass
class B(A): pass
class C(A): pass
class D(B, C): pass

print(D.__mro__)
# (<class 'D'>, <class 'B'>, <class 'C'>, <class 'A'>, <class 'object'>)
# MRO: D → B → C → A → object

class Animal:
    def sound(self) -> str:
        raise NotImplementedError("Subclasses must implement sound()")

class Dog(Animal):
    def sound(self) -> str:
        return "Woof"

class Cat(Animal):
    def sound(self) -> str:
        return "Meow"

def make_sounds(animals: list) -> None:
    """
    Polymorphic dispatch: the correct sound() method is called
    based on the RUNTIME type of each object, not the static type 'Animal'.
    """
    for animal in animals:
        print(animal.sound())   # Dynamic dispatch

make_sounds([Dog(), Cat(), Dog()])
# Woof
# Meow
# Woof

class Vehicle:
    def __init__(self, make: str, model: str, year: int):
        self.make = make
        self.model = model
        self.year = year

class Car(Vehicle):
    def __init__(self, make: str, model: str, year: int, doors: int):
        super().__init__(make, model, year)   # Call parent constructor
        self.doors = doors

class ElectricCar(Car):
    def __init__(self, make: str, model: str, year: int, doors: int, range_km: int):
        super().__init__(make, model, year, doors)  # Call Car constructor
        self.range_km = range_km

class A:
    def greet(self): print("Hello from A")

class B(A):
    def greet(self): print("Hello from B")

class C(A):
    def greet(self): print("Hello from C")

class D(B, C):
    pass

D().greet()  # "Hello from B" — MRO: D → B → C → A
print(D.__mro__)  # (D, B, C, A, object)

class A:
    def method(self):
        print("A.method")

class B(A):
    def method(self):
        print("B.method")
        super().method()    # Calls next in MRO (not necessarily A)

class C(A):
    def method(self):
        print("C.method")
        super().method()    # Calls next in MRO

class D(B, C):
    def method(self):
        print("D.method")
        super().method()

D().method()
# D.method → B.method → C.method → A.method
# super() follows the MRO, not the direct parent

# Python uses DUCK TYPING: "If it walks like a duck and quacks like a duck, it IS a duck"
# No need for explicit inheritance; method presence is sufficient

class Duck:
    def quack(self): print("Quack!")
    def walk(self): print("Walk...")

class Person:
    def quack(self): print("I'm quacking like a duck!")
    def walk(self): print("I'm walking like a duck!")

def in_the_pond(duck):
    duck.quack()    # Works for ANY object with a 'quack' method
    duck.walk()

in_the_pond(Duck())    # Works
in_the_pond(Person())  # Also works — duck typing, no isinstance() check needed

class OptimizedPoint:
    __slots__ = ['x', 'y']   # Only these attributes allowed

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

p = OptimizedPoint(1, 2)
# p.z = 3  # AttributeError: 'OptimizedPoint' has no attribute 'z'
# Memory: ~40-50% less per instance vs regular dict-backed object

from dataclasses import dataclass, field
from typing import ClassVar

@dataclass
class Student:
    """Auto-generates __init__, __repr__, __eq__ based on fields."""
    name: str
    student_id: int
    grades: list[float] = field(default_factory=list)  # Mutable default: safe
    school: ClassVar[str] = "MIT"  # Class variable; not included in __init__

    def gpa(self) -> float:
        if not self.grades:
            return 0.0
        return sum(self.grades) / len(self.grades)

s1 = Student("Alice", 1001)
s2 = Student("Bob", 1002, [3.8, 3.9, 4.0])
print(s2.gpa())    # 3.9
print(s1 == s2)    # False — __eq__ compares fields

from abc import ABC, abstractmethod
from typing import List
import math

# Abstract base class (Pillar 2: Abstraction)
class Shape(ABC):
    """
    Abstract class for geometric shapes.
    Class invariant: All shapes have a non-negative area.
    """

    def __init__(self, color: str = "white"):
        self._color = color   # Encapsulated (Pillar 1)

    @property
    def color(self) -> str:
        return self._color    # Controlled access

    @abstractmethod
    def area(self) -> float:
        """Returns the area of the shape."""
        pass

    @abstractmethod
    def perimeter(self) -> float:
        """Returns the perimeter of the shape."""
        pass

    def describe(self) -> str:
        """Concrete method — shared behavior."""
        return f"{self._color} {type(self).__name__}: area={self.area():.2f}"

    def __repr__(self) -> str:
        return f"{type(self).__name__}(color={self._color!r})"


# Concrete classes (Pillar 3: Inheritance)
class Circle(Shape):
    def __init__(self, radius: float, color: str = "red"):
        super().__init__(color)
        if radius <= 0:
            raise ValueError(f"Radius must be positive, got {radius}")
        self._radius = radius

    def area(self) -> float:
        return math.pi * self._radius ** 2

    def perimeter(self) -> float:
        return 2 * math.pi * self._radius


class Rectangle(Shape):
    def __init__(self, width: float, height: float, color: str = "blue"):
        super().__init__(color)
        if width <= 0 or height <= 0:
            raise ValueError("Width and height must be positive")
        self._width = width
        self._height = height

    def area(self) -> float:
        return self._width * self._height

    def perimeter(self) -> float:
        return 2 * (self._width + self._height)


class Square(Rectangle):
    """Square IS-A Rectangle (valid if LSP is respected here)."""

    def __init__(self, side: float, color: str = "green"):
        super().__init__(side, side, color)
        # Note: We do NOT override setters, so LSP is maintained here

    def perimeter(self) -> float:
        return 4 * self._width


# Polymorphism (Pillar 4)
def print_shapes(shapes: List[Shape]) -> None:
    """Works for ANY Shape subtype — polymorphic dispatch."""
    for shape in shapes:
        print(shape.describe())   # Calls correct area() at runtime

shapes = [Circle(5), Rectangle(4, 6), Square(3)]
print_shapes(shapes)
# red Circle: area=78.54
# blue Rectangle: area=24.00
# green Square: area=9.00

from typing import TypeVar, Generic, Optional, List

T = TypeVar('T')

class Stack(Generic[T]):
    """
    Generic stack — works for any type T.
    Parametric polymorphism: one implementation, many types.
    """

    def __init__(self) -> None:
        self._items: List[T] = []

    def push(self, item: T) -> None:
        """Push item onto the stack. O(1) amortized."""
        self._items.append(item)

    def pop(self) -> T:
        """Remove and return top item. O(1)."""
        if self.is_empty():
            raise IndexError("Pop from empty stack")
        return self._items.pop()

    def peek(self) -> T:
        """Return top item without removing. O(1)."""
        if self.is_empty():
            raise IndexError("Peek at empty stack")
        return self._items[-1]

    def is_empty(self) -> bool:
        return len(self._items) == 0

    def __len__(self) -> int:
        return len(self._items)

# Works for any type:
int_stack: Stack[int] = Stack()
int_stack.push(1)
int_stack.push(2)
print(int_stack.pop())   # 2

str_stack: Stack[str] = Stack()
str_stack.push("hello")
str_stack.push("world")
print(str_stack.pop())   # "world"