Pythonnumbers数字的抽象基类

Z时代
2024-01-10
分类：综合

python lib

源代码： 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() 如下:

python3 notranslate">

def__hash__(self):
ifself.denominator==1:
# Get integers right.
returnhash(self.numerator)
# Expensive check, but definitely correct.
ifself==float(self):
returnhash(float(self))
else:
# Use tuple's hash to avoid a high collision rate on
# simple fractions.
returnhash((self.numerator,self.denominator))

加入更多数字的ABC¶

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

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

实现算术运算¶

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

classMyIntegral(Integral):
def__add__(self,other):
ifisinstance(other,MyIntegral):
returndo_my_adding_stuff(self,other)
elifisinstance(other,OtherTypeIKnowAbout):
returndo_my_other_adding_stuff(self,other)
else:
returnNotImplemented
def__radd__(self,other):
ifisinstance(other,MyIntegral):
returndo_my_adding_stuff(other,self)
elifisinstance(other,OtherTypeIKnowAbout):
returndo_my_other_adding_stuff(other,self)
elifisinstance(other,Integral):
returnint(other)+int(self)
elifisinstance(other,Real):
returnfloat(other)+float(self)
elifisinstance(other,Complex):
returncomplex(other)+complex(self)
else:
returnNotImplemented

Complex 有 5 种不同的混合类型的操作。我将上面提到的所有代码作为“模板”称作 MyIntegral 和 OtherTypeIKnowAbout。 a 是 Complex 的子类型 A 的实例 (a:A<:Complex)，同时 b:B<:Complex。我将要计算 a+b:

如果 A 被定义成一个承认 b 的 __add__()，一切都没有问题。
如果 A 转回成“模板”失败，它将返回一个属于 __add__() 的值，我们需要避免 B 定义了一个更加智能的 __radd__()，因此模板需要返回一个属于 __add__() 的 NotImplemented 。（或者 A 可能完全不实现 __add__() 。）
接着看 B 的 __radd__() 。如果它承认 a ，一切都没有问题。
如果没有成功回退到模板，就没有更多的方法可以去尝试，因此这里将使用默认的实现。
如果 B<:A ， Python 在 A.__add__ 之前尝试 B.__radd__ 。这是可行的，是通过对 A 的认识实现的，因此这可以在交给 Complex 处理之前处理这些实例。

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

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

def_operator_fallbacks(monomorphic_operator,fallback_operator):
defforward(a,b):
ifisinstance(b,(int,Fraction)):
returnmonomorphic_operator(a,b)
elifisinstance(b,float):
returnfallback_operator(float(a),b)
elifisinstance(b,complex):
returnfallback_operator(complex(a),b)
else:
returnNotImplemented
forward.__name__='__'+fallback_operator.__name__+'__'
forward.__doc__=monomorphic_operator.__doc__
defreverse(b,a):
ifisinstance(a,Rational):
# Includes ints.
returnmonomorphic_operator(a,b)
elifisinstance(a,numbers.Real):
returnfallback_operator(float(a),float(b))
elifisinstance(a,numbers.Complex):
returnfallback_operator(complex(a),complex(b))
else:
returnNotImplemented
reverse.__name__='__r'+fallback_operator.__name__+'__'
reverse.__doc__=monomorphic_operator.__doc__
returnforward,reverse
def_add(a,b):
"""a + b"""
returnFraction(a.numerator*b.denominator+
b.numerator*a.denominator,
a.denominator*b.denominator)
__add__,__radd__=_operator_fallbacks(_add,operator.add)
# ...