モダンPython上級 #1 マジックメソッドの深さとプロトコル

プログラミング言語 Python dunder マジックメソッド
読了 8分

モダンPython中級 シリーズを終えたなら、いよいよ 言語の深さ に入ります。上級シリーズ7編は、ライブラリ・フレームワークのコードでよく出会う道具たち — マジックメソッド、ディスクリプタ、メタクラス、非同期の深さ、GIL/並行性、typing 上級、パフォーマンス — を扱います。

  • #1 マジックメソッドの深さとプロトコル ← 今回
  • #2 ディスクリプタと __set_name__
  • #3 メタクラス — いつ本当に必要か
  • #4 非同期の深さ (イベントループ、gather/wait、async generator)
  • #5 GIL と並行性 — threading vs multiprocessing vs asyncio
  • #6 typing 上級 — Variance、ParamSpec、Self
  • #7 パフォーマンス — cProfile、line_profiler、メモリプロファイリング

マジックメソッド (またはダンダーメソッド、dunder = double underscore) は、Pythonオブジェクトが言語機能と出会う 公式フック です。len(x) が x.__len__() を呼び、a + b が a.__add__(b) を呼ぶ、という具合です。このフックを正確に知れば Python らしいオブジェクトを作れて、ライブラリコードを読むときに何が呼ばれているかが見えてきます。

オブジェクトのライフサイクル #

__init__ と __new__ — 違い #

2 つの居場所 
class Foo:
    def __new__(cls, *args, **kwargs):
        # インスタンスを作る (メモリ確保)
        instance = super().__new__(cls)
        return instance

    def __init__(self, value):
        # 作られたインスタンスを初期化する
        self.value = value
  • __new__ — クラスメソッドのように動作し、インスタンスを作って返す。cls を最初の引数に受け取る
  • __init__ — インスタンスメソッド、すでに作られたインスタンスを初期化する。self を受け取る

ほとんどのコードは __init__ だけを書きます。__new__ が必要な場面は限られます。

  • 不変型 (tuple、str) を継承して作る
  • シングルトンのようなインスタンスキャッシュ
  • __init__ 呼び出し自体を防ぎたいとき
__new__ が他のオブジェクトを返すと 
class Singleton:
    _instance = None
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

a = Singleton()
b = Singleton()
print(a is b)   # True

__new__ が返したオブジェクトが そのクラスのインスタンスでなければ __init__ は呼ばれません。微妙な場面なので注意。

__del__ — ほとんど使わない #

オブジェクトがガベージコレクションされるときに呼ばれます。ただし。

  • いつ呼ばれるか保証されない — GC のタイミングに依存
  • 循環参照があると呼ばれないこともある
  • 例外が出ても無視される

