Dunder / Magic Methods

class Vector:
    def __init__(self, x: float, y: float) -> None:
        self.x = x
        self.y = y
 
    def __repr__(self) -> str:
        return f"Vector({self.x}, {self.y})"
 
    def __add__(self, other: "Vector") -> "Vector":
        return Vector(self.x + other.x, self.y + other.y)
 
    def __eq__(self, other: object) -> bool:
        if not isinstance(other, Vector):
            return NotImplemented
        return (self.x, self.y) == (other.x, other.y)

class Shelf:
    def __init__(self, items: list[str]) -> None:
        self._items = list(items)
 
    def __len__(self) -> int:
        return len(self._items)
 
    def __getitem__(self, index: int) -> str:
        return self._items[index]
 
    def __contains__(self, item: object) -> bool:
        return item in self._items
 
    def __repr__(self) -> str:
        return f"Shelf({self._items!r})"
 
class Money:
    __slots__ = ("amount", "currency")
 
    def __init__(self, amount: int, currency: str) -> None:
        self.amount = amount
        self.currency = currency
 
    def __eq__(self, other: object) -> bool:
        if not isinstance(other, Money):
            return NotImplemented
        return self.amount == other.amount and self.currency == other.currency
 
    def __hash__(self) -> int:
        return hash((self.amount, self.currency))
 
if __name__ == "__main__":
    s = Shelf(["a", "b"])
    print(len(s), "a" in s, s[0])
    cache = {Money(100, "USD"): "ok"}
    print(cache[Money(100, "USD")])

from functools import total_ordering
 
@total_ordering
class Version:
    def __init__(self, major: int, minor: int) -> None:
        self.major = major
        self.minor = minor
 
    def __eq__(self, other: object) -> bool:
        ...
 
    def __lt__(self, other: "Version") -> bool:
        return (self.major, self.minor) < (other.major, other.minor)