• numbers —- 数字的抽象基类
    • 数字的层次
    • 类型接口注释。
      • 加入更多数字的ABC
      • 实现算数运算

    numbers —- 数字的抽象基类

    源代码：Lib/numbers.py

    numbers 模块 (PEP 3141) 定义了数字 抽象基类 的层次结构，其中逐级定义了更多操作。 此模块中所定义的类型都不可被实例化。

    • 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()、 //、 %、 <、 <=、 >、 和 >=。

    实数同样默认支持 complex()、 real、 imag 和 conjugate()。

    • class numbers.Rational

    • 子类型 Real 并加入 numerator 和 denominator 两种属性，这两种属性应该属于最低的级别。加入后，这默认支持 float()。

      • numerator

      • 摘要。

      • denominator

      • 摘要。

    • class numbers.Integral

    • 子类型 Rational 加上转化至 int。 默认支持 float()、 numerator 和 denominator。 在 ** 中加入抽象方法和比特字符串的操作： <<、 >>、 &、 ^、 |、 ~。

    类型接口注释。

    实现者需要注意使相等的数字相等并拥有同样的值。当这两个数使用不同的扩展模块时，这其中的差异是很微妙的。例如，用 fractions.Fraction 实现 hash() 如下:

    1. def __hash__(self):
    2.     if self.denominator == 1:
    3.         # Get integers right.
    4.         return hash(self.numerator)
    5.     # Expensive check, but definitely correct.
    6.     if self == float(self):
    7.         return hash(float(self))
    8.     else:
    9.         # Use tuple's hash to avoid a high collision rate on
    10.         # simple fractions.
    11.         return hash((self.numerator, self.denominator))

    加入更多数字的ABC

    当然，这里有更多支持数字的ABC，如果不加入这些，就将缺少层次感。你可以用如下方法在 Complex 和 Real 中加入MyFoo：

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

    实现算数运算

    我们希望实现计算，因此，混合模式操作要么调用一个作者知道参数类型的实现，要么转变成为最接近的内置类型并对这个执行操作。对于子类 Integral，这意味着 add() 和 radd() 必须用如下方式定义：

    1. class MyIntegral(Integral):
    2.  
    3.     def __add__(self, other):
    4.         if isinstance(other, MyIntegral):
    5.             return do_my_adding_stuff(self, other)
    6.         elif isinstance(other, OtherTypeIKnowAbout):
    7.             return do_my_other_adding_stuff(self, other)
    8.         else:
    9.             return NotImplemented
    10.  
    11.     def __radd__(self, other):
    12.         if isinstance(other, MyIntegral):
    13.             return do_my_adding_stuff(other, self)
    14.         elif isinstance(other, OtherTypeIKnowAbout):
    15.             return do_my_other_adding_stuff(other, self)
    16.         elif isinstance(other, Integral):
    17.             return int(other) + int(self)
    18.         elif isinstance(other, Real):
    19.             return float(other) + float(self)
    20.         elif isinstance(other, Complex):
    21.             return complex(other) + complex(self)
    22.         else:
    23.             return NotImplemented

    There are 5 different cases for a mixed-type operation on subclassesof Complex. I'll refer to all of the above code that doesn'trefer to MyIntegral and OtherTypeIKnowAbout as"boilerplate". a will be an instance of A, which is a subtypeof Complex (a : A <: Complex), and b : B <:Complex. I'll consider a + b:

    1. 如果 A 被定义成一个承认b 的 add()，一切都没有问题。

    2. 如果 A 转回成“模板”失败，它将返回一个属于 add() 的值，我们需要避免 B 定义了一个更加智能的 radd()，因此模板需要返回一个属于 add() 的 NotImplemented 。（或者 A 可能完全不实现 add() 。）

    3. 接着看 B 的 radd() 。如果它承认 a ，一切都没有问题。

    4. 如果没有成功回退到模板，就没有更多的方法可以去尝试，因此这里将使用默认的实现。

    5. 如果 B <: A ， Python 在 A.add 之前尝试 B.radd 。 这是可行的，是通过对 A 的认识实现的，因此这可以在交给 Complex 处理之前处理这些实例。

    如果 A <: Complex 和 B <: Real 没有共享任何资源，那么适当的共享操作涉及内置的 complex ，并且分别获得 radd() ，因此 a+b == b+a。

    由于对任何一直类型的大部分操作是十分相似的，可以定义一个帮助函数，即一个生成后续或相反的实例的生成器。例如，使用 fractions.Fraction 如下：

    1. def _operator_fallbacks(monomorphic_operator, fallback_operator):
    2.     def forward(a, b):
    3.         if isinstance(b, (int, Fraction)):
    4.             return monomorphic_operator(a, b)
    5.         elif isinstance(b, float):
    6.             return fallback_operator(float(a), b)
    7.         elif isinstance(b, complex):
    8.             return fallback_operator(complex(a), b)
    9.         else:
    10.             return NotImplemented
    11.     forward.__name__ = '__' + fallback_operator.__name__ + '__'
    12.     forward.__doc__ = monomorphic_operator.__doc__
    13.  
    14.     def reverse(b, a):
    15.         if isinstance(a, Rational):
    16.             # Includes ints.
    17.             return monomorphic_operator(a, b)
    18.         elif isinstance(a, numbers.Real):
    19.             return fallback_operator(float(a), float(b))
    20.         elif isinstance(a, numbers.Complex):
    21.             return fallback_operator(complex(a), complex(b))
    22.         else:
    23.             return NotImplemented
    24.     reverse.__name__ = '__r' + fallback_operator.__name__ + '__'
    25.     reverse.__doc__ = monomorphic_operator.__doc__
    26.  
    27.     return forward, reverse
    28.  
    29. def _add(a, b):
    30.     """a + b"""
    31.     return Fraction(a.numerator * b.denominator +
    32.                     b.numerator * a.denominator,
    33.                     a.denominator * b.denominator)
    34.  
    35. __add__, __radd__ = _operator_fallbacks(_add, operator.add)
    36.  
    37. # ...