numbers
— Classes base abstratas numéricas¶
Código-fonte: Lib/numbers.py
The numbers
module (PEP 3141) defines a hierarchy of numeric
abstract base classes which progressively define
more operations. None of the types defined in this module are intended to be instantiated.
- class numbers.Number¶
A raiz da hierarquia numérica. Se você quiser apenas verificar se um argumento x é um número, sem se importar com o tipo, use
isinstance(x, Number)
.
A torre numérica¶
- class numbers.Complex¶
As subclasses deste tipo descrevem números complexos e incluem as operações que funcionam no tipo embutido
complex
. Elas são: conversões paracomplex
ebool
,real
,imag
,+
,-
,*
,/
,**
,abs()
,conjugate()
,==
e!=
. Todos exceto-
e!=
são abstratos.- real¶
Abstrata. Obtém o componente real deste número.
- imag¶
Abstrata. Obtém o componente imaginário deste número.
- abstractmethod conjugate()¶
Abstrata. Retorna o conjugado complexo. Por exemplo,
(1+3j).conjugate() == (1-3j)
.
- class numbers.Real¶
To
Complex
,Real
adds the operations that work on real numbers.Em suma, são: uma conversão para
float
,math.trunc()
,round()
,math.floor()
,math.ceil()
,divmod()
,//
,%
,<
,<=
,>
e>=
.Real também fornece padrão para
complex()
,real
,imag
econjugate()
.
- class numbers.Rational¶
Estende
Real
e adiciona as propriedadesnumerator
edenominator
. Ele fornece um padrão parafloat()
.Os valores
numerator
edenominator
devem ser instâncias deIntegral
e devem estar nos termos mais baixos comdenominator
positivo.- numerator¶
Abstrata.
- denominator¶
Abstrata.
Nota para implementadores de tipos¶
Os implementadores devem ter o cuidado de tornar iguais números iguais e fazer hash deles com os mesmos valores. Isso pode ser sutil se houver duas extensões diferentes dos números reais. Por exemplo, fractions.Fraction
implementa hash()
desta forma:
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))
Adicionando mais ABCs numéricas¶
Existem, é claro, mais ABCs possíveis para números, e isso seria uma hierarquia pobre se excluísse a possibilidade de adicioná-los. Você pode adicionar MyFoo
entre Complex
e Real
com:
class MyFoo(Complex): ...
MyFoo.register(Real)
Implementando as operações aritméticas¶
We want to implement the arithmetic operations so that mixed-mode
operations either call an implementation whose author knew about the
types of both arguments, or convert both to the nearest built in type
and do the operation there. For subtypes of Integral
, this
means that __add__()
and __radd__()
should be
defined as:
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
Existem 5 casos diferentes para uma operação de tipo misto em subclasses de Complex
. Vou me referir a todo o código acima que não se refere a MyIntegral
e OtherTypeIKnowAbout
com um “modelo”. a
será uma instância de A
, que é um subtipo de Complex
(a : A <: Complex
) e b : B <: Complex
. Vou considerar a + b
:
If
A
defines an__add__()
which acceptsb
, all is well.If
A
falls back to the boilerplate code, and it were to return a value from__add__()
, we’d miss the possibility thatB
defines a more intelligent__radd__()
, so the boilerplate should returnNotImplemented
from__add__()
. (OrA
may not implement__add__()
at all.)Then
B
’s__radd__()
gets a chance. If it acceptsa
, all is well.Se ele recorrer ao padrão, não há mais métodos possíveis para tentar, então é aqui que a implementação padrão deve residir.
Se
B <: A
, Python tentaB.__radd__
antes deA.__add__
. Isso está ok, porque foi implementado com conhecimento deA
, então ele pode lidar com essas instâncias antes de delegar paraComplex
.
If A <: Complex
and B <: Real
without sharing any other knowledge,
then the appropriate shared operation is the one involving the built
in complex
, and both __radd__()
s land there, so a+b
== b+a
.
Como a maioria das operações em qualquer tipo será muito semelhante, pode ser útil definir uma função auxiliar que gera as instâncias de avanço e reversão de qualquer operador. Por exemplo, fractions.Fraction
usa:
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)
# ...