Objects & Classes

class BankAccount:
    interest_rate = 0.02          # class attribute: shared by all accounts

    def __init__(self, owner, balance=0):
        self.owner = owner        # instance attributes: this account's own
        self.balance = balance

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("deposit must be positive")
        self.balance += amount
        return self.balance

    def add_interest(self):
        self.balance += self.balance * self.interest_rate

acct = BankAccount("Ada", 100)
acct.deposit(50)
acct.add_interest()
print(acct.owner, acct.balance)
print(type(acct).__name__, isinstance(acct, BankAccount))
print(acct.__dict__)              # the instance attributes ARE a dict

class Animal:
    def __init__(self, name):
        self.name = name
    def speak(self):
        return "..."
    def intro(self):
        return f"{self.name} says {self.speak()}"

class Dog(Animal):
    def speak(self):                # override
        return "Woof"

class Puppy(Dog):
    def __init__(self, name, age_weeks):
        super().__init__(name)      # let Animal set self.name
        self.age_weeks = age_weeks
    def speak(self):
        return super().speak() + "!"   # extend rather than replace

for a in [Animal("Thing"), Dog("Rex"), Puppy("Bit", 8)]:
    print(a.intro())

p = Puppy("Bit", 8)
print(isinstance(p, Dog), isinstance(p, Animal), issubclass(Puppy, Animal))
print(Puppy.__bases__[0].__name__, Puppy.__mro__[1].__name__)

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

class LogMixin:
    def log(self, msg):
        print(f"[{type(self).__name__}] {msg}")

class Base:
    def describe(self):
        return "Base"

class Left(Base):
    def describe(self):
        return "Left → " + super().describe()

class Right(Base):
    def describe(self):
        return "Right → " + super().describe()

class Both(JSONMixin, LogMixin, Left, Right):
    def __init__(self):
        self.id = 7

b = Both()
print([c.__name__ for c in Both.__mro__])
print(b.describe())        # the diamond: each super() follows the MRO, so Base runs ONCE
b.log(b.to_json())

import math

class Circle:
    def __init__(self, r): self.r = r
    def area(self): return math.pi * self.r ** 2

class Square:
    def __init__(self, s): self.s = s
    def area(self): return self.s ** 2

class Text:                       # nothing to do with shapes…
    def area(self): return 0      # …but it quacks

shapes = [Circle(1), Square(3), Text()]
print([round(s.area(), 2) for s in shapes])
print(sum(s.area() for s in shapes) > 12)

# Built-ins are polymorphic the same way: len() works on anything with __len__
print(len("abc"), len([1, 2]), len({"k": 1}))

# Abstract base classes: when you DO want to force the method to exist
from abc import ABC, abstractmethod
class Shape(ABC):
    @abstractmethod
    def area(self): ...

try:
    Shape()
except TypeError as e:
    print("TypeError:", e)

class Money:
    def __init__(self, cents, currency="USD"):
        self.cents = cents
        self.currency = currency

    def __repr__(self):                 # for developers: unambiguous
        return f"Money({self.cents}, {self.currency!r})"

    def __str__(self):                  # for users: pretty
        return f"{self.cents / 100:.2f} {self.currency}"

    def __add__(self, other):
        if self.currency != other.currency:
            raise ValueError("currency mismatch")
        return Money(self.cents + other.cents, self.currency)

    def __eq__(self, other):
        return isinstance(other, Money) and (self.cents, self.currency) == (other.cents, other.currency)

    def __lt__(self, other):
        return self.cents < other.cents

    def __bool__(self):
        return self.cents != 0

a, b = Money(1999), Money(1)
print(a + b)                # __add__ then __str__
print(repr(a), [a])         # __repr__ (lists use repr for their items)
print(a == Money(1999), a != b, a < b)
print(sorted([a, b, Money(500)]))
print(bool(Money(0)), "zero is falsy")

class Temperature:
    def __init__(self, celsius):
        self.celsius = celsius       # goes through the setter below

    @property
    def celsius(self):
        return self._celsius

    @celsius.setter
    def celsius(self, value):
        if value < -273.15:
            raise ValueError("below absolute zero")
        self._celsius = value

    @property
    def fahrenheit(self):            # computed, read-only
        return self._celsius * 9 / 5 + 32

t = Temperature(25)
print(t.celsius, t.fahrenheit)      # attribute syntax, method behind it
t.celsius = 30
print(t.fahrenheit)
try:
    t.celsius = -300
except ValueError as e:
    print("rejected:", e)
try:
    t.fahrenheit = 100
except AttributeError as e:
    print("read-only:", e)

from dataclasses import dataclass, field, asdict

@dataclass
class Order:
    id: int
    customer: str
    items: list[str] = field(default_factory=list)   # never a bare [] default!
    total: float = 0.0

    def add(self, item, price):
        self.items.append(item)
        self.total += price

o = Order(1, "Ada")
o.add("book", 12.5)
print(o)                                  # __repr__ for free
print(o == Order(1, "Ada", ["book"], 12.5))   # __eq__ for free
print(asdict(o))

@dataclass(frozen=True, order=True)        # immutable and sortable
class Version:
    major: int
    minor: int

print(sorted([Version(1, 10), Version(1, 2)]))
try:
    Version(1, 0).major = 2
except Exception as e:
    print(type(e).__name__)