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

Исходный код: Lib/numbers.py

Модуль numbers (PEP 3141) определяет иерархию числовых abstract base classes, которые постепенно определяют больше операций. Ни один из типов, определенных в этом модуле, не предназначен для создания экземпляров.

class numbers.Number

Корень числовой иерархии. Если вы просто хотите проверить, является ли аргумент x числом, не заботясь о том, какого типа, используйте isinstance(x, Number).

Числовая башня

class numbers.Complex

Подклассы этого типа описывают комплексные числа и включают в себя операции, которые работают со встроенным типом complex. Это: преобразования в complex и bool, real, imag, +, -, *, /, **, abs(), conjugate(), ==, и !=. Все, кроме - и !=, являются абстрактными.

real

Абстрактный. Извлекает действительную составляющую этого числа.

imag

Абстрактный. Извлекает мнимую составляющую этого числа.

abstractmethod conjugate()

Абстрактный. Возвращает комплексное сопряжение. Например, (1+3j).conjugate() == (1-3j).

class numbers.Real

К Complex, Real добавляет операции, которые работают с вещественными числами.

Вкратце, это: преобразование в float, math.trunc(), round(), math.floor(), math.ceil(), divmod(), //, %, <, <=, >, и >=.

Real также предоставляет значения по умолчанию для complex(), real, imag, и conjugate().

class numbers.Rational

Подтипы Real и добавляет свойства numerator и denominator. Он также предоставляет значение по умолчанию для float().

Значения numerator и denominator должны быть экземплярами Integral и должны быть наименьшими при положительном значении denominator.

numerator

Абстрактный.

denominator

Абстрактный.

class numbers.Integral

Подтипы Rational и добавляет преобразование в int. Предоставляет значения по умолчанию для float(), numerator, и denominator. Добавляет абстрактные методы для pow() с использованием операций с модулем и битовой строкой: <<, >>, &, ^, |, ~.

Примечания для разработчиков типов

Разработчики должны быть осторожны, чтобы сделать равные числа равными и преобразовать их в одинаковые значения. Это может быть сложно, если есть два разных расширения действительных чисел. Например, fractions.Fraction реализует hash() следующим образом:

def __hash__(self):
    if self.denominator == 1:
        # Get integers right.
        return hash(self.numerator)
    # Expensive check, but definitely correct.
    if self == float(self):
        return hash(float(self))
    else:
        # Use tuple's hash to avoid a high collision rate on
        # simple fractions.
        return hash((self.numerator, self.denominator))

Добавление дополнительных цифровых азбук

Конечно, существует больше возможных азбук для чисел, и это была бы плохая иерархия, если бы она исключала возможность их добавления. Вы можете добавить 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

Существует 5 различных вариантов выполнения операции смешанного типа в подклассах Complex. Я буду ссылаться на весь приведенный выше код, который не относится к 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. Тогда B у __radd__() появляется шанс. Если он принимает 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)

# ...
Числовые и математические модули
math — Математические функции
Вернуться на верх