12 — Classes & Objects

# ── Production: a validated, memory-efficient data class ──
# Combines @dataclass (auto __init__/__repr__/__eq__) with __slots__ (no __dict__)
# and __post_init__ for validation that can't be expressed in type hints alone.

from dataclasses import dataclass, field
from datetime import datetime

@dataclass(frozen=True, slots=True)
class User:
    """
    Immutable user record — frozen=True makes it hashable (can be a dict key/set member),
    slots=True eliminates __dict__ overhead (~40% memory reduction per instance).
    """
    id: int
    email: str
    name: str
    created_at: datetime = field(default_factory=datetime.now)  # mutable default → factory
    roles: frozenset[str] = field(default_factory=frozenset)     # frozenset: immutable + hashable

    def __post_init__(self):
        # frozen=True means attributes can't be set normally — use object.__setattr__
        # to work around the frozen restriction for validation-driven adjustments
        if not self.email or "@" not in self.email:
            raise ValueError(f"invalid email: {self.email!r}")
        if self.id <= 0:
            raise ValueError(f"id must be positive, got {self.id}")

# Frozen + slots dataclass is hashable → usable as dict keys and set members
user = User(id=1, email="ada@example.com", "name"="Ada")
print(user)   # User(id=1, email='ada@example.com', name='Ada', created_at=..., roles=frozenset())
# user.email = "x"  # FrozenInstanceError — can't mutate a frozen dataclass

# Can be used as a dict key (hashable because frozen + all fields hashable)
user_index = {user: "admin"}

# ── Memory comparison: __dict__ vs __slots__ ──
import sys

@dataclass
class UserDict:
    id: int
    email: str
    name: str

@dataclass(slots=True)
class UserSlots:
    id: int
    email: str
    name: str

ud = UserDict(1, "a@b.com", "Ada")
us = UserSlots(1, "a@b.com", "Ada")
print(f"with __dict__:    {sys.getsizeof(ud) + sys.getsizeof(ud.__dict__)} bytes")
print(f"with __slots__:   {sys.getsizeof(us)} bytes")
# Typical: ~232 bytes vs ~64 bytes — 3.6× smaller, compounds at millions of instances

class Counter:
    def __init__(self):
        self.count = 0

    def increment(self):
        self.count += 1
        return self.count

c = Counter()
print(c.increment())        # 1 — sugar for Counter.increment(c)
print(Counter.increment(c))   # 2 — identical, explicit form

class Employee:
    company = "Acme Corp"          # CLASS attribute — shared by ALL instances

    def __init__(self, name):
        self.name = name              # INSTANCE attribute — unique per object

alice = Employee("Alice")
bob = Employee("Bob")

print(alice.company, bob.company)   # Acme Corp Acme Corp — same object, shared
print(Employee.company)               # Acme Corp

Employee.company = "NewCo"              # changes it for ALL instances (and future ones)
print(alice.company, bob.company)         # NewCo NewCo

alice.company = "Alice's Startup"           # creates a NEW instance attribute on alice,
print(alice.company, bob.company)             # SHADOWING the class attribute — doesn't touch it
# Alice's Startup NewCo

# WRONG — a mutable class attribute is SHARED and mutated in place by every instance
class ShoppingCart:
    items = []                    # class attribute — ONE list shared by all carts!

    def add(self, item):
        self.items.append(item)     # mutates the SHARED list, doesn't create a new one

cart_a = ShoppingCart()
cart_b = ShoppingCart()
cart_a.add("apple")
print(cart_b.items)   # ['apple'] — leaked into cart_b, which never touched cart_a!

# RIGHT — initialize mutable state in __init__, so each instance gets its own
class ShoppingCartFixed:
    def __init__(self):
        self.items = []              # instance attribute — fresh list per instance

cart_c = ShoppingCartFixed()
cart_d = ShoppingCartFixed()
cart_c.add = lambda item: cart_c.items.append(item)
cart_c.add("banana")
print(cart_d.items)   # [] — correctly isolated

class Pizza:
    def __init__(self, toppings):
        self.toppings = toppings

    def describe(self):                       # instance method — needs an instance
        return f"Pizza with {', '.join(self.toppings)}"

    @classmethod
    def margherita(cls):                       # classmethod — receives the CLASS, not an instance
        return cls(["mozzarella", "basil"])       # cls(...) so subclasses construct correctly

    @staticmethod
    def is_valid_topping(topping):                # staticmethod — no self, no cls, just a namespaced function
        return topping.lower() not in {"pineapple"}

p = Pizza.margherita()
print(p.describe())                    # Pizza with mozzarella, basil
print(Pizza.is_valid_topping("ham"))     # True
print(Pizza.is_valid_topping("pineapple"))  # False (a controversial but valid design opinion)

class StuffedCrustPizza(Pizza):
    pass

sc = StuffedCrustPizza.margherita()
print(type(sc))   # <class '__main__.StuffedCrustPizza'> — NOT Pizza, thanks to cls(...)

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

p = Point(1, 2)
print(p.__dict__)   # {'x': 1, 'y': 2}

p.z = 99            # you can add attributes NOT declared in __init__ at all
print(p.__dict__)     # {'x': 1, 'y': 2, 'z': 99}

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

    def __repr__(self):                        # unambiguous, developer-facing representation
        return f"Vector({self.x}, {self.y})"

    def __eq__(self, other):                   # powers ==
        return isinstance(other, Vector) and self.x == other.x and self.y == other.y

    def __add__(self, other):                  # powers +
        return Vector(self.x + other.x, self.y + other.y)

v1 = Vector(1, 2)
v2 = Vector(3, 4)
print(v1 + v2)          # Vector(4, 6) — uses __add__ and __repr__
print(v1 == Vector(1, 2))   # True — uses __eq__
print([v1, v2])                # [Vector(1, 2), Vector(3, 4)] — repr used inside containers

class Animal:
    pass

class Dog(Animal):
    pass

d = Dog()

print(isinstance(d, Dog))       # True
print(isinstance(d, Animal))      # True — isinstance respects inheritance
print(type(d) == Animal)            # False — exact type check, ignores inheritance
print(type(d) == Dog)                 # True

print("before class")

class Demo:
    print("inside class body")     # runs ONCE, when the class statement executes
    x = 1 + 1                        # a normal assignment — becomes a class attribute
    print(f"x is now {x}")

print("after class")
print(Demo.x)

# Output:
# before class
# inside class body
# x is now 2
# after class
# 2

class Player:
    inventory = []

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

    def pick_up(self, item):
        self.inventory.append(item)

alice = Player("Alice")
alice.pick_up("sword")

bob = Player("Bob")
print(bob.inventory)