numbers — Абстрактные базовые классы чисел

Добавление других числовых ABC

Конечно, для чисел можно определить и другие ABC, и эта иерархия была бы неудачной, если бы не позволяла добавлять их. Вы можете добавить MyFoo между Complex и Real следующим образом:

class MyFoo(Complex): ...
MyFoo.register(Real)

Реализация арифметических операций

Мы хотим реализовать арифметические операции так, чтобы операции со смешанными типами либо вызывали реализацию, автор которой учитывал типы обоих аргументов, либо преобразовывали оба аргумента к ближайшему встроенному типу и выполняли операцию для него. Для подклассов Integral это означает, что методы __add__() и __radd__() следует определить так:

class MyIntegral(Integral):

    def __add__(self, other):
        if isinstance(other, MyIntegral):
            return do_my_adding_stuff(self, other)
        elif isinstance(other, OtherTypeIKnowAbout):
            return do_my_other_adding_stuff(self, other)
        else:
            return NotImplemented

    def __radd__(self, other):
        if isinstance(other, MyIntegral):
            return do_my_adding_stuff(other, self)
        elif isinstance(other, OtherTypeIKnowAbout):
            return do_my_other_adding_stuff(other, self)
        elif isinstance(other, Integral):
            return int(other) + int(self)
        elif isinstance(other, Real):
            return float(other) + float(self)
        elif isinstance(other, Complex):
            return complex(other) + complex(self)
        else:
            return NotImplemented

Для операции со смешанными типами над подклассами Complex возможны 5 различных случаев. Весь приведённый выше код, не связанный с MyIntegral и OtherTypeIKnowAbout, я буду называть «шаблонным кодом». a будет экземпляром A, являющегося подклассом Complex (a : A <: Complex), и b : B <: Complex. Рассмотрим a + b:

1. Если A определяет метод __add__(), принимающий b, всё в порядке.
2. Если A использует шаблонный код и возвращает значение из __add__(), мы упустим возможность того, что B определяет более интеллектуальный метод __radd__(), поэтому шаблонный код должен возвращать NotImplemented из __add__(). (Или A может вообще не реализовывать __add__().)
3. Затем вызывается метод __radd__() объекта B. Если он принимает a, всё в порядке.
4. Если он использует шаблонный код, других методов для вызова не остаётся, поэтому именно здесь должна находиться реализация по умолчанию.
5. Если B <: A, Python вызывает B.__radd__ раньше A.__add__. Это допустимо, поскольку реализация учитывает A и поэтому может обработать такие экземпляры, прежде чем передать управление Complex.

Если A <: Complex и B <: Real, не имея общих знаний о чём-либо ещё, то подходящей общей операцией будет операция со встроенным типом complex, и оба метода __radd__() приведут к ней, так что a+b == b+a.

Поскольку большинство операций для любого заданного типа будут очень похожи, может быть полезно определить вспомогательную функцию, создающую прямой и обратный варианты любого заданного оператора. Например, fractions.Fraction использует:

def _operator_fallbacks(monomorphic_operator, fallback_operator):
    def forward(a, b):
        if isinstance(b, (int, Fraction)):
            return monomorphic_operator(a, b)
        elif isinstance(b, float):
            return fallback_operator(float(a), b)
        elif isinstance(b, complex):
            return fallback_operator(complex(a), b)
        else:
            return NotImplemented
    forward.__name__ = '__' + fallback_operator.__name__ + '__'
    forward.__doc__ = monomorphic_operator.__doc__

    def reverse(b, a):
        if isinstance(a, Rational):
            # Includes ints.
            return monomorphic_operator(a, b)
        elif isinstance(a, Real):
            return fallback_operator(float(a), float(b))
        elif isinstance(a, Complex):
            return fallback_operator(complex(a), complex(b))
        else:
            return NotImplemented
    reverse.__name__ = '__r' + fallback_operator.__name__ + '__'
    reverse.__doc__ = monomorphic_operator.__doc__

    return forward, reverse

def _add(a, b):
    """a + b"""
    return Fraction(a.numerator * b.denominator +
                    b.numerator * a.denominator,
                    a.denominator * b.denominator)

__add__, __radd__ = _operator_fallbacks(_add, operator.add)

# ...