［Pythonチートシート］特殊メソッド編：Pythonチートシート

class Foo:
    def __new__(cls):
        print('__new__')
        self = super().__new__(cls)  # インスタンス生成を行う典型的なコード
        self.attr = 'set in __new__'  # ここでしかできない初期化処理を書いてもよい
        return self  # 生成したインスタンスを返す

    def __init__(self, name='foo'):
        print('__init__')
        self.name = name  # インスタンスの初期化処理

    def __del__(self):
        #super().__del__()  # 基底クラスに__del__メソッドがあれば必ず呼び出す
        print('__del__')  # インスタンスが破壊されるときに行う処理

foo = Foo()  # '__new__'と'__init__'が表示される
print('foo.attr:', foo.attr)  # 'foo.attr: set in __new__'
bar = foo
print('bar.name:', bar.name)  # 'bar.name: foo'
print('del foo')  # この時点ではまだ生成したインスタンスには別名がある
del foo
print('del bar')
del bar  # '__del__'：この時点でインスタンスを束縛する名前がなくなる

class NumberedTuple(tuple):
    def __new__(cls, iterable):
        tmp = [(idx, value) for idx, value in enumerate(iterable)]
        self = super().__new__(cls, tmp)
        return self

nt = NumberedTuple(['foo','bar', 'baz'])
print(nt)  # ((0, 'foo'), (1, 'bar'), (2, 'baz'))

class MyDigit:
    @staticmethod
    def _isfloat(val):
        if val.startswith('-'):
            val = val[1:]
        if val.count('.') <= 1 and val.replace('.', '').isdigit():
            return True
        return False

    def __init__(self, val="0.0"):
        if MyDigit._isfloat(val):
            self.val = val
        else:
            self.val = "0.0"

    def __bool__(self):
        return bool(float(self.val))

    def __int__(self):
        return int(float(self.val))

    def __float__(self):
        return float(self.val)

    def __repr__(self):  # eval関数でオブジェクトを復元可能な表現
        return f"MyDigit('{self.val}')"

    #def __str__(self):  # コメントアウトを外すとself.valが返されるようになる
    #    return self.val

mydigit = MyDigit('foo')
print("MyDigit('foo'):", mydigit)  # MyDigit('foo'): MyDigit('0.0')
print(f"bool(MyDigit('foo')):", bool(mydigit))  # bool(MyDigit('foo')): False

mydigit = MyDigit('1.5')
print(f'bool({mydigit}):', bool(mydigit))  # bool(MyDigit('1.5')): True
print(f'int({mydigit}):', int(mydigit))  # int(MyDigit('1.5')): 1
print(f'repr({mydigit}):', repr(mydigit))  # repr(MyDigit('1.5')): MyDigit('1.5')
print(f'str({mydigit}):', str(mydigit))  # str(MyDigit('1.5')): MyDigit('1.5')
print(f"eval('repr(mydigit)'):", eval('repr(mydigit)'))  # eval('repr(mydigit)'): MyDigit('1.5')

class AAA:
    def __init__(self, val=0):
        self.val = val

    def __eq__(self, other):
        if isinstance(other, self.__class__):
            return self.val == other.val
        else:
            kls = other.__class__.__name__
            raise NotImplementedError(
                f'comparison between AAA and {kls} is not supported')

    def __ne__(self, other):
        return not self.__eq__(other)

    def __lt__(self, other):
        if isinstance(other, self.__class__):
            return self.val < other.val
        else:
            kls = other.__class__.__name__
            raise NotImplementedError(
                f'comparison between AAA and {kls} is not supported')

    def __le__(self, other):
        return self.__lt__(other) or self.__eq__(other)

    def __gt__(self, other):
        return not self.__le__(other)  # other.__lt__(self)

    def __ge__(self, other):
        return not self.__lt__(other)  # other.__le__(self)

aaa = AAA(10)
bbb = AAA(20)

print(aaa == bbb)  # False
print(aaa != bbb)  # True
print(aaa < bbb)  # True
print(aaa <= bbb)  # True
print(aaa > bbb)  # False
print(aaa >= bbb)  # False

aaa > 100  # NotImplmentedError例外

from functools import total_ordering

@total_ordering
class AAA:
    def __init__(self, val=0):
        self.val = val

    def __eq__(self, other):
        if isinstance(other, self.__class__):
            return self.val == other.val
        else:
            kls = other.__class__.__name__
            raise NotImplementedError(
              f'comparison between AAA and {kls} is not supported')

    def __lt__(self, other):
        if isinstance(other, self.__class__):
            return self.val < other.val
        else:
            kls = other.__class__.__name__
            raise NotImplementedError(
              f'comparison between AAA and {kls} is not supported')

class Hello:
    def __call__(self, x):
        print(f'Hello {x}')

hello = Hello()  # クラスは呼び出し可能オブジェクト
hello('world')  # Helloクラスのインスタンスは呼び出し可能オブジェクト

class MyDigit:
    @staticmethod
    def _isint(val):
        if val.startswith('-'):
            val = val[1:]
        if val.count('.') == 0 and val.isdigit():
            return True
        return False

    def __init__(self, val="0.0"):
        if MyDigit._isint(val):
            self.val = val
        else:
            self.val = "0"

    def __add__(self, other):
        if isinstance(other, self.__class__):
            tmp = str(int(self.val) + int(other.val))
            return MyDigit(tmp)
        else:
            raise NotImplementedError()

    def __sub__(self, other):
        if isinstance(other, self.__class__):
            tmp = str(int(self.val) - int(other.val))
            return MyDigit(tmp)
        else:
            raise NotImplementedError()

    def __mul__(self, other):
        if isinstance(other, self.__class__):
            tmp = str(int(self.val) * int(other.val))
            return MyDigit(tmp)
        else:
            raise NotImplementedError()

    def __floordiv__(self, other):
        if isinstance(other, self.__class__):
            tmp = int(self.val) // int(other.val)
            return MyDigit(str(tmp))
        else:
            raise NotImplementedError()

    def __mod__(self, other):
        if isinstance(other, self.__class__):
            tmp = int(self.val) % int(other.val)
            return MyDigit(str(tmp))
        else:
            raise NotImplementedError()

    def __truediv__(self, other):
        return self.__floordiv__(other)

    def __divmod__(self, other):
        q = self.__floordiv__(other)
        r = self.__mod__(other)
        return (q, r)

    def __neg__(self):
        if self.val.startswith('-'):
            tmp = self.val[1:]
        else:
            tmp = "-" + self.val
        return MyDigit(tmp)

    def __str__(self):
        return self.val

d1 = MyDigit('17')
d2 = MyDigit('4')

print(d1 + d2)  # 21
print(d1 - d2)  # 13
print(d2 - d1)  # -13
print(d1 * d2)  # 68
print(d1 / d2)  # 4
print(d1 % d2)  # 1
(q, r) = (divmod(d1, d2))
print(q, r)  # 4 1
print(-d1)  # -17