【Python】特殊メソッド一覧｜クラス設計が楽になる実用リファレンス

class MyNumber(int):
    # インスタンス生成前に値を加工したい場合の例
    def __new__(cls, value):
        # ここでは負の値を絶対値に変換してからintを生成する
        obj = super().__new__(cls, abs(value))
        return obj

    def __init__(self, value):
        # __new__で実際に格納された値はすでにabs(value)
        # ここではログ出力や追加属性の設定だけを行う
        self.original_value = value


n = MyNumber(-10)
print(n)                # __str__はintのものが使われる
print(n.original_value)

class Tracked:
    def __init__(self, name):
        self.name = name
        print(f"[INIT] {self.name}")

    def __del__(self):
        # ここで重要な処理をしてはいけない(呼ばれない場合がある)
        print(f"[DEL] {self.name}")


def create():
    obj = Tracked("temp")


create()
print("関数終了")

class User:
    def __init__(self, user_id, name, is_admin=False):
        self.user_id = user_id
        self.name = name
        self.is_admin = is_admin

    def __repr__(self):
        # 開発者が状態を一目で確認できるように詳細に書く
        return (f"User(user_id={self.user_id!r}, "
                f"name={self.name!r}, is_admin={self.is_admin!r})")

    def __str__(self):
        # ユーザ向けにはコンパクトな表現
        role = "admin" if self.is_admin else "user"
        return f"{self.name} ({role})"


u = User(1, "Alice", True)
print(u)          # __str__
print(repr(u))    # __repr__

from datetime import datetime

class LogRecord:
    def __init__(self, level, message, created=None):
        self.level = level
        self.message = message
        self.created = created or datetime.now()

    def __format__(self, format_spec):
        # format_specに応じて出力を切り替える例
        if format_spec == "short":
            return f"[{self.level}] {self.message}"
        elif format_spec == "time":
            ts = self.created.strftime("%H:%M:%S")
            return f"{ts} | {self.level} | {self.message}"
        else:
            # デフォルトの詳細形式
            ts = self.created.isoformat(timespec="seconds")
            return f"{ts} [{self.level}] {self.message}"


rec = LogRecord("INFO", "system started")
print(f"{rec:short}")
print(f"{rec:time}")
print(f"{rec}")

class Packet:
    def __init__(self, msg_type, payload: bytes):
        self.msg_type = msg_type
        self.payload = payload

    def __bytes__(self):
        # 単純なプロトコル: [type(1byte)][len(2byte)][payload]
        length = len(self.payload)
        header = bytes([self.msg_type]) + length.to_bytes(2, "big")
        return header + self.payload


p = Packet(1, b"hello")
raw = bytes(p)
print(raw)

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

    def __add__(self, other):
        # 型チェックを行い、不正な型にはNotImplementedを返すのが慣習
        if not isinstance(other, Vector2D):
            return NotImplemented
        return Vector2D(self.x + other.x, self.y + other.y)

    def __sub__(self, other):
        if not isinstance(other, Vector2D):
            return NotImplemented
        return Vector2D(self.x - other.x, self.y - other.y)

    def __neg__(self):
        return Vector2D(-self.x, -self.y)

    def __abs__(self):
        return (self.x ** 2 + self.y ** 2) ** 0.5

    def __repr__(self):
        return f"Vector2D({self.x}, {self.y})"


v1 = Vector2D(1, 2)
v2 = Vector2D(3, 4)
print(v1 + v2)
print(v1 - v2)
print(-v1)
print(abs(v2))

class NumberBox:
    def __init__(self, value):
        self.value = value

    def __add__(self, other):
        if isinstance(other, NumberBox):
            return NumberBox(self.value + other.value)
        if isinstance(other, (int, float)):
            return NumberBox(self.value + other)
        return NotImplemented

    def __radd__(self, other):
        # 右辺加算: int + NumberBoxなど
        return self.__add__(other)

    def __iadd__(self, other):
        # インプレース: 自分を直接書き換える
        if isinstance(other, NumberBox):
            self.value += other.value
        elif isinstance(other, (int, float)):
            self.value += other
        else:
            return NotImplemented
        return self

    def __repr__(self):
        return f"NumberBox({self.value})"


nb = NumberBox(10)
print(5 + nb)     # __radd__
nb += 3           # __iadd__
print(nb)

