python standard library numbers

python 标准库数字的抽象基类 numbers

昨天深夜 红薯 一篇博文 悼 @宏哥 ,让我久久不能平静。

时间定格在了2020年1月16号。

还依稀记得几年前和宏哥聊天,听说他去创业了。

还记得那时意气风发,舌战群儒,没想到如今阴阳两隔。

创业这条路,真的不好走。

愿天堂没有代码。

大家都好好活着吧。

源代码

源代码: Lib/numbers.py

numbers 模块 (PEP 3141) 定义了数字 抽象基类 的层次结构,其中逐级定义了更多操作。 此模块中所定义的类型都不可被实例化。

核心类

class numbers.Number

数字的层次结构的基础。如果你只想确认参数 x 是不是数字而不关心其类型,则使用isinstance(x, Number)。

数字的层次

  • class numbers.Complex

    内置在类型 complex 里的子类描述了复数和它的运算操作。这些操作有:转化至 complexboolrealimag+-*/abs()conjugate()==!=。 所有的异常,-!= ,都是抽象的。real抽象的。得到该数字的实数部分。imag抽象的。得到该数字的虚数部分。abstractmethod conjugate()抽象的。返回共轭复数。例如 (1+3j).conjugate() == (1-3j)

  • class numbers.Real

    相对于 ComplexReal 加入了只有实数才能进行的操作。简单的说,它们是:转化至 floatmath.trunc()round()math.floor()math.ceil()divmod()//%<<=>、 和 >=。实数同样默认支持 complex()realimagconjugate()

  • class numbers.Rational

    子类型 Real 并加入 numeratordenominator 两种属性,这两种属性应该属于最低的级别。加入后,这默认支持 float()numerator摘要。denominator摘要。

  • class numbers.Integral

    子类型 Rational 加上转化至 int。 默认支持 float()numeratordenominator。 在 ** 中加入抽象方法和比特字符串的操作: <<>>&^|~

类型接口注解

实现者需要注意使相等的数字相等并拥有同样的值。当这两个数使用不同的扩展模块时,这其中的差异是很微妙的。例如,用 fractions.Fraction 实现 hash() 如下:

1
2
3
4
5
6
7
8
9
10
11
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,如果不加入这些,就将缺少层次感。你可以用如下方法在 ComplexReal 中加入MyFoo:

1
2
3
class MyFoo(Complex):
pass
MyFoo.register(Real)

实现算数运算

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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

复数的子类上的混合操作有五种情况。前述的代码中除去MyIntegral和OtherTypeIKnow的文本将作为下面描述的样板。a是A的实例,并且使复数的子类(a:A<:Complex),b是B的实例,也是复数的子类。我们以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 <: ComplexB <: Real 没有共享任何资源,那么适当的共享操作涉及内置的 complex ,并且分别获得 __radd__() ,因此 a+b == b+a

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
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, numbers.Real):
return fallback_operator(float(a), float(b))
elif isinstance(a, numbers.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)

# ...
坚持原创技术分享,您的支持将鼓励我继续创作!