"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" 的值必須是 "Integral" 的實例且
   "denominator" 要是正數。

   numerator

      為抽象的。

   denominator

      為抽象的。

class numbers.Integral

   "Rational" 的子型別，並增加了 "int" 的轉換操作。為 "float()"、
   "numerator" 和 "denominator" 提供了預設值。為 "pow()" 方法增加了求
   餘 (modulus) 和位元字串運算 (bit-string operations) 的抽象方法：
   "<<"、">>"、"&"、"^"、"|"、"~"。


給型別實作者的註記
==================

實作者需注意，相等的數值除了大小相等外，還必須擁有同樣的雜湊值。當使用
兩個不同的實數擴充時，這可能是很微妙的。例如，"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))


加入更多數值 ABC
----------------

當然，還有更多用於數值的 ABC，如果不加入它們就不會有健全的階層。你可以
在 "Complex" 和 "Real" 中加入 "MyFoo"，像是：

   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" 的程式碼稱作「模板 (boilerplate)
」。"a" 是 "Complex" 之子型別 "A" 的實例 ("a : A <: Complex")，同時 "b
: B <: Complex"。我將要計算 "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"。

由於大部分對任意給定類型的操作都十分相似的，定義一個為任意給定運算子生
成向前 (forward) 與向後 (reverse) 實例的輔助函式可能會非常有用。例如，
"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)

   # ...