class Version:
    def __init__(self, major, minor):
        self.major = major
        self.minor = minor

    def _key(self):
        return (self.major, self.minor)

    def __eq__(self, other):
        if not isinstance(other, Version):
            return NotImplemented
        return self._key() == other._key()

    def __lt__(self, other):
        if not isinstance(other, Version):
            return NotImplemented
        return self._key() < other._key()

    def __repr__(self):
        return f"{self.major}.{self.minor}"


versions = [Version(1, 2), Version(1, 10), Version(1, 3)]
print(sorted(versions))
print(Version(1, 2) < Version(1, 3))

class Config:
    def __init__(self, options):
        self.options = options

    def __bool__(self):
        # 有効なオプションが1つ以上あればTrueとみなす
        return bool(self.options)


cfg = Config({})
if not cfg:
    print("設定が空です")

class TagSet:
    def __init__(self, *tags):
        self._tags = set(tags)

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

    def __contains__(self, item):
        # 大文字小文字を区別しないタグ集合とする例
        return item.lower() in {t.lower() for t in self._tags}


tags = TagSet("Python", "Django")
print(len(tags))
print("python" in tags)

class Settings:
    def __init__(self):
        self._data = {}

    def __getitem__(self, key):
        # 存在しないときにわかりやすいエラーを出す
        try:
            return self._data[key]
        except KeyError:
            raise KeyError(f"設定キーがありません: {key!r}")

    def __setitem__(self, key, value):
        self._data[key] = value

    def __delitem__(self, key):
        del self._data[key]


s = Settings()
s["timeout"] = 30
print(s["timeout"])
del s["timeout"]

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

    def __getitem__(self, index):
        if isinstance(index, slice):
            # スライス用の処理
            return RangeView(self._data[index])
        else:
            return self._data[index]

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

    def __repr__(self):
        return f"RangeView({self._data!r})"


rv = RangeView(range(10))
print(rv[2])
print(rv[2:6])

class Countdown:
    def __init__(self, start):
        self.current = start

    def __iter__(self):
        # 自分自身がイテレータでもあるケース
        return self

    def __next__(self):
        if self.current <= 0:
            raise StopIteration
        value = self.current
        self.current -= 1
        return value


for i in Countdown(3):
    print(i)

class History:
    def __init__(self):
        self._events = []

    def add(self, event):
        self._events.append(event)

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

    def __reversed__(self):
        return reversed(self._events)


h = History()
h.add("start")
h.add("process")
h.add("end")

print(list(h))
print(list(reversed(h)))

