Sympy類Zero，One和NegativeOne，它們爲什麼存在？

Question

今天，我發現這個

>>> type(1) 
<class 'sympy.core.numbers.One'> 
>>> type(0) 
<class 'sympy.core.numbers.Zero'> 
>>> type(-1) 
<class 'sympy.core.numbers.NegativeOne'> 
>>> type(2) 
<class 'sympy.core.numbers.Integer'> 

我看了documentation from sympy那些類型，但它並沒有說爲什麼他們存在什麼。是否有理由爲-1，0和1有3個特殊的單身人士課程？

編輯：我看到這個在SymPy online shell

Answer 1

在SymPy每個數字是由the class Number實例表示。 Float s，Integer s和Rational s是Number的子類。 Zero是Integer的 的子類。

你可以通過調用其類的mro（方法解析順序）的方法檢查對象的完整類血統：

In [34]: from sympy import S 
In [38]: type(S.Zero).mro() 
Out[38]: 
[sympy.core.numbers.Zero, 
sympy.core.numbers.IntegerConstant, 
sympy.core.numbers.Integer,   <-- Zero is a kind of Integer 
sympy.core.numbers.Rational, 
sympy.core.numbers.Number, 
sympy.core.expr.AtomicExpr, 
sympy.core.basic.Atom, 
sympy.core.expr.Expr, 
sympy.core.basic.Basic, 
sympy.core.evalf.EvalfMixin, 
object] 

這些子類「教」 SymPy如何操作和象徵性地簡化表達式。作爲 例如，在Rational類的實例是negated this way：

def __neg__(self): 
    return Rational(-self.p, self.q) 

也就是說，如果x是Rational一個實例，然後-x導致x.__neg__()被調用。

@staticmethod 
def __neg__(): 
    return S.Zero # the negation of Zero is still Zero 

Zero，One和MinusOne：同時，Integer類的實例，是negated by

def __neg__(self): 
    return Integer(-self.p) 

而如果對象是，特別的Zero一個實例，則its negation是 由下式定義還實施_eval_power方法，其中 「教」這些對象如何評估x提高到一個權力（其中x是 Zero,One或MinusOne）。例如，Zero raised to a positive expression等於本身：

def _eval_power(self, expt): 
    if expt.is_positive: 
     return self 
    ... 

One raised to anything等於本身：

def _eval_power(self, expt): 
    return self 

如果你仔細閱讀the source code爲sympy.core.numbers模塊，你會發現 負荷的定義它們是效應教學SymPy如何算術符號 。這與數學課中教孩子的東西並沒有太大差別，只不過它是用計算機來表達的。

您可能想知道爲什麼每個整數都沒有特殊的類。 Integers除了Zero,One和MinusOne被視爲 通用Integer類的實例。他們的加法和乘法規則等都在那裏列出。不像在加載模塊時被instantated Zero，One和MinusOne，其它整數緩存only as needed：

def __new__(cls, i): 
    ... 
    try: 
     return _intcache[ival] # <-- return the cached Integer if seen before 
    except KeyError:   
     obj = Expr.__new__(cls) # <-- create a new Integer if ival not in _intcache 
     obj.p = ival 

     _intcache[ival] = obj 
     return obj 

Answer 2

首先，請注意type(1)給你type(Integer(1))因爲SymPy現場包裝在Integer()自動整型常量（這是爲了避免其中1/2評估爲0.5而不是Rational(1, 2)）。但是請注意，在常規Python會話type(1)中是int。

SymPy中有幾個對象實現爲單例，意味着只有一個實例存在。你可以看到這一切在S對象

In [13]: dir(S) 
Out[13]: 
['Catalan', 
'ComplexInfinity', 
'Complexes', 
'EulerGamma', 
'Exp1', 
'GoldenRatio', 
'Half', 
'IdentityFunction', 
'ImaginaryUnit', 
'Infinity', 
'NaN', 
'Naturals0', 
'NegativeInfinity', 
'NegativeOne', 
'One', 
'Pi', 
'Reals', 
'Zero', 
'__call__', 
'__class__', 
'__delattr__', 
'__doc__', 
'__format__', 
'__getattr__', 
'__getattribute__', 
'__hash__', 
'__init__', 
'__module__', 
'__new__', 
'__reduce__', 
'__reduce_ex__', 
'__repr__', 
'__setattr__', 
'__sizeof__', 
'__slots__', 
'__str__', 
'__subclasshook__', 
'_classes_to_install', 
'false', 
'register', 
'true'] 

（忽略與_開始的那些;這些都是Python的內部方法）

這樣做的原因是，這些對象使用了很多。 0,1和-1是很常見的對象。每當你寫1/x時，它在內部表示爲Pow(x, -1)。 x - y表示爲Add(x, Mul(-1, y))。對於0，它經常出現在各種符號計算中。 1也很常見。通過擁有一個實例，SymPy支持兩種優化。首先，它節省了內存。其次，你可以使用is進行比較，比如x is S.One。因爲只有一個實例可以存在Integer(1)總是與S.One相同。

（也，我要指出，一些S對象實際上並沒有那麼普遍，像Catalan和EulerGamma。我猜他們增加了更多的方便性大於任何東西）