リソースの後片付けは __del__ ではなく コンテキストマネージャ (中級 #3) が正解です。

表現 — __repr__ vs __str__ #

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

    def __repr__(self) -> str:
        return f"Point(x={self.x}, y={self.y})"

    def __str__(self) -> str:
        return f"({self.x}, {self.y})"

p = Point(1, 2)
print(repr(p))   # Point(x=1, y=2)   ← デバッグ用、曖昧でなく
print(str(p))    # (1, 2)            ← 人が読みやすく
print(f"{p}")    # (1, 2)            ← f-string は str
print(p)         # (1, 2)            ← print も str

ルール。

  • __repr__ — 曖昧でない表現。可能なら eval(repr(x)) == x になるように
  • __str__ — ユーザーに見せる表現。定義しないと __repr__ が使われる

@dataclass (中級 #1) が自動で作るのは __repr__ です。

__format__ — f-string のフォーマット指定 #

フォーマット指定を受け取る 
class Money:
    def __init__(self, amount, currency):
        self.amount, self.currency = amount, currency

    def __format__(self, spec):
        if spec == "k":
            return f"{self.amount / 1000:.1f}k {self.currency}"
        return f"{self.amount} {self.currency}"

m = Money(12345, "KRW")
print(f"{m}")     # 12345 KRW
print(f"{m:k}")   # 12.3k KRW

f-string f"{x:fmt}" の fmt 部分が __format__(spec) の引数として渡されます。ドメインオブジェクトにユーザー定義のフォーマットを与えるときに使います。

比較 #

__eq__ と __hash__ — 相棒 #

この 2 つは 必ずセットで動きます。

基本ルール 
class User:
    def __init__(self, id, name):
        self.id, self.name = id, name

    def __eq__(self, other):
        if not isinstance(other, User):
            return NotImplemented
        return self.id == other.id

    def __hash__(self):
        return hash(self.id)

ルール。

  • a == b なら hash(a) == hash(b) が 必ず 成立しなければならない
  • __eq__ だけ定義すると __hash__ が自動で None になり、set/dict のキーに使えない
  • 可変オブジェクトは通常 hashable ではない

@dataclass(frozen=True) が両メソッドを一緒に自動生成します。

__lt__ などの比較 — functools.total_ordering #

<、<=、>、>=、==、!= の 6 つを全部書くのが面倒なとき。

total_ordering 
from functools import total_ordering

@total_ordering
class Score:
    def __init__(self, value):
        self.value = value

    def __eq__(self, other):
        return self.value == other.value

    def __lt__(self, other):
        return self.value < other.value
# 残りの 4 つは自動で埋まる

@dataclass(order=True) の方が短いですが、単純なフィールド比較 にしか向いていません。複雑な比較ロジックは total_ordering で。

コンテナのように — シーケンス/マッピング #

__len__、__getitem__、__contains__、__iter__ #

シーケンスを作る 
class Page:
    def __init__(self, items):
        self.items = items

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

    def __getitem__(self, index):
        return self.items[index]

    def __contains__(self, value):
        return value in self.items

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

p = Page(["a", "b", "c"])
len(p)            # 3
p[0]              # 'a'
"b" in p          # True
list(p)           # ['a', 'b', 'c']
for x in p: ...   # OK

この 4 つを埋めれば ほぼ list のように 動作します。実は __getitem__ と __len__ だけでも for in が動作します (インデックス 0 から IndexError まで試行)。

スライスも自動 #

__getitem__ の引数に slice オブジェクト が渡されることがあります。

スライスの処理 
class MyList:
    def __init__(self, items):
        self.items = items

    def __getitem__(self, key):
        if isinstance(key, slice):
            return MyList(self.items[key])
        return self.items[key]

m = MyList([1, 2, 3, 4, 5])
m[1:3].items   # [2, 3]

m[1:3] の呼び出し時、key は slice(1, 3, None) です。

__setitem__、__delitem__ #

書き込み/削除 
class Cache:
    def __init__(self):
        self._data = {}

    def __getitem__(self, key):
        return self._data[key]

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

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

c = Cache()
c["x"] = 1
print(c["x"])   # 1
del c["x"]

dict のように動作するオブジェクトを作るときに使います。

呼び出し可能 — __call__ #

オブジェクトを関数のように呼び出せるようにするフック。

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

    def __call__(self, value):
        self.count += 1
        return value * 2

c = Counter()
print(c(5))        # 10
print(c(7))        # 14
print(c.count)     # 2

中級 #5 の クラス形式のデコレータ はこのフックの上に作られています。PyTorch の nn.Module も __call__ を持っていてモデルを関数のように呼び出せます。

属性アクセス — __getattr__、__setattr__、__getattribute__ #

__getattr__ — 存在しない属性を要求されたとき #

存在しない属性の lazy 処理 
class Lazy:
    def __getattr__(self, name):
        if name.startswith("get_"):
            field = name[4:]
            return lambda: f"value of {field}"
        raise AttributeError(name)

l = Lazy()
l.get_name()   # 'value of name'
l.get_age()    # 'value of age'

存在しない属性 のときだけ呼ばれます。存在する属性は通常の経路を通ります。ORM の自動メソッド、プロキシオブジェクトなどでよく登場します。

__getattribute__ — すべての属性要求に対して #

すべての属性をフック — 危険 
class All:
    def __getattribute__(self, name):
        print(f"アクセス: {name}")
        return super().__getattribute__(name)

すべての属性アクセスに割り込みます。 誤って使うと無限再帰が起こりやすいため (自分の中で self.x を使うとまた __getattribute__ が呼ばれる)、通常は __getattr__ だけを使います。

__setattr__、__delattr__ #

書き込みフック 
class Frozen:
    def __init__(self, x):
        self.x = x
        object.__setattr__(self, "_locked", True)

    def __setattr__(self, name, value):
        if getattr(self, "_locked", False):
            raise AttributeError(f"{name} は変更不可")
        super().__setattr__(name, value)

f = Frozen(5)
f.x = 10   # AttributeError

@dataclass(frozen=True) の動作はまさにこのパターンです。

算術演算 — __add__ など #

演算子オーバーロード 
class Vec:
    def __init__(self, x, y):
        self.x, self.y = x, y

    def __add__(self, other):
        return Vec(self.x + other.x, self.y + other.y)

    def __mul__(self, k):
        return Vec(self.x * k, self.y * k)

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

v = Vec(1, 2) + Vec(3, 4)        # __add__
w = Vec(1, 2) * 3                 # __mul__
u = 3 * Vec(1, 2)                 # __rmul__ (左側のオペランドが知らない型)

対称な演算が必要なら __rmul__ のような reflected バージョンも定義します。左側のオペランドが自分を掛ける方法を知らないとき (例: int * Vec) に呼ばれます。

__bool__ — 真理値 #

bool 
class Bag:
    def __init__(self):
        self.items = []

    def __bool__(self):
        return bool(self.items)

b = Bag()
if b:
    print("何かある")

定義しないと __len__ を見て、それもなければ常に True。コンテナ形式には __len__ だけで十分な場面が多いです。

継承時のフック — __init_subclass__ #

サブクラスが 作られるとき に呼ばれるフック。メタクラスを使わなくても似たことができます。

__init_subclass__ 
class Plugin:
    registry = []

    def __init_subclass__(cls, **kwargs):
        super().__init_subclass__(**kwargs)
        Plugin.registry.append(cls)

class JsonPlugin(Plugin):
    pass

class CsvPlugin(Plugin):
    pass

print(Plugin.registry)
# [<class 'JsonPlugin'>, <class 'CsvPlugin'>]

プラグインの自動登録 などの場面でよく使われます。メタクラス (#3) の方が強力ですが、この程度の仕事なら __init_subclass__ の方が軽くて安全です。

よく出会うメソッド — 一覧表 #

カテゴリメソッド呼ばれるタイミング
生成/破棄__new__、__init__、__del__インスタンス作成時 / 後片付け時
表現__repr__、__str__、__format__、__bool__repr()、str()、f""、if
比較__eq__、__hash__、__lt__ など==、hash()、<
コンテナ__len__、__getitem__、__setitem__、__contains__、__iter__len()、x[k]、in、for
呼び出し__call__x(...)
属性__getattr__、__setattr__、__delattr__属性アクセス
算術__add__、__sub__、__mul__、__truediv__、…+、-、*、/
非同期__await__、__aiter__、__anext__、__aenter__、__aexit__await、async for/with
継承フック__init_subclass__、__class_getitem__サブクラス / Cls[T]

この表を全部覚える必要はありません。どんなフックがある という事実だけ把握しておけば、ライブラリコードで見かけたときに検索できます。

まとめ #

今回押さえたこと。

  • __new__ はインスタンス生成、__init__ は初期化。ほとんどは __init__ だけ
  • __del__ よりコンテキストマネージャ
  • __repr__ (開発者) vs __str__ (ユーザー)、定義しないと __repr__ がフォールバック
  • __format__ で f-string のフォーマット指定を受け取る
  • __eq__ と __hash__ は相棒、frozen=True dataclass が自動生成
  • コンテナは __len__ + __getitem__ でほぼ list レベルの動作
  • __call__ でオブジェクトを関数のように
  • __getattr__ は存在しない属性、__getattribute__ はすべての属性 (危険)
  • __init_subclass__ でメタクラスなしの軽い自動登録
  • マジックメソッドはオブジェクトと言語機能をつなぐ公式フック

次回 (#2 ディスクリプタと __set_name__) では、マジックメソッドの中でも特殊な分類 — 属性をオブジェクト化するディスクリプタ を扱います。@property は実はディスクリプタの一形態です。

X