class DefaultDict(dict):
    def __init__(self, default_factory, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.default_factory = default_factory

    def __missing__(self, key):
        value = self.default_factory()
        # 自動的に登録しておく
        self[key] = value
        return value


d = DefaultDict(list)
d["errors"].append("first error")
print(d)

class LazyAttrs:
    def __init__(self):
        self._cache = {}

    def __getattr__(self, name):
        # 存在しない属性にアクセスされたときだけ呼ばれる
        if name == "expensive":
            print("計算中...")
            value = sum(range(10_000))
            self._cache[name] = value
            return value
        raise AttributeError(name)

    def __getattribute__(self, name):
        # すべてのアクセスを横取り
        if name == "_cache":
            # 無限再帰を避けるためsuperを使う
            return super().__getattribute__(name)
        if name in super().__getattribute__("_cache"):
            return self._cache[name]
        return super().__getattribute__(name)


obj = LazyAttrs()
print(obj.expensive)  # 初回は計算
print(obj.expensive)  # 2回目以降はキャッシュから

class ReadOnlyOnce:
    def __init__(self):
        super().__setattr__("_locked", False)

    def __setattr__(self, name, value):
        if name == "value" and getattr(self, "_locked", False):
            raise AttributeError("valueは一度しか設定できません")
        super().__setattr__(name, value)
        if name == "value":
            super().__setattr__("_locked", True)


obj = ReadOnlyOnce()
obj.value = 10
print(obj.value)
# 次は例外
# obj.value = 20

class PublicAPI:
    def __init__(self):
        self._internal = 1
        self.visible = 2

    def __dir__(self):
        # 公開したい属性だけを返す
        return ["visible"]


p = PublicAPI()
print(dir(p))

class FileLogger:
    def __init__(self, path):
        self.path = path
        self._f = None

    def __enter__(self):
        self._f = open(self.path, "a", encoding="utf-8")
        self._f.write("=== start ===\n")
        return self

    def __exit__(self, exc_type, exc, tb):
        if exc:
            self._f.write(f"ERROR: {exc}\n")
        self._f.write("=== end ===\n")
        self._f.close()
        # 例外を抑制しない場合はFalseを返す
        return False

    def log(self, msg):
        self._f.write(msg + "\n")


with FileLogger("log.txt") as logger:
    logger.log("hello")

class Typed:
    def __init__(self, name, expected_type):
        self.name = name
        self.expected_type = expected_type

    def __get__(self, instance, owner):
        if instance is None:
            return self  # クラスからアクセスされた場合
        return instance.__dict__.get(self.name)

    def __set__(self, instance, value):
        if not isinstance(value, self.expected_type):
            raise TypeError(f"{self.name} must be {self.expected_type}")
        instance.__dict__[self.name] = value


class Person:
    age = Typed("age", int)

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


p = Person(20)
print(p.age)
# p.age = "old"  # TypeError

class Multiplier:
    def __init__(self, factor):
        self.factor = factor

    def __call__(self, x):
        return x * self.factor


double = Multiplier(2)
print(double(10))

class RegistryMeta(type):
    registry = {}

    def __new__(mcls, name, bases, namespace):
        cls = super().__new__(mcls, name, bases, namespace)
        if name != "Base":
            RegistryMeta.registry[name] = cls
        return cls


class Base(metaclass=RegistryMeta):
    pass


class ServiceA(Base):
    pass


class ServiceB(Base):
    pass


print(RegistryMeta.registry)

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

    def _pair(self):
        return (self.x, self.y)

    def __add__(self, other):
        if not isinstance(other, Vec2):
            return NotImplemented
        return Vec2(self.x + other.x, self.y + other.y)

    def __mul__(self, scalar):
        if not isinstance(scalar, (int, float)):
            return NotImplemented
        return Vec2(self.x * scalar, self.y * scalar)

    def __rmul__(self, scalar):
        return self.__mul__(scalar)

    def __abs__(self):
        x, y = self._pair()
        return (x * x + y * y) ** 0.5

    def __repr__(self):
        return f"Vec2({self.x}, {self.y})"


v1 = Vec2(1, 2)
v2 = Vec2(3, 4)
print(v1 + v2)
print(2 * v1)
print(abs(v2))

class AppConfig:
    def __init__(self, host, port, debug=False):
        self.host = host
        self.port = port
        self.debug = debug

    def __repr__(self):
        return (f"AppConfig(host={self.host!r}, "
                f"port={self.port!r}, debug={self.debug!r})")


cfg = AppConfig("localhost", 8000, True)
print(cfg)

class TaskList:
    def __init__(self):
        self._tasks = []

    def add(self, task):
        self._tasks.append(task)

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

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

    def __repr__(self):
        return f"TaskList({len(self)} tasks)"


tasks = TaskList()
tasks.add("backup")
tasks.add("cleanup")

print(tasks)
for t in tasks:
    print("-", t)
print("count:", len(tasks))

import time

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

    def __enter__(self):
        self.start = time.time()
        print(f"[ENTER] {self.name}")
        return self

    def __exit__(self, exc_type, exc, tb):
        elapsed = time.time() - self.start
        if exc:
            print(f"[ERROR] {self.name}: {exc}")
        print(f"[EXIT] {self.name} ({elapsed:.3f}s)")
        return False  # 例外はそのまま伝播


def work():
    with ScopeTracer("work"):
        time.sleep(0.1)


work()

import urllib.parse

class ApiClient:
    def __init__(self, base_url):
        self.base_url = base_url.rstrip("/")

    def __call__(self, path, **params):
        url = f"{self.base_url}/{path.lstrip('/')}"
        if params:
            query = urllib.parse.urlencode(params)
            url = f"{url}?{query}"
        # 実際にはrequests.getなどを呼ぶ
        print(f"GET {url}")
        return {"url": url, "status": "ok"}


client = ApiClient("https://api.example.com")
res = client("users", id=1)
print(res)