numbers —- 數字的抽象基類

源代碼： Lib/numbers.py

讓客戶滿意是我們工作的目標，不斷超越客戶的期望值來自于我們對這個行業(yè)的熱愛。我們立志把好的技術通過有效、簡單的方式提供給客戶，將通過不懈努力成為客戶在信息化領域值得信任、有價值的長期合作伙伴，公司提供的服務項目有：域名注冊、虛擬空間、營銷軟件、網站建設、江安網站維護、網站推廣。

---

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

Subtypes Real and adds numerator and denominator properties. It also provides a default for float().

The numerator and denominator values should be instances of Integral and should be in lowest terms with denominator positive.

• 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))
 
 
 

加入更多數字的ABC

當然，這里有更多支持數字的ABC，如果不加入這些，就將缺少層次感。你可以用如下方法在 Complex 和 Real 中加入 MyFoo:

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

實現算術運算

我們希望實現計算，因此，混合模式操作要么調用一個作者知道參數類型的實現，要么轉變成為最接近的內置類型并對這個執(zhí)行操作。對于子類 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 是 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。

由于對任何一直類型的大部分操作是十分相似的，可以定義一個幫助函數，即一個生成后續(xù)或相反的實例的生成器。例如，使用 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)
  
  
  
  
  
  
  
  
# ...
 
 
 

當前名稱：創(chuàng)新互聯Python教程：numbers —- 數字的抽象基類
轉載來源：http://www.5511xx.com/article/djsdpdj.html