Магические методы

from datetime import date

class Money:
    def __init__(self, amount, currency="RUB"):
        self.amount, self.currency = amount, currency

    def __repr__(self):
        return f"Money({self.amount!r}, {self.currency!r})"

    def __str__(self):
        return f"{self.amount:,.2f} {self.currency}".replace(",", " ")

    def __format__(self, spec):
        if spec == "short":
            return f"{self.amount:.0f}{self.currency[0]}"
        return str(self)

m = Money(1234567.5)
print(repr(m), str(m), f"{m}", f"{m:short}", sep="\n")

class Money:
    def __init__(self, amount):
        self.amount = amount

    def __add__(self, other):                 # m + other
        if isinstance(other, Money):
            return Money(self.amount + other.amount)
        if isinstance(other, (int, float)):
            return Money(self.amount + other)
        return NotImplemented                 # «не умею» — Python попробует other.__radd__

    def __radd__(self, other):                # other + m (если у other нет подходящего __add__)
        return self.__add__(other)

    def __mul__(self, k):
        return Money(self.amount * k)

    __rmul__ = __mul__

    def __neg__(self):
        return Money(-self.amount)

    def __repr__(self):
        return f"Money({self.amount})"

a, b = Money(100), Money(50)
print(a + b, a + 10, 10 + a, a * 3, 2 * a, -a)
print(sum([a, b, Money(1)]))                  # sum начинает с 0 → нужен __radd__

class Playlist:
    def __init__(self, songs):
        self._songs = list(songs)

    def __len__(self):
        return len(self._songs)

    def __getitem__(self, index):            # p[i], p[a:b], и даже for и in!
        result = self._songs[index]
        return Playlist(result) if isinstance(index, slice) else result

    def __setitem__(self, index, value):
        self._songs[index] = value

    def __delitem__(self, index):
        del self._songs[index]

    def __contains__(self, song):            # song in p — быстрее, чем перебор через __getitem__
        return song in self._songs

    def __iter__(self):
        return iter(self._songs)

    def __repr__(self):
        return f"Playlist({self._songs})"

p = Playlist(["Intro", "Song A", "Song B", "Outro"])
print(len(p), p[0], p[1:3], "Song B" in p)
p[0] = "New Intro"
del p[-1]
for song in p:
    print("♪", song)
print(list(reversed(p)), sorted(p))

class RateLimiter:
    def __init__(self, limit):
        self.limit = limit
        self.used = 0

    def __call__(self, request):
        if self.used >= self.limit:
            return f"429 Too Many Requests: {request}"
        self.used += 1
        return f"200 OK: {request}"

allow = RateLimiter(2)
for r in ["/a", "/b", "/c"]:
    print(allow(r))
print(callable(allow), callable(42))

import time

class Timer:
    def __enter__(self):
        self.start = time.perf_counter()
        return self                         # то, что попадёт в as

    def __exit__(self, exc_type, exc, tb):
        self.elapsed = time.perf_counter() - self.start
        print(f"прошло {self.elapsed * 1000:.1f} мс")
        return False                        # не подавлять исключения

with Timer() as t:
    sum(range(300_000))

class Config:
    def __init__(self, data):
        self._data = data

    def __getattr__(self, name):              # только если атрибут не найден обычно
        try:
            return self._data[name]
        except KeyError:
            raise AttributeError(f"нет настройки {name!r}") from None

    def __setattr__(self, name, value):       # при ЛЮБОМ присваивании
        if not name.startswith("_") and not isinstance(value, (int, str, bool)):
            raise TypeError("настройки — только int, str, bool")
        super().__setattr__(name, value)      # обойти себя, чтобы не уйти в рекурсию

cfg = Config({"debug": True, "port": 8000})
print(cfg.debug, cfg.port)
cfg.timeout = 30
print(cfg.timeout)
try:
    cfg.missing
except AttributeError as e:
    print(e)

class Singleton:
    _instance = None

    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            print("создаю объект")
            cls._instance = super().__new__(cls)
        return cls._instance

    def __init__(self, value):
        print("инициализирую", value)
        self.value = value

a = Singleton(1)
b = Singleton(2)              # __new__ вернул тот же объект, но __init__ вызвался снова!
print(a is b, a.value)

class UpperStr(str):          # наследование от неизменяемого типа — только через __new__
    def __new__(cls, value):
        return super().__new__(cls, value.upper())

print(UpperStr("привет"), type(UpperStr("x")))