花下貓語：在 Python 中，不同型別的數字可以直接做算術運算，並不需要作顯式的型別轉換。但是，它的“隱式型別轉換”可能跟其它語言不同，因為 Python 中的數字是一種特殊的物件，派生自同一個抽象基類。在上一篇文章 中，我們討論到了 Python 數字的運算，然後我想探究“Python 的數字物件到底是什麼”的話題，所以就翻譯了這篇 PEP，希望對你也有所幫助。
PEP原文： https://www.python.org/dev/peps/pep-3141/
PEP標題： PEP 3141 -- A Type Hierarchy for Numbers
PEP作者： Jeffrey Yasskin
建立日期： 2007-04-23
譯者 ：豌豆花下貓@Python貓公眾號
PEP翻譯計劃： https://github.com/chinesehuazhou/peps-cn
概要
本提案定義了一種抽象基類（ABC）（PEP 3119）的層次結構，用來表示類似數字（number-like）的類。它提出了一個 Number :> Complex :> Real :> Rational :> Integral 的層次結構，其中 A :> B 表示“A 是 B 的超類”。該層次結構受到了 Scheme 的數字塔（numeric tower）啟發。（譯註：數字--複數--實數--有理數--整數）
基本原理
以數字作為引數的函式應該能夠判定這些數字的屬性，並且根據數字的型別，確定是否以及何時進行過載，即基於引數的型別，函式應該是可過載的。
例如，切片要求其引數為Integrals，而math模組中的函式要求其引數為Real。
規範
本 PEP 規定了一組抽象基類（Abstract Base Class），並提出了一個實現某些方法的通用策略。它使用了來自於PEP 3119的術語，但是該層次結構旨在對特定類集的任何系統方法都有意義。
標準庫中的型別檢查應該使用這些類，而不是具體的內建型別。
數值類
我們從 Number 類開始，它是人們想象的數字型別的模糊概念。此類僅用於過載；它不提供任何操作。
class Number(metaclass=ABCMeta): pass
大多數複數（complex number）的實現都是可雜湊的，但是如果你需要依賴它，則必須明確地檢查：此層次結構支援可變的數。
class Complex(Number):
"""Complex defines the operations that work on the builtin complex type.
In short, those are: conversion to complex, bool(), .real, .imag,
+, -, *, /, **, abs(), .conjugate(), ==, and !=.
If it is given heterogenous arguments, and doesn't have special
knowledge about them, it should fall back to the builtin complex
type as described below.
"""
@abstractmethod
def __complex__(self):
"""Return a builtin complex instance."""
def __bool__(self):
"""True if self != 0."""
return self != 0
@abstractproperty
def real(self):
"""Retrieve the real component of this number.
This should subclass Real.
"""
raise NotImplementedError
@abstractproperty
def imag(self):
"""Retrieve the real component of this number.
This should subclass Real.
"""
raise NotImplementedError
@abstractmethod
def __add__(self, other):
raise NotImplementedError
@abstractmethod
def __radd__(self, other):
raise NotImplementedError
@abstractmethod
def __neg__(self):
raise NotImplementedError
def __pos__(self):
"""Coerces self to whatever class defines the method."""
raise NotImplementedError
def __sub__(self, other):
return self + -other
def __rsub__(self, other):
return -self + other
@abstractmethod
def __mul__(self, other):
raise NotImplementedError
@abstractmethod
def __rmul__(self, other):
raise NotImplementedError
@abstractmethod
def __div__(self, other):
"""a/b; should promote to float or complex when necessary."""
raise NotImplementedError
@abstractmethod
def __rdiv__(self, other):
raise NotImplementedError
@abstractmethod
def __pow__(self, exponent):
"""a**b; should promote to float or complex when necessary."""
raise NotImplementedError
@abstractmethod
def __rpow__(self, base):
raise NotImplementedError
@abstractmethod
def __abs__(self):
"""Returns the Real distance from 0."""
raise NotImplementedError
@abstractmethod
def conjugate(self):
"""(x+y*i).conjugate() returns (x-y*i)."""
raise NotImplementedError
@abstractmethod
def __eq__(self, other):
raise NotImplementedError
# __ne__ is inherited from object and negates whatever __eq__ does.
Real抽象基類表示在實數軸上的值，並且支援內建的float的操作。實數（Real number）是完全有序的，除了 NaN（本 PEP 基本上不考慮它）。
class Real(Complex):
"""To Complex, Real adds the operations that work on real numbers.
In short, those are: conversion to float, trunc(), math.floor(),
math.ceil(), round(), divmod(), //, %, <, <=, >, and >=.
Real also provides defaults for some of the derived operations.
"""
# XXX What to do about the __int__ implementation that's
# currently present on float? Get rid of it?
@abstractmethod
def __float__(self):
"""Any Real can be converted to a native float object."""
raise NotImplementedError
@abstractmethod
def __trunc__(self):
"""Truncates self to an Integral.
Returns an Integral i such that:
* i>=0 iff self>0;
* abs(i) <= abs(self);
* for any Integral j satisfying the first two conditions,
abs(i) >= abs(j) [i.e. i has "maximal" abs among those].
i.e. "truncate towards 0".
"""
raise NotImplementedError
@abstractmethod
def __floor__(self):
"""Finds the greatest Integral <= self."""
raise NotImplementedError
@abstractmethod
def __ceil__(self):
"""Finds the least Integral >= self."""
raise NotImplementedError
@abstractmethod
def __round__(self, ndigits:Integral=None):
"""Rounds self to ndigits decimal places, defaulting to 0.
If ndigits is omitted or None, returns an Integral,
otherwise returns a Real, preferably of the same type as
self. Types may choose which direction to round half. For
example, float rounds half toward even.
"""
raise NotImplementedError
def __divmod__(self, other):
"""The pair (self // other, self % other).
Sometimes this can be computed faster than the pair of
operations.
"""
return (self // other, self % other)
def __rdivmod__(self, other):
"""The pair (self // other, self % other).
Sometimes this can be computed faster than the pair of
operations.
"""
return (other // self, other % self)
@abstractmethod
def __floordiv__(self, other):
"""The floor() of self/other. Integral."""
raise NotImplementedError
@abstractmethod
def __rfloordiv__(self, other):
"""The floor() of other/self."""
raise NotImplementedError
@abstractmethod
def __mod__(self, other):
"""self % other
See
https://mail.python.org/pipermail/python-3000/2006-May/001735.html
and consider using "self/other - trunc(self/other)"
instead if you're worried about round-off errors.
"""
raise NotImplementedError
@abstractmethod
def __rmod__(self, other):
"""other % self"""
raise NotImplementedError
@abstractmethod
def __lt__(self, other):
"""< on Reals defines a total ordering, except perhaps for NaN."""
raise NotImplementedError
@abstractmethod
def __le__(self, other):
raise NotImplementedError
# __gt__ and __ge__ are automatically done by reversing the arguments.
# (But __le__ is not computed as the opposite of __gt__!)
# Concrete implementations of Complex abstract methods.
# Subclasses may override these, but don't have to.
def __complex__(self):
return complex(float(self))
@property
def real(self):
return +self
@property
def imag(self):
return 0
def conjugate(self):
"""Conjugate is a no-op for Reals."""
return +self
我們應該整理 Demo/classes/Rat.py，並把它提升為 Rational.py 加入標準庫。然後它將實現有理數（Rational）抽象基類。
class Rational(Real, Exact):
""".numerator and .denominator should be in lowest terms."""
@abstractproperty
def numerator(self):
raise NotImplementedError
@abstractproperty
def denominator(self):
raise NotImplementedError
# Concrete implementation of Real's conversion to float.
# (This invokes Integer.__div__().)
def __float__(self):
return self.numerator / self.denominator
最後是整數類：
class Integral(Rational):
"""Integral adds a conversion to int and the bit-string operations."""
@abstractmethod
def __int__(self):
raise NotImplementedError
def __index__(self):
"""__index__() exists because float has __int__()."""
return int(self)
def __lshift__(self, other):
return int(self) << int(other)
def __rlshift__(self, other):
return int(other) << int(self)
def __rshift__(self, other):
return int(self) >> int(other)
def __rrshift__(self, other):
return int(other) >> int(self)
def __and__(self, other):
return int(self) & int(other)
def __rand__(self, other):
return int(other) & int(self)
def __xor__(self, other):
return int(self) ^ int(other)
def __rxor__(self, other):
return int(other) ^ int(self)
def __or__(self, other):
return int(self) | int(other)
def __ror__(self, other):
return int(other) | int(self)
def __invert__(self):
return ~int(self)
# Concrete implementations of Rational and Real abstract methods.
def __float__(self):
"""float(self) == float(int(self))"""
return float(int(self))
@property
def numerator(self):
"""Integers are their own numerators."""
return +self
@property
def denominator(self):
"""Integers have a denominator of 1."""
return 1
運算及__magic__方法的變更
為了支援從 float 到 int（確切地說，從 Real 到 Integral）的精度收縮，我們提出了以下新的 __magic__ 方法，可以從相應的庫函式中呼叫。所有這些方法都返回 Intergral 而不是 Real。
- __trunc__(self)：在新的內建 trunc(x) 裡呼叫，它返回從 0 到 x 之間的最接近 x 的 Integral。
- __floor__(self)：在 math.floor(x) 裡呼叫，返回最大的 Integral <= x。
- __ceil__(self)：在 math.ceil(x) 裡呼叫，返回最小的 Integral > = x。
- __round__(self)：在 round(x) 裡呼叫，返回最接近 x 的 Integral ，根據選定的型別作四捨五入。浮點數將從 3.0 版本起改為向偶數端四捨五入。（譯註：round(2.5) 等於 2，round(3.5) 等於 4）。它還有一個帶兩引數的版本__round__(self, ndigits)，被 round(x, ndigits) 呼叫，但返回的是一個 Real。
在 2.6 版本中，math.floor、math.ceil 和 round 將繼續返回浮點數。
float 的 int() 轉換等效於 trunc()。一般而言，int() 的轉換首先會嘗試__int__()，如果找不到，再嘗試__trunc__()。
complex.__{divmod, mod, floordiv, int, float}__ 也消失了。提供一個好的錯誤訊息來幫助困惑的搬運工會很好，但更重要的是不出現在 help(complex) 中。
給型別實現者的說明
實現者應該注意使相等的數字相等，並將它們雜湊為相同的值。如果實數有兩個不同的擴充套件，這可能會變得微妙。例如，一個複數型別可以像這樣合理地實現 hash()：
def __hash__(self):
return hash(complex(self))
但應注意所有超出了內建複數範圍或精度的值。
新增更多數字抽象基類
當然，數字還可能有更多的抽象基類，如果排除了新增這些數字的可能性，這會是一個糟糕的等級體系。你可以使用以下方法在 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 的程式碼稱為“樣板”。
a 是 A 的例項，它是Complex(a : A <: Complex) 的子型別，還有 b : B <: Complex。對於 a + b，我這麼考慮：
- 如果 A 定義了接受 b 的__add__，那麼沒問題。
- 如果 A 走到了樣板程式碼分支（譯註：else 分支），還從__add__返回一個值的話，那麼我們就錯過了為 B 定義一個更智慧的__radd__的可能性，因此樣板應該從__add__返回 NotImplemented。（或者 A 可以不實現__add__）
- 然後 B 的__radd__的機會來了。如果它接受 a，那麼沒問題。
- 如果它走到樣板分支上，就沒有辦法了，因此需要有預設的實現。
- 如果 B <: A，則 Python 會在 A.__ add__之前嘗試 B.__ radd__。這也可以，因為它是基於 A 而實現的，因此可以在委派給 Complex 之前處理這些例項。
如果 A <: Complex 和 B <: Real 沒有其它關係，則合適的共享操作是內建複數的操作，它們的__radd__都在其中，因此 a + b == b + a。（譯註：這幾段沒看太明白，可能譯得不對）
被拒絕的方案
本 PEP 的初始版本定義了一個被 Haskell Numeric Prelude 所啟發的代數層次結構，其中包括 MonoidUnderPlus、AdditiveGroup、Ring 和 Field，並在得到數字之前，還有其它幾種可能的代數型別。
我們原本希望這對使用向量和矩陣的人有用，但 NumPy 社群確實對此並不感興趣，另外我們還遇到了一個問題，即便 x 是 X <: MonoidUnderPlus 的例項，而且 y 是 Y < : MonoidUnderPlus 的例項，x + y 可能還是行不通。
然後，我們為數字提供了更多的分支結構，包括高斯整數（Gaussian Integer）和 Z/nZ 之類的東西，它們可以是 Complex，但不一定支援“除”之類的操作。
社群認為這對 Python 來說太複雜了，因此我現在縮小了提案的範圍，使其更接近於 Scheme 數字塔。
十進位制型別
經與作者協商，已決定目前不將 Decimal 型別作為數字塔的一部分。
參考文獻
1、抽象基類簡介：http://www.python.org/dev/peps/pep-3119/
2、可能是 Python 3 的類樹？Bill Janssen 的 Wiki 頁面：http://wiki.python.org/moin/AbstractBaseClasses
3、NumericPrelude：數字型別類的實驗性備選層次結構：http://darcs.haskell.org/numericprelude/docs/html/index.html
4、Scheme 數字塔：https://groups.csail.mit.edu/mac/ftpdir/scheme-reports/r5rs-html/r5rs_8.html#SEC50
（譯註：在譯完之後，我才發現“PEP中文翻譯計劃”已收錄過一篇譯文，有些地方譯得不盡相同，讀者們可比對閱讀。）
致謝
感謝 Neal Norwitz 最初鼓勵我編寫此 PEP，感謝 Travis Oliphant 指出 numpy 社群並不真正關心代數概念，感謝 Alan Isaac 提醒我 Scheme 已經做到了，以及感謝 Guido van Rossum 和郵件組裡的其他人幫忙完善了這套概念。
版權
該文件已放入公共領域。