`decimal` — Aritmética de ponto fixo decimal e ponto flutuante¶

Código-fonte: Lib/decimal.py

O módulo decimal fornece suporte a aritmética rápida de ponto flutuante decimal corretamente arredondado. Oferece várias vantagens sobre o tipo de dados float:

Decimal “é baseado em um modelo de ponto flutuante que foi projetado com as pessoas em mente e necessariamente tem um princípio orientador primordial – os computadores devem fornecer uma aritmética que funcione da mesma maneira que a aritmética que as pessoas aprendem na escola”. – trecho da especificação aritmética decimal.
Os números decimais podem ser representados exatamente. Por outro lado, números como 1.1 e 2.2 não possuem representações exatas em ponto flutuante binário. Os usuários finais normalmente não esperam que 1.1 + 2.2 sejam exibidos como 3.3000000000000003, como acontece com o ponto flutuante binário.
A exatidão transita para a aritmética. No ponto flutuante decimal, 0.1 + 0.1 + 0.1 - 0.3 é exatamente igual a zero. No ponto flutuante binário, o resultado é 5.5511151231257827e-017. Embora próximas de zero, as diferenças impedem o teste de igualdade confiável e as diferenças podem se acumular. Por esse motivo, o decimal é preferido em aplicativos de contabilidade que possuem invariáveis estritos de igualdade.
O módulo decimal incorpora uma noção de casas significativas para que 1.30 + 1.20 seja 2.50. O zero à direita é mantido para indicar significância. Esta é a apresentação habitual para aplicações monetárias. Para multiplicação, a abordagem “livro escolar” usa todas as figuras nos multiplicandos. Por exemplo, 1.3 * 1.2 é igual a 1.56 enquanto 1.30 * 1.20 é igual a 1.5600.
Diferentemente do ponto flutuante binário baseado em hardware, o módulo decimal possui uma precisão alterável pelo usuário (padrão de 28 casas), que pode ser tão grande quanto necessário para um determinado problema:
```
>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
```
O ponto flutuante binário e decimal é implementado em termos de padrões publicados. Enquanto o tipo ponto flutuante embutido expõe apenas uma parte modesta de seus recursos, o módulo decimal expõe todas as partes necessárias do padrão. Quando necessário, o programador tem controle total sobre o arredondamento e o manuseio do sinal. Isso inclui uma opção para impor aritmética exata usando exceções para bloquear quaisquer operações inexatas.
O módulo decimal foi projetado para dar suporte, “sem prejuízo, a aritmética decimal não arredondada exata (às vezes chamada aritmética de ponto fixo) e aritmética arredondada de ponto flutuante”. – trecho da especificação aritmética decimal.

O design do módulo é centrado em torno de três conceitos: o número decimal, o contexto da aritmética e os sinais.

Um número decimal é imutável. Possui um sinal, dígitos de coeficiente e um expoente. Para preservar a significância, os dígitos do coeficiente não truncam zeros à direita. Os decimais também incluem valores especiais, tais como Infinity, -Infinity e NaN. O padrão também diferencia -0 de +0.

O contexto da aritmética é um ambiente que especifica precisão, regras de arredondamento, limites de expoentes, sinalizadores indicando os resultados das operações e ativadores de interceptação que determinam se os sinais são tratados como exceções. As opções de arredondamento incluem ROUND_CEILING, ROUND_DOWN, ROUND_FLOOR, ROUND_HALF_DOWN, ROUND_HALF_EVEN, ROUND_HALF_UP, ROUND_UP e ROUND_05UP.

Sinais são grupos de condições excepcionais que surgem durante o curso da computação. Dependendo das necessidades da aplicação, os sinais podem ser ignorados, considerados informativos ou tratados como exceções. Os sinais no módulo decimal são: Clamped, InvalidOperation, DivisionByZero, Inexact, Rounded, Subnormal, Overflow, Underflow e FloatOperation.

Para cada sinal, há um sinalizador e um ativador de interceptação. Quando um sinal é encontrado, seu sinalizador é definido como um e, se o ativador de interceptação estiver definido como um, uma exceção será gerada. Os sinalizadores são fixos; portanto, o usuário precisa redefini-los antes de monitorar um cálculo.

Ver também

A especificação geral aritmética decimal da IBM, The General Decimal Arithmetic Specification.

Tutorial de início rápido¶

O início usual do uso de decimais é importar o módulo, exibir o contexto atual com getcontext() e, se necessário, definir novos valores para precisão, arredondamento ou armadilhas ativados:

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

Instâncias decimais podem ser construídas a partir de números inteiros, strings, pontos flutuantes ou tuplas. A construção de um número inteiro ou de um ponto flutuante realiza uma conversão exata do valor desse número inteiro ou ponto flutuante. Os números decimais incluem valores especiais como NaN, que significa “Não é um número”, Infinity positivo e negativo e -0:

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

Se o sinal FloatOperation for capturado na armadilha, a mistura acidental de decimais e pontos flutuantes em construtores ou comparações de ordenação levanta uma exceção:

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
decimal.FloatOperation: [<class 'decimal.FloatOperation'>]
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
decimal.FloatOperation: [<class 'decimal.FloatOperation'>]
>>> Decimal('3.5') == 3.5
True

Novo na versão 3.3.

O significado de um novo decimal é determinado apenas pelo número de dígitos inseridos. A precisão e o arredondamento do contexto só entram em jogo durante operações aritméticas.

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

Se os limites internos da versão C forem excedidos, a construção de um decimal levanta InvalidOperation:

>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
decimal.InvalidOperation: [<class 'decimal.InvalidOperation'>]

Alterado na versão 3.3.

Os decimais interagem bem com grande parte do resto do Python. Aqui está um pequeno circo voador de ponto flutuante decimal:

>>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))
>>> max(data)
Decimal('9.25')
>>> min(data)
Decimal('0.03')
>>> sorted(data)
[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),
 Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]
>>> sum(data)
Decimal('19.29')
>>> a,b,c = data[:3]
>>> str(a)
'1.34'
>>> float(a)
1.34
>>> round(a, 1)
Decimal('1.3')
>>> int(a)
1
>>> a * 5
Decimal('6.70')
>>> a * b
Decimal('2.5058')
>>> c % a
Decimal('0.77')

E algumas funções matemáticas também estão disponíveis no Decimal:

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

O método quantize() arredonda um número para um expoente fixo. Esse método é útil para aplicações monetárias que geralmente arredondam os resultados para um número fixo de locais:

>>> Decimal('7.325').quantize(Decimal('.01'), rounding=ROUND_DOWN)
Decimal('7.32')
>>> Decimal('7.325').quantize(Decimal('1.'), rounding=ROUND_UP)
Decimal('8')

Como mostrado acima, a função getcontext() acessa o contexto atual e permite que as configurações sejam alteradas. Essa abordagem atende às necessidades da maioria das aplicações.

Para trabalhos mais avançados, pode ser útil criar contextos alternativos usando o construtor Context(). Para ativar uma alternativa, use a função setcontext().

De acordo com o padrão, o módulo decimal fornece dois contextos padrão prontos para uso, BasicContext e ExtendedContext. O primeiro é especialmente útil para depuração porque muitas das armadilhas estão ativadas:

>>> myothercontext = Context(prec=60, rounding=ROUND_HALF_DOWN)
>>> setcontext(myothercontext)
>>> Decimal(1) / Decimal(7)
Decimal('0.142857142857142857142857142857142857142857142857142857142857')

>>> ExtendedContext
Context(prec=9, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[])
>>> setcontext(ExtendedContext)
>>> Decimal(1) / Decimal(7)
Decimal('0.142857143')
>>> Decimal(42) / Decimal(0)
Decimal('Infinity')

>>> setcontext(BasicContext)
>>> Decimal(42) / Decimal(0)
Traceback (most recent call last):
  File "<pyshell#143>", line 1, in -toplevel-
    Decimal(42) / Decimal(0)
DivisionByZero: x / 0

Os contextos também possuem sinalizadores para monitorar condições excepcionais encontradas durante os cálculos. Os sinalizadores permanecem definidos até que sejam explicitamente limpos, portanto, é melhor limpar os sinalizadores antes de cada conjunto de cálculos monitorados usando o método clear_flags().

>>> setcontext(ExtendedContext)
>>> getcontext().clear_flags()
>>> Decimal(355) / Decimal(113)
Decimal('3.14159292')
>>> getcontext()
Context(prec=9, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[Inexact, Rounded], traps=[])

A entrada flags mostra que a aproximação racional de Pi foi arredondada (dígitos além da precisão do contexto foram descartados) e que o resultado é inexato (alguns dos dígitos descartados eram diferentes de zero).

As armadilhas individuais são definidas usando o dicionário no campo traps de um contexto:

>>> setcontext(ExtendedContext)
>>> Decimal(1) / Decimal(0)
Decimal('Infinity')
>>> getcontext().traps[DivisionByZero] = 1
>>> Decimal(1) / Decimal(0)
Traceback (most recent call last):
  File "<pyshell#112>", line 1, in -toplevel-
    Decimal(1) / Decimal(0)
DivisionByZero: x / 0

A maioria dos programas ajusta o contexto atual apenas uma vez, no início do programa. E, em muitas aplicações, os dados são convertidos para Decimal com uma única conversão dentro de um loop. Com o conjunto de contextos e decimais criados, a maior parte do programa manipula os dados de maneira diferente do que com outros tipos numéricos do Python.

Objetos de Decimal¶

class decimal.Decimal(value="0", context=None)¶

Constrói um novo objeto de Decimal com base em value.

value pode ser um inteiro, string, tupla, float ou outro objeto de Decimal. Se nenhum value for fornecido, retornará Decimal('0'). Se value for uma string, ele deverá estar em conformidade com a sintaxe da string numérica decimal após caracteres de espaço em branco à esquerda e à direita, bem como sublinhados em toda parte, serem removidos:

sign           ::=  '+' | '-'
digit          ::=  '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
indicator      ::=  'e' | 'E'
digits         ::=  digit [digit]...
decimal-part   ::=  digits '.' [digits] | ['.'] digits
exponent-part  ::=  indicator [sign] digits
infinity       ::=  'Infinity' | 'Inf'
nan            ::=  'NaN' [digits] | 'sNaN' [digits]
numeric-value  ::=  decimal-part [exponent-part] | infinity
numeric-string ::=  [sign] numeric-value | [sign] nan

Outros dígitos decimais Unicode também são permitidos onde digit aparece acima. Isso inclui dígitos decimais de vários outros alfabetos (por exemplo, dígitos em árabes-índicos e devanágaris), além dos dígitos de largura total '\uff10' a '\uff19'.

Se value for um tuple, ele deverá ter três componentes, um sinal (0 para positivo ou 1 para negativo), um tuple de dígitos e um expoente inteiro. Por exemplo, Decimal((0, (1, 4, 1, 4), -3)) returna Decimal('1.414').

Se value é um float, o valor do ponto flutuante binário é convertido sem perdas no seu equivalente decimal exato. Essa conversão geralmente requer 53 ou mais dígitos de precisão. Por exemplo, Decimal(float('1.1')) converte para Decimal('1.100000000000000088817841970012523233890533447265625').

A precisão context não afeta quantos dígitos estão armazenados. Isso é determinado exclusivamente pelo número de dígitos em value. Por exemplo, Decimal('3.00000') registra todos os cinco zeros, mesmo que a precisão do contexto seja apenas três.

O objetivo do argumento context é determinar o que fazer se value for uma string malformada. Se o contexto capturar InvalidOperation, uma exceção será levantada; caso contrário, o construtor retornará um novo decimal com o valor de NaN.

Uma vez construídos, objetos de Decimal são imutáveis.

Alterado na versão 3.2: O argumento para o construtor agora pode ser uma instância de float.

Alterado na versão 3.3: Os argumentos de float levantam uma exceção se a armadilha FloatOperation estiver definida. Por padrão, a armadilha está desativada.

Alterado na versão 3.6: Sublinhados são permitidos para agrupamento, como nos literais de ponto flutuante e integral no código.

Objetos decimais de ponto flutuante compartilham muitas propriedades com outros tipos numéricos embutidos, como float e int. Todas as operações matemáticas usuais e métodos especiais se aplicam. Da mesma forma, objetos decimais podem ser copiados, separados, impressos, usados como chaves de dicionário, usados como elementos de conjunto, comparados, classificados e coagidos a outro tipo (como float ou int).

Existem algumas pequenas diferenças entre aritmética em objetos decimais e aritmética em números inteiros e flutuantes. Quando o operador de resto % é aplicado a objetos decimais, o sinal do resultado é o sinal do dividend em vez do sinal do divisor:

>>> (-7) % 4
1
>>> Decimal(-7) % Decimal(4)
Decimal('-3')

O operador de divisão inteira // se comporta de maneira análoga, retornando a parte inteira do quociente verdadeiro (truncando em direção a zero) em vez de seu resto, de modo a preservar a identidade usual x == (x // y) * y + x % y:

>>> -7 // 4
-2
>>> Decimal(-7) // Decimal(4)
Decimal('-1')

Os operadores % e // implementam as operações de remainder e divide-integer (respectivamente) como descrito na especificação.

Objetos decimais geralmente não podem ser combinados com pontos flutuantes ou instâncias de fractions.Fraction em operações aritméticas: uma tentativa de adicionar um Decimal a um float, por exemplo, vai levantar um TypeError. No entanto, é possível usar os operadores de comparação do Python para comparar uma instância de Decimal x com outro número y. Isso evita resultados confusos ao fazer comparações de igualdade entre números de tipos diferentes.

Alterado na versão 3.2: As comparações de tipos mistos entre instâncias de Decimal e outros tipos numéricos agora são totalmente suportadas.

Além das propriedades numéricas padrão, os objetos de ponto flutuante decimal também possuem vários métodos especializados:

adjusted()¶: Retorna o expoente ajustado depois de deslocar os dígitos mais à direita do coeficiente até restar apenas o dígito principal: Decimal('321e+5').adjusted() retorna sete. Usado para determinar a posição do dígito mais significativo em relação ao ponto decimal.

as_integer_ratio()¶

Retorna um par (n, d) de números inteiros que representam a instância dada Decimal como uma fração, nos termos mais baixos e com um denominador positivo:

>>> Decimal('-3.14').as_integer_ratio()
(-157, 50)

A conversão é exata. Levanta OverflowError em infinitos e ValueError em NaNs.

Novo na versão 3.6.

as_tuple()¶: Retorna uma representação de tupla nomeada do número: DecimalTuple(sign, digits, exponent).

canonical()¶: Retorna a codificação canônica do argumento. Atualmente, a codificação de uma instância de Decimal é sempre canônica, portanto, esta operação retorna seu argumento inalterado.

compare(other, context=None)¶

Compara os valores de duas instâncias decimais. compare() retorna uma instância decimal, e se qualquer operando for um NaN, o resultado será um NaN:

a or b is a NaN  ==> Decimal('NaN')
a < b            ==> Decimal('-1')
a == b           ==> Decimal('0')
a > b            ==> Decimal('1')

compare_signal(other, context=None)¶: Esta operação é idêntica ao método compare(), exceto que todos os NaNs sinalizam. Ou seja, se nenhum operando for um NaN sinalizador, qualquer operando NaN silencioso será tratado como se fosse um NaN sinalizador.

compare_total(other, context=None)¶

Compara dois operandos usando sua representação abstrata em vez de seu valor numérico. Semelhante ao método compare(), mas o resultado fornece uma ordem total nas instâncias de Decimal. Duas instâncias de Decimal com o mesmo valor numérico, mas diferentes representações, se comparam desiguais nesta ordem:

>>> Decimal('12.0').compare_total(Decimal('12'))
Decimal('-1')

Os NaNs silenciosos e sinalizadores também estão incluídos no pedido total. O resultado dessa função é Decimal('0') se os dois operandos tiverem a mesma representação, Decimal('-1') se o primeiro operando for menor na ordem total que o segundo e Decimal('1') se o primeiro operando for maior na ordem total que o segundo operando. Veja a especificação para detalhes da ordem total.

Esta operação não é afetada pelo contexto e é silenciosa: nenhum sinalizador é alterado e nenhum arredondamento é executado. Como uma exceção, a versão C pode levantar InvalidOperation se o segundo operando não puder ser convertido exatamente.

compare_total_mag(other, context=None)¶

Compara dois operandos usando sua representação abstrata em vez de seu valor, como em compare_total(), mas ignorando o sinal de cada operando. x.compare_total_mag(y) é equivalente a x.copy_abs().compare_total(y.copy_abs()).

Esta operação não é afetada pelo contexto e é silenciosa: nenhum sinalizador é alterado e nenhum arredondamento é executado. Como uma exceção, a versão C pode levantar InvalidOperation se o segundo operando não puder ser convertido exatamente.

conjugate()¶: Apenas retorna a si próprio, sendo esse método apenas para atender à Especificação de Decimal.

copy_abs()¶: Retorna o valor absoluto do argumento. Esta operação não é afetada pelo contexto e é silenciosa: nenhum sinalizador é alterado e nenhum arredondamento é executado.

copy_negate()¶: Retorna a negação do argumento. Esta operação não é afetada pelo contexto e é silenciosa: nenhum sinalizador é alterado e nenhum arredondamento é executado.

copy_sign(other, context=None)¶

Retorna uma cópia do primeiro operando com o sinal definido para ser o mesmo que o sinal do segundo operando. Por exemplo:

>>> Decimal('2.3').copy_sign(Decimal('-1.5'))
Decimal('-2.3')

Esta operação não é afetada pelo contexto e é silenciosa: nenhum sinalizador é alterado e nenhum arredondamento é executado. Como uma exceção, a versão C pode levantar InvalidOperation se o segundo operando não puder ser convertido exatamente.

exp(context=None)¶

Retorna o valor da função exponencial (natural) e**x no número especificado. O resultado é arredondado corretamente usando o modo de arredondamento ROUND_HALF_EVEN.

>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal(321).exp()
Decimal('2.561702493119680037517373933E+139')

from_float(f)¶

Método de classe que converte um ponto flutuante em um número decimal, exatamente.

Observe que Decimal.from_float(0.1) não é o mesmo que Decimal(‘0.1’). Como 0.1 não é exatamente representável no ponto flutuante binário, o valor é armazenado como o valor representável mais próximo que é 0x1.999999999999ap-4. Esse valor equivalente em decimal é 0.1000000000000000055511151231257827021181583404541015625.

Nota

A partir do Python 3.2 em diante, uma instância de Decimal também pode ser construída diretamente a partir de um float.

>>> Decimal.from_float(0.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
>>> Decimal.from_float(float('nan'))
Decimal('NaN')
>>> Decimal.from_float(float('inf'))
Decimal('Infinity')
>>> Decimal.from_float(float('-inf'))
Decimal('-Infinity')

Novo na versão 3.1.

fma(other, third, context=None)¶

Multiplicação e adição fundidos. Retorna self*other+third sem arredondamento do produto intermediário self*other.

>>> Decimal(2).fma(3, 5)
Decimal('11')

is_canonical()¶: Retorna True se o argumento for canônico e False caso contrário. Atualmente, uma instância de Decimal é sempre canônica, portanto, esta operação sempre retorna True.

is_finite()¶: Retorna True se o argumento for um número finito e False se o argumento for um infinito ou um NaN.

is_infinite()¶: Retorna True se o argumento for infinito positivo ou negativo e False caso contrário.

is_nan()¶: Retorna True se o argumento for NaN (silencioso ou sinalizador) e False caso contrário.

is_normal(context=None)¶: Retorna True se o argumento for um número finito normal. Retorna False se o argumento for zero, subnormal, infinito ou NaN.

is_qnan()¶: Retorna True se o argumento for um NaN silencioso, e False caso contrário.

is_signed()¶: Retorna True se o argumento tiver um sinal negativo e False caso contrário. Observe que zeros e NaNs podem carregar sinais.

is_snan()¶: Retorna True se o argumento for um sinal NaN e False caso contrário.

is_subnormal(context=None)¶: Retorna True se o argumento for subnormal e False caso contrário.

is_zero()¶: Retorna True se o argumento for um zero (positivo ou negativo) e False caso contrário.

ln(context=None)¶: Retorna o logaritmo (base e) natural do operando. O resultado é arredondado corretamente usando o modo de arredondamento ROUND_HALF_EVEN.

log10(context=None)¶: Retorna o logaritmo da base dez do operando. O resultado é arredondado corretamente usando o modo de arredondamento ROUND_HALF_EVEN.

logb(context=None)¶: Para um número diferente de zero, retorna o expoente ajustado de seu operando como uma instância de Decimal. Se o operando é zero, Decimal('-Infinity') é retornado e o sinalizador DivisionByZero é levantado. Se o operando for um infinito, Decimal('Infinity') será retornado.

logical_and(other, context=None)¶: logical_and() é uma operação lógica que leva dois operandos lógicos (consulte Operandos lógicos). O resultado é o and dígito a dígito dos dois operandos.

logical_invert(context=None)¶: logical_invert() é uma operação lógica. O resultado é a inversão dígito a dígito do operando.

logical_or(other, context=None)¶: logical_or() é uma operação lógica que leva dois operandos lógicos (consulte Operandos lógicos). O resultado é o or dígito a dígito dos dois operandos.

logical_xor(other, context=None)¶: logical_xor() é uma operação lógica que leva dois operandos lógicos (consulte Operandos lógicos). O resultado é o “ou exclusivo” dígito a dígito ou dos dois operandos.

max(other, context=None)¶: Como max(self, other), exceto que a regra de arredondamento de contexto é aplicada antes de retornar e que os valores NaN são sinalizados ou ignorados (dependendo do contexto e se estão sinalizando ou silenciosos).

max_mag(other, context=None)¶: Semelhante ao método max(), mas a comparação é feita usando os valores absolutos dos operandos.

min(other, context=None)¶: Como min(self, other), exceto que a regra de arredondamento de contexto é aplicada antes de retornar e que os valores NaN são sinalizados ou ignorados (dependendo do contexto e se estão sinalizando ou silenciosos).

min_mag(other, context=None)¶: Semelhante ao método min(), mas a comparação é feita usando os valores absolutos dos operandos.

next_minus(context=None)¶: Retorna o maior número representável no contexto fornecido (ou no contexto atual da thread, se nenhum contexto for fornecido) que seja menor que o operando especificado.

next_plus(context=None)¶: Retorna o menor número representável no contexto fornecido (ou no contexto atual da thread, se nenhum contexto for fornecido) que seja maior que o operando fornecido.

next_toward(other, context=None)¶: Se os dois operandos forem desiguais, retorna o número mais próximo ao primeiro operando na direção do segundo operando. Se os dois operandos forem numericamente iguais, retorna uma cópia do primeiro operando com o sinal configurado para ser o mesmo que o sinal do segundo operando.

normalize(context=None)¶: Normaliza o número eliminando os zeros à direita e convertendo qualquer resultado igual a Decimal('0') para Decimal('0e0'). Usado para produzir valores canônicos para atributos de uma classe de equivalência. Por exemplo, Decimal('32.100') e Decimal('0.321000e+2') normalizam com o valor equivalente Decimal('32.1').

number_class(context=None)¶

Retorna uma string descrevendo a classe do operando. O valor retornado é uma das dez sequências a seguir.

"-Infinity", indicando que o operando é infinito negativo.
"-Normal", indicando que o operando é um número normal negativo.
"-Subnormal", indicando que o operando é negativo e subnormal.
"-Zero", indicando que o operando é um zero negativo.
"+Zero", indicando que o operando é um zero positivo.
"+Subnormal", indicando que o operando é positivo e subnormal.
"+Normal", indicando que o operando é um número normal positivo.
"+Infinity", indicando que o operando é infinito positivo.
"NaN", indicando que o operando é um NaN (“Not a Number”) silencioso.
"sNaN", indicando que o operando é um NaN sinalizador.

quantize(exp, rounding=None, context=None)¶

Retorna um valor igual ao primeiro operando após o arredondamento e com o expoente do segundo operando.

>>> Decimal('1.41421356').quantize(Decimal('1.000'))
Decimal('1.414')

Diferentemente de outras operações, se o comprimento do coeficiente após a operação de quantização for maior que a precisão, então InvalidOperation é sinalizado. Isso garante que, a menos que haja uma condição de erro, o expoente quantizado é sempre igual ao do operando do lado direito.

Também, diferentemente de outras operações, a quantização nunca sinaliza Underflow, mesmo que o resultado seja subnormal e inexato.

Se o expoente do segundo operando for maior que o do primeiro, o arredondamento poderá ser necessário. Nesse caso, o modo de arredondamento é determinado pelo argumento rounding, se fornecido, ou pelo argumento context fornecido; se nenhum argumento for fornecido, o modo de arredondamento do contexto da thread atual será usado.

Um erro é retornado sempre que o expoente resultante for maior que Emax ou menor que Etiny.

radix()¶: Retorna Decimal(10), a raiz (base) na qual a classe Decimal faz toda a sua aritmética. Incluído para compatibilidade com a especificação.

remainder_near(other, context=None)¶

Retorna o resto da divisão de self por other. Isso é diferente de self % other, pois o sinal do resto é escolhido para minimizar seu valor absoluto. Mais precisamente, o valor de retorno é self - n * other, onde n é o número inteiro mais próximo do valor exato de self / other, e se dois números inteiros estiverem igualmente próximos, o par será é escolhido.

Se o resultado for zero, seu sinal será o sinal de self.

>>> Decimal(18).remainder_near(Decimal(10))
Decimal('-2')
>>> Decimal(25).remainder_near(Decimal(10))
Decimal('5')
>>> Decimal(35).remainder_near(Decimal(10))
Decimal('-5')

rotate(other, context=None)¶: Retorna o resultado da rotação dos dígitos do primeiro operando em uma quantidade especificada pelo segundo operando. O segundo operando deve ser um número inteiro no intervalo - precisão através da precisão. O valor absoluto do segundo operando fornece o número de locais a serem rotacionados. Se o segundo operando for positivo, a rotação será para a esquerda; caso contrário, a rotação será para a direita. O coeficiente do primeiro operando é preenchido à esquerda com zeros na precisão do comprimento, se necessário. O sinal e o expoente do primeiro operando não são alterados.

same_quantum(other, context=None)¶

Testa se “self” e “other” têm o mesmo expoente ou se ambos são NaN.

Esta operação não é afetada pelo contexto e é silenciosa: nenhum sinalizador é alterado e nenhum arredondamento é executado. Como uma exceção, a versão C pode levantar InvalidOperation se o segundo operando não puder ser convertido exatamente.

scaleb(other, context=None)¶: Retorna o primeiro operando com o expoente ajustado pelo segundo. Da mesma forma, retorna o primeiro operando multiplicado por 10**other. O segundo operando deve ser um número inteiro.

shift(other, context=None)¶: Retorna o resultado da troca dos dígitos do primeiro operando em uma quantidade especificada pelo segundo operando. O segundo operando deve ser um número inteiro no intervalo - precisão através da precisão. O valor absoluto do segundo operando fornece o número de locais a serem deslocados. Se o segundo operando for positivo, o deslocamento será para a esquerda; caso contrário, a mudança é para a direita. Os dígitos deslocados para o coeficiente são zeros. O sinal e o expoente do primeiro operando não são alterados.

sqrt(context=None)¶: Retorna a raiz quadrada do argumento para a precisão total.

to_eng_string(context=None)¶

Converte em uma string, usando notação de engenharia, se for necessário um expoente.

A notação de engenharia possui um expoente que é múltiplo de 3. Isso pode deixar até 3 dígitos à esquerda da casa decimal e pode exigir a adição de um ou dois zeros à direita.

Por exemplo, isso converte Decimal('123E+1') para Decimal('1.23E+3').

to_integral(rounding=None, context=None)¶: Idêntico ao método to_integral_value(). O nome to_integral foi mantido para compatibilidade com versões mais antigas.

to_integral_exact(rounding=None, context=None)¶: Arredonda para o número inteiro mais próximo, sinalizando Inexact ou Rounded, conforme apropriado, se o arredondamento ocorrer. O modo de arredondamento é determinado pelo parâmetro rounding, se fornecido, ou pelo context especificado. Se nenhum parâmetro for fornecido, o modo de arredondamento do contexto atual será usado.

to_integral_value(rounding=None, context=None)¶: Arredonda para o número inteiro mais próximo sem sinalizar Inexact ou Rounding. Se fornecido, aplica rounding; caso contrário, usa o método de arredondamento no context especificado ou no contexto atual.

Operandos lógicos¶

Os métodos logical_and(), logical_invert(), logical_or() e logical_xor() esperam que seus argumentos sejam operandos lógicos. Um operando lógico é uma instância de Decimal cujo expoente e sinal são zero e cujos dígitos são todos 0 ou 1.

Objetos de contexto¶

Contextos são ambientes para operações aritméticas. Eles governam a precisão, estabelecem regras para arredondamento, determinam quais sinais são tratados como exceções e limitam o intervalo dos expoentes.

Cada thread possui seu próprio contexto atual que é acessado ou alterado usando as funções getcontext() e setcontext():

decimal.getcontext()¶: Retorna o contexto atual para a thread ativa.

decimal.setcontext(c)¶: Define o contexto atual para a thread ativa como C.

Você também pode usar a instrução with e a função localcontext() para alterar temporariamente o contexto ativo.

decimal.localcontext(ctx=None)¶

Retorna um gerenciador de contexto que vai definir o contexto atual da thread ativa para uma cópia de ctx na entrada da instrução “with” e restaurar o contexto anterior ao sair da instrução “with”. Se nenhum contexto for especificado, uma cópia do contexto atual será usada.

Por exemplo, o código a seguir define a precisão decimal atual para 42 casas, executa um cálculo e restaura automaticamente o contexto anterior:

from decimal import localcontext

with localcontext() as ctx:
    ctx.prec = 42   # Perform a high precision calculation
    s = calculate_something()
s = +s  # Round the final result back to the default precision

Novos contextos também podem ser criados usando o construtor Context descrito abaixo. Além disso, o módulo fornece três contextos pré-criados:

class decimal.BasicContext¶

Este é um contexto padrão definido pela Especificação Aritmética Decimal Geral. A precisão está definida como nove. O arredondamento está definido como ROUND_HALF_UP. Todos os sinalizadores estão limpos. Todos as armadilhas estão ativadas (tratadas como exceções), exceto por Inexact, Rounded e Subnormal.

Como muitas das armadilhas estão ativadas, esse contexto é útil para depuração.

class decimal.ExtendedContext¶

Este é um contexto padrão definido pela Especificação Aritmética Decimal Geral. A precisão está definida como nove. O arredondamento está definido como ROUND_HALF_EVEN. Todos os sinalizadores estão limpos. Nenhuma armadilha está ativada (de forma que exceções não são levantadas durante os cálculos).

Como as armadilhas estão desativadas, esse contexto é útil para aplicativos que preferem ter o valor de resultado de NaN ou Infinity em vez de levantar exceções. Isso permite que uma aplicação conclua uma execução na presença de condições que interromperiam o programa.

class decimal.DefaultContext¶

Este contexto é usado pelo construtor Context como um protótipo para novos contextos. Alterar um campo (tal como precisão) tem o efeito de alterar o padrão para novos contextos criados pelo construtor Context.

Esse contexto é mais útil em ambientes multithread. A alteração de um dos campos antes do início das threads tem o efeito de definir os padrões para todo o sistema. Não é recomendável alterar os campos após o início das threads, pois exigiria sincronização de threads para evitar condições de corrida.

Em ambientes de thread única, é preferível não usar esse contexto. Em vez disso, basta criar contextos explicitamente, conforme descrito abaixo.

Os valores padrão são prec=28, rounding=ROUND_HALF_EVEN e armadilhas ativadas para Overflow, InvalidOperation e DivisionByZero.

Além dos três contextos fornecidos, novos contextos podem ser criados com o construtor Context.

class decimal.Context(prec=None, rounding=None, Emin=None, Emax=None, capitals=None, clamp=None, flags=None, traps=None)¶

Cria um novo contexto. Se um campo não for especificado ou for None, os valores padrão serão copiados de DefaultContext. Se o campo flags não for especificado ou for None, todos os sinalizadores serão limpados.

prec é um número inteiro no intervalo [1, MAX_PREC] que define a precisão das operações aritméticas no contexto.

A opção rounding é uma das constantes listadas na seção Modos de arredondamento.

Os campos traps e flags listam todos os sinais a serem configurados. Geralmente, novos contextos devem apenas definir armadilhas e deixar os sinalizadores limpos.

Os campos Emin e Emax são números inteiros que especificam os limites externos permitidos para expoentes. Emin deve estar no intervalo [MIN_EMIN, 0], Emax no intervalo [0, MAX_EMAX].

O campo capitals é 0 ou 1 (o padrão). Se definido como 1, os expoentes serão impressos com um E maiúsculo; caso contrário, um e minúscula é usado: Decimal('6.02e+23').

O campo clamp é 0 (o padrão) ou 1. Se definido como 1, o expoente e de uma instância de Decimal representável nesse contexto é estritamente limitado ao intervalo Emin - prec + 1 <= e <= Emax - prec + 1. Se clamp for 0, uma condição mais fraca será mantida: o expoente ajustado da instância de Decimal é no máximo Emax. Quando clamp é 1, um grande número normal terá, sempre que possível, seu expoente reduzido e um número correspondente de zeros adicionado ao seu coeficiente, para ajustar as restrições do expoente; isso preserva o valor do número, mas perde informações sobre zeros à direita significativos. Por exemplo:

>>> Context(prec=6, Emax=999, clamp=1).create_decimal('1.23e999')
Decimal('1.23000E+999')

Um valor de clamp de 1 permite compatibilidade com os formatos de intercâmbio decimal de largura fixa especificados na IEEE 754.

A classe Context define vários métodos de uso geral, bem como um grande número de métodos para fazer aritmética diretamente em um determinado contexto. Além disso, para cada um dos métodos de Decimal descritos acima (com exceção dos métodos adjusted() e as_tuple()) existe um método correspondente em Context. Por exemplo, para uma instância C de Context e uma instância x de Decimal, C.exp(x) é equivalente a x.exp(context=C). Cada método de Context aceita um número inteiro do Python (uma instância de int) em qualquer lugar em que uma instância de Decimal seja aceita.

clear_flags()¶: Redefine todos os sinalizadores para 0.

clear_traps()¶: Redefine todas as armadilhas para 0.

Novo na versão 3.3.

copy()¶: Retorna uma duplicata do contexto.

copy_decimal(num)¶: Retorna uma cópia da instância de Decimal num.

create_decimal(num)¶

Cria uma nova instância decimal a partir de num, mas usando self como contexto. Diferentemente do construtor de Decimal, a precisão do contexto, o método de arredondamento, os sinalizadores e as armadilhas são aplicadas à conversão.

Isso é útil porque as constantes geralmente são fornecidas com uma precisão maior do que a necessária pela aplicação. Outro benefício é que o arredondamento elimina imediatamente os efeitos indesejados dos dígitos além da precisão atual. No exemplo a seguir, o uso de entradas não arredondadas significa que adicionar zero a uma soma pode alterar o resultado:

>>> getcontext().prec = 3
>>> Decimal('3.4445') + Decimal('1.0023')
Decimal('4.45')
>>> Decimal('3.4445') + Decimal(0) + Decimal('1.0023')
Decimal('4.44')

Este método implementa a operação “to-number” da especificação IBM. Se o argumento for uma string, nenhum espaço em branco à esquerda ou à direita ou sublinhado serão permitidos.

create_decimal_from_float(f)¶

Cria uma nova instância de Decimal a partir de um ponto flutuante f, mas arredondando usando self como contexto. Diferentemente do método da classe Decimal.from_float(), a precisão do contexto, o método de arredondamento, os sinalizadores e as armadilhas são aplicados à conversão.

>>> context = Context(prec=5, rounding=ROUND_DOWN)
>>> context.create_decimal_from_float(math.pi)
Decimal('3.1415')
>>> context = Context(prec=5, traps=[Inexact])
>>> context.create_decimal_from_float(math.pi)
Traceback (most recent call last):
    ...
decimal.Inexact: None

Novo na versão 3.1.

Etiny()¶: Retorna um valor igual a Emin - prec + 1, que é o valor mínimo do expoente para resultados subnormais. Quando ocorre o estouro negativo, o expoente é definido como Etiny.

Etop()¶: Retorna um valor igual a Emax - prec + 1.

A abordagem usual para trabalhar com decimais é criar instâncias de Decimal e depois aplicar operações aritméticas que ocorrem no contexto atual da thread ativa. Uma abordagem alternativa é usar métodos de contexto para calcular dentro de um contexto específico. Os métodos são semelhantes aos da classe Decimal e são contados apenas brevemente aqui.

abs(x)¶: Retorna o valor absoluto de x.

add(x, y)¶: Retorna a soma de x e y.

canonical(x)¶: Retorna o mesmo objeto de Decimal x.

compare(x, y)¶: Compara x e y numericamente.

compare_signal(x, y)¶: Compara os valores dos dois operandos numericamente.

compare_total(x, y)¶: Compara dois operandos usando sua representação abstrata.

compare_total_mag(x, y)¶: Compara dois operandos usando sua representação abstrata, ignorando o sinal.

copy_abs(x)¶: Retorna uma cópia de x com o sinal definido para 0.

copy_negate(x)¶: Retorna uma cópia de x com o sinal invertido.

copy_sign(x, y)¶: Copia o sinal de y para x.

divide(x, y)¶: Retorna x dividido por y.

divide_int(x, y)¶: Retorna x dividido por y, truncado para um inteiro.

divmod(x, y)¶: Divide dois números e retorna a parte inteira do resultado.

exp(x)¶: Retorna e ** x.

fma(x, y, z)¶: Retorna x multiplicado por y, mais z.

is_canonical(x)¶: Retorna True se x for canonical; caso contrário, retorna False.

is_finite(x)¶: Retorna True se x for finito; caso contrário, retorna False.

is_infinite(x)¶: Retorna True se x for infinito; caso contrário, retorna False.

is_nan(x)¶: Retorna True se x for qNaN ou sNaN; caso contrário, retorna False.

is_normal(x)¶: Retorna True se x for um número normal; caso contrário, retorna False.

is_qnan(x)¶: Retorna True se x for um NaN silencioso; caso contrário, retorna False.

is_signed(x)¶: Retorna True se x for negativo; caso contrário, retorna False.

is_snan(x)¶: Retorna True se x for um NaN sinalizador; caso contrário, retorna False.

is_subnormal(x)¶: Retorna True se x for subnormal; caso contrário, retorna False.

is_zero(x)¶: Retorna True se x for zero; caso contrário, retorna False.

ln(x)¶: Retorna o logaritmo natural (base e) de x.

log10(x)¶: Retorna o logaritmo de base 10 de x.

logb(x)¶: Retorna o expoente da magnitude do MSD do operando.

logical_and(x, y)¶: Aplica a operação lógica e entre cada dígito do operando.

logical_invert(x)¶: Inverte todos os dígitos em x.

logical_or(x, y)¶: Aplica a operação lógica ou entre cada dígito do operando.

logical_xor(x, y)¶: Aplica a operação lógica ou exclusivo entre cada dígito do operando.

max(x, y)¶: Compara dois valores numericamente e retorna o máximo.

max_mag(x, y)¶: Compara dois valores numericamente com seu sinal ignorado.

min(x, y)¶: Compara dois valores numericamente e retorna o mínimo.

min_mag(x, y)¶: Compara dois valores numericamente com seu sinal ignorado.

minus(x)¶: Minus corresponde ao operador de subtração de prefixo unário no Python.

multiply(x, y)¶: Retorna o produto de x e y.

next_minus(x)¶: Retorna o maior número representável menor que x.

next_plus(x)¶: Retorna o menor número representável maior que x.

next_toward(x, y)¶: Retorna o número mais próximo a x, em direção a y.

normalize(x)¶: Reduz x para sua forma mais simples.

number_class(x)¶: Retorna uma indicação da classe de x.

plus(x)¶: Plus corresponde ao operador de soma de prefixo unário no Python. Esta operação aplica a precisão e o arredondamento do contexto, portanto não é uma operação de identidade.

power(x, y, modulo=None)¶

Retorna x à potência de y, com a redução de módulo modulo se fornecido.

Com dois argumentos, calcula x**y. Se x for negativo, y deve ser inteiro. O resultado será inexato, a menos que y seja inteiro e o resultado seja finito e possa ser expresso exatamente em “precisão” dígitos. O modo de arredondamento do contexto é usado. Os resultados são sempre arredondados corretamente na versão Python.

Decimal(0) ** Decimal(0) resulta em InvalidOperation, e se InvalidOperation não for capturado, resulta em Decimal('NaN').

Alterado na versão 3.3: O módulo C calcula power() em termos das funções corretamente arredondadas exp() e ln(). O resultado é bem definido, mas apenas “quase sempre corretamente arredondado”.

Com três argumentos, calcula (x**y) % modulo. Para o formulário de três argumentos, as seguintes restrições nos argumentos são válidas:

todos os três argumentos devem ser inteiros

y não pode ser negativo

pelo menos um de x ou y não pode ser negativo

modulo não pode ser zero e deve ter pelo menos “precisão” dígitos

O valor resultante de Context.power(x, y, modulo) é igual ao valor que seria obtido ao computar (x**y) % modulo com precisão ilimitada, mas é calculado com mais eficiência . O expoente do resultado é zero, independentemente dos expoentes de x, y e modulo. O resultado é sempre exato.

quantize(x, y)¶: Retorna um valor igual a x (arredondado), com o expoente de y.

radix()¶: Só retorna 10, já que isso é Decimal, :)

remainder(x, y)¶

Retorna o resto da divisão inteira.

O sinal do resultado, se diferente de zero, é o mesmo que o do dividendo original.

remainder_near(x, y)¶: Retorna x - y * n, onde n é o número inteiro mais próximo do valor exato de x / y (se o resultado for 0, seu sinal será o sinal de x).

rotate(x, y)¶: Retorna uma cópia re de x, y vezes.

same_quantum(x, y)¶: Retorna True se os dois operandos tiverem o mesmo expoente.

scaleb(x, y)¶: Retorna o primeiro operando após adicionar o segundo valor seu exp.

shift(x, y)¶: Retorna uma cópia deslocada de x, y vezes.

sqrt(x)¶: Raiz quadrada de um número não negativo para precisão do contexto.

subtract(x, y)¶: Retorna a diferença entre x e y.

to_eng_string(x)¶

Converte em uma string, usando notação de engenharia, se for necessário um expoente.

A notação de engenharia possui um expoente que é múltiplo de 3. Isso pode deixar até 3 dígitos à esquerda da casa decimal e pode exigir a adição de um ou dois zeros à direita.

to_integral_exact(x)¶: Arredonda para um número inteiro.

to_sci_string(x)¶: Converte um número em uma string usando notação científica.

Constantes¶

As constantes nesta seção são relevantes apenas para o módulo C. Eles também estão incluídos na versão pura do Python para compatibilidade.

	32 bits	64 bits
`decimal.MAX_PREC`¶	`425000000`	`999999999999999999`
`decimal.MAX_EMAX`¶	`425000000`	`999999999999999999`
`decimal.MIN_EMIN`¶	`-425000000`	`-999999999999999999`
`decimal.MIN_ETINY`¶	`-849999999`	`-1999999999999999997`

decimal.HAVE_THREADS¶: O valor é True. Descontinuado porque o Python agora sempre tem threads.

Obsoleto desde a versão 3.9.

decimal.HAVE_CONTEXTVAR¶: O valor padrão é True. Se o Python for compilado usando --without-decimal-contextvar, a versão C usará um contexto local de thread em vez de local de corrotina e o valor será False. Isso é um pouco mais rápido em alguns cenários de contexto aninhados.

Novo na versão 3.9: backport realizado para 3.7 e 3.8.

Modos de arredondamento¶

decimal.ROUND_CEILING¶: Arredonda para Infinity.

decimal.ROUND_DOWN¶: Arredonda para zero.

decimal.ROUND_FLOOR¶: Arredonda para -Infinity.

decimal.ROUND_HALF_DOWN¶: Arrendonda para o mais próximo com empates tendendo a zero.

decimal.ROUND_HALF_EVEN¶: Arredonda para o mais próximo com empates indo para o mais próximo inteiro par.

decimal.ROUND_HALF_UP¶: Arrendonda para o mais próximo com empates se afastando de zero.

decimal.ROUND_UP¶: Arredonda se afastando de zero.

decimal.ROUND_05UP¶: Arredonda se afastando de zero se o último dígito após o arredondamento para zero fosse 0 ou 5; caso contrário, arredonda para zero.

Sinais¶

Sinais representam condições que surgem durante o cálculo. Cada um corresponde a um sinalizador de contexto e um ativador de armadilha de contexto.

O sinalizador de contexto é definido sempre que a condição é encontrada. Após o cálculo, os sinalizadores podem ser verificados para fins informativos (por exemplo, para determinar se um cálculo era exato). Depois de verificar os sinalizadores, certifique-se de limpar todos os sinalizadores antes de iniciar o próximo cálculo.

Se o ativador de armadilha de contexto estiver definido para o sinal, a condição fará com que uma exceção Python seja levantada. Por exemplo, se a armadilha DivisionByZero for configurada, uma exceção DivisionByZero será levantada ao encontrar a condição.

class decimal.Clamped¶

Altera um expoente para ajustar as restrições de representação.

Normalmente, clamping ocorre quando um expoente fica fora dos limites do contexto Emin e Emax. Se possível, o expoente é reduzido para caber adicionando zeros ao coeficiente.

class decimal.DecimalException¶: Classe base para outros sinais e uma subclasse de ArithmeticError.

class decimal.DivisionByZero¶

Sinaliza a divisão de um número não infinito por zero.

Pode ocorrer com divisão, divisão de módulo ou ao elevar um número a uma potência negativa. Se este sinal não for capturado, retornará Infinity ou -Infinity com o sinal determinado pelas entradas do cálculo.

class decimal.Inexact¶

Indica que o arredondamento ocorreu e o resultado não é exato.

Sinaliza quando dígitos diferentes de zero foram descartados durante o arredondamento. O resultado arredondado é retornado. O sinalizador ou armadilha de sinal é usado para detectar quando os resultados são inexatos.

class decimal.InvalidOperation¶

Uma operação inválida foi realizada.

Indica que uma operação foi solicitada que não faz sentido. Se não for capturado, retorna NaN. As possíveis causas incluem:

Infinity - Infinity
0 * Infinity
Infinity / Infinity
x % 0
Infinity % x
sqrt(-x) and x > 0
0 ** 0
x ** (non-integer)
x ** Infinity

class decimal.Overflow¶

Estouro numérico.

Indica que o expoente é maior que Emax após o arredondamento ocorrer. Se não for capturado, o resultado depende do modo de arredondamento, puxando para dentro para o maior número finito representável ou arredondando para fora para Infinity. Nos dois casos, Inexact e Rounded também são sinalizados.

class decimal.Rounded¶

O arredondamento ocorreu, embora possivelmente nenhuma informação tenha sido perdida.

Sinalizado sempre que o arredondamento descarta dígitos; mesmo que esses dígitos sejam zero (como arredondamento 5.00 a 5.0). Se não for capturado, retorna o resultado inalterado. Este sinal é usado para detectar a perda de dígitos significativos.

class decimal.Subnormal¶

O expoente foi menor que Emin antes do arredondamento.

Ocorre quando um resultado da operação é subnormal (o expoente é muito pequeno). Se não for capturado, retorna o resultado inalterado.

class decimal.Underflow¶

Estouro negativo numérico com resultado arredondado para zero.

Ocorre quando um resultado subnormal é empurrado para zero arredondando. Inexact e Subnormal também são sinalizados.

class decimal.FloatOperation¶

Ativa semânticas mais rigorosas para misturar objetos de float com de Decimal.

Se o sinal não for capturado (padrão), a mistura de tipos float e Decimal será permitida no construtor Decimal, create_decimal() e em todos os operadores de comparação. Tanto a conversão quanto as comparações são exatas. Qualquer ocorrência de uma operação mista é registrada silenciosamente pela configuração FloatOperation nos sinalizadores de contexto. Conversões explícitas com from_float() ou create_decimal_from_float() não definem o sinalizador.

Caso contrário (o sinal é capturado), apenas comparações de igualdade e conversões explícitas são silenciosas. Todas as outras operações mistas levantam FloatOperation.

A tabela a seguir resume a hierarquia de sinais:

exceptions.ArithmeticError(exceptions.Exception)
    DecimalException
        Clamped
        DivisionByZero(DecimalException, exceptions.ZeroDivisionError)
        Inexact
            Overflow(Inexact, Rounded)
            Underflow(Inexact, Rounded, Subnormal)
        InvalidOperation
        Rounded
        Subnormal
        FloatOperation(DecimalException, exceptions.TypeError)

Observações sobre ponto flutuante¶

Atenuando o erro de arredondamento com maior precisão¶

O uso do ponto flutuante decimal elimina o erro de representação decimal (possibilitando representar 0.1 de forma exata); no entanto, algumas operações ainda podem sofrer erros de arredondamento quando dígitos diferentes de zero excederem a precisão fixa.

Os efeitos do erro de arredondamento podem ser amplificados pela adição ou subtração de quantidades quase compensadoras, resultando em perda de significância. Knuth fornece dois exemplos instrutivos em que a aritmética de ponto flutuante arredondado com precisão insuficiente causa a quebra das propriedades associativas e distributivas da adição:

# Examples from Seminumerical Algorithms, Section 4.2.2.
>>> from decimal import Decimal, getcontext
>>> getcontext().prec = 8

>>> u, v, w = Decimal(11111113), Decimal(-11111111), Decimal('7.51111111')
>>> (u + v) + w
Decimal('9.5111111')
>>> u + (v + w)
Decimal('10')

>>> u, v, w = Decimal(20000), Decimal(-6), Decimal('6.0000003')
>>> (u*v) + (u*w)
Decimal('0.01')
>>> u * (v+w)
Decimal('0.0060000')

O módulo decimal permite restaurar as identidades expandindo a precisão o suficiente para evitar perda de significância:

>>> getcontext().prec = 20
>>> u, v, w = Decimal(11111113), Decimal(-11111111), Decimal('7.51111111')
>>> (u + v) + w
Decimal('9.51111111')
>>> u + (v + w)
Decimal('9.51111111')
>>>
>>> u, v, w = Decimal(20000), Decimal(-6), Decimal('6.0000003')
>>> (u*v) + (u*w)
Decimal('0.0060000')
>>> u * (v+w)
Decimal('0.0060000')

Valores especiais¶

O sistema numérico para o módulo decimal fornece valores especiais, incluindo NaN, sNaN, -Infinity, Infinity e dois zeros, +0 e -0.

Os infinitos podem ser construídos diretamente com: Decimal('Infinity'). Além disso, eles podem resultar da divisão por zero quando o sinal DivisionByZero não é capturado. Da mesma forma, quando o sinal Overflow não é capturado, o infinito pode resultar do arredondamento além dos limites do maior número representável.

Os infinitos contêm sinais (afins) e podem ser usados em operações aritméticas, onde são tratados como números muito grandes e indeterminados. Por exemplo, adicionar uma constante ao infinito fornece outro resultado infinito.

Algumas operações são indeterminadas e retornam NaN ou, se o sinal InvalidOperation for capturado, levanta uma exceção. Por exemplo, 0/0 retorna NaN, que significa “não é um número” em inglês. Esta variação de NaN é silenciosa e, uma vez criada, fluirá através de outros cálculos sempre resultando em outra NaN. Esse comportamento pode ser útil para uma série de cálculos que ocasionalmente têm entradas ausentes — ele permite que o cálculo continue enquanto sinaliza resultados específicos como inválidos.

Uma variante é sNaN, que sinaliza em vez de permanecer em silêncio após cada operação. Esse é um valor de retorno útil quando um resultado inválido precisa interromper um cálculo para tratamento especial.

O comportamento dos operadores de comparação do Python pode ser um pouco surpreendente onde um NaN está envolvido. Um teste de igualdade em que um dos operandos é um NaN silencioso ou sinalizador sempre retorna False (mesmo ao fazer Decimal('NaN')==Decimal('NaN')), enquanto um teste de desigualdade sempre retorna True. Uma tentativa de comparar dois decimais usando qualquer um dos operadores <, <=, > ou >= levantará o sinal InvalidOperation se um dos operandos for um NaN e retorna False se esse sinal não for capturado. Observe que a especificação aritmética decimal geral não especifica o comportamento das comparações diretas; estas regras para comparações envolvendo a NaN foram retiradas do padrão IEEE 854 (consulte a Tabela 3 na seção 5.7). Para garantir uma rígida conformidade com os padrões, use os métodos compare() e compare-signal().

Os zeros com sinais podem resultar de cálculos insuficientes. Eles mantêm o sinal que teria resultado se o cálculo tivesse sido realizado com maior precisão. Como sua magnitude é zero, os zeros positivos e negativos são tratados como iguais e seu sinal é informacional.

Além dos dois zeros com sinais que são distintos e iguais, existem várias representações de zero com diferentes precisões e ainda com valor equivalente. Isso leva um pouco de tempo para se acostumar. Para um olho acostumado a representações de ponto flutuante normalizadas, não é imediatamente óbvio que o seguinte cálculo retorne um valor igual a zero:

>>> 1 / Decimal('Infinity')
Decimal('0E-1000026')

Trabalhando com threads¶

A função getcontext() acessa um objeto Context diferente para cada thread. Ter contextos de threads separadas significa que as threads podem fazer alterações (como getcontext().prec=10) sem interferir em outras threads.

Da mesma forma, a função setcontext() atribui automaticamente seu alvo à thread atual.

Se setcontext() não tiver sido chamado antes de getcontext(), então getcontext() criará automaticamente um novo contexto para uso na thread atual.

O novo contexto é copiado de um contexto protótipo chamado DefaultContext. Para controlar os padrões para que cada thread, use os mesmos valores em todo a aplicação, modifique diretamente o objeto DefaultContext. Isso deve ser feito antes de qualquer thread ser iniciada, para que não haja uma condição de corrida entre as threads chamando getcontext(). Por exemplo:

# Set applicationwide defaults for all threads about to be launched
DefaultContext.prec = 12
DefaultContext.rounding = ROUND_DOWN
DefaultContext.traps = ExtendedContext.traps.copy()
DefaultContext.traps[InvalidOperation] = 1
setcontext(DefaultContext)

# Afterwards, the threads can be started
t1.start()
t2.start()
t3.start()
 . . .

Receitas¶

Aqui estão algumas receitas que servem como funções utilitárias e que demonstram maneiras de trabalhar com a classe Decimal:

def moneyfmt(value, places=2, curr='', sep=',', dp='.',
             pos='', neg='-', trailneg=''):
    """Convert Decimal to a money formatted string.

    places:  required number of places after the decimal point
    curr:    optional currency symbol before the sign (may be blank)
    sep:     optional grouping separator (comma, period, space, or blank)
    dp:      decimal point indicator (comma or period)
             only specify as blank when places is zero
    pos:     optional sign for positive numbers: '+', space or blank
    neg:     optional sign for negative numbers: '-', '(', space or blank
    trailneg:optional trailing minus indicator:  '-', ')', space or blank

    >>> d = Decimal('-1234567.8901')
    >>> moneyfmt(d, curr='$')
    '-$1,234,567.89'
    >>> moneyfmt(d, places=0, sep='.', dp='', neg='', trailneg='-')
    '1.234.568-'
    >>> moneyfmt(d, curr='$', neg='(', trailneg=')')
    '($1,234,567.89)'
    >>> moneyfmt(Decimal(123456789), sep=' ')
    '123 456 789.00'
    >>> moneyfmt(Decimal('-0.02'), neg='<', trailneg='>')
    '<0.02>'

    """
    q = Decimal(10) ** -places      # 2 places --> '0.01'
    sign, digits, exp = value.quantize(q).as_tuple()
    result = []
    digits = list(map(str, digits))
    build, next = result.append, digits.pop
    if sign:
        build(trailneg)
    for i in range(places):
        build(next() if digits else '0')
    if places:
        build(dp)
    if not digits:
        build('0')
    i = 0
    while digits:
        build(next())
        i += 1
        if i == 3 and digits:
            i = 0
            build(sep)
    build(curr)
    build(neg if sign else pos)
    return ''.join(reversed(result))

def pi():
    """Compute Pi to the current precision.

    >>> print(pi())
    3.141592653589793238462643383

    """
    getcontext().prec += 2  # extra digits for intermediate steps
    three = Decimal(3)      # substitute "three=3.0" for regular floats
    lasts, t, s, n, na, d, da = 0, three, 3, 1, 0, 0, 24
    while s != lasts:
        lasts = s
        n, na = n+na, na+8
        d, da = d+da, da+32
        t = (t * n) / d
        s += t
    getcontext().prec -= 2
    return +s               # unary plus applies the new precision

def exp(x):
    """Return e raised to the power of x.  Result type matches input type.

    >>> print(exp(Decimal(1)))
    2.718281828459045235360287471
    >>> print(exp(Decimal(2)))
    7.389056098930650227230427461
    >>> print(exp(2.0))
    7.38905609893
    >>> print(exp(2+0j))
    (7.38905609893+0j)

    """
    getcontext().prec += 2
    i, lasts, s, fact, num = 0, 0, 1, 1, 1
    while s != lasts:
        lasts = s
        i += 1
        fact *= i
        num *= x
        s += num / fact
    getcontext().prec -= 2
    return +s

def cos(x):
    """Return the cosine of x as measured in radians.

    The Taylor series approximation works best for a small value of x.
    For larger values, first compute x = x % (2 * pi).

    >>> print(cos(Decimal('0.5')))
    0.8775825618903727161162815826
    >>> print(cos(0.5))
    0.87758256189
    >>> print(cos(0.5+0j))
    (0.87758256189+0j)

    """
    getcontext().prec += 2
    i, lasts, s, fact, num, sign = 0, 0, 1, 1, 1, 1
    while s != lasts:
        lasts = s
        i += 2
        fact *= i * (i-1)
        num *= x * x
        sign *= -1
        s += num / fact * sign
    getcontext().prec -= 2
    return +s

def sin(x):
    """Return the sine of x as measured in radians.

    The Taylor series approximation works best for a small value of x.
    For larger values, first compute x = x % (2 * pi).

    >>> print(sin(Decimal('0.5')))
    0.4794255386042030002732879352
    >>> print(sin(0.5))
    0.479425538604
    >>> print(sin(0.5+0j))
    (0.479425538604+0j)

    """
    getcontext().prec += 2
    i, lasts, s, fact, num, sign = 1, 0, x, 1, x, 1
    while s != lasts:
        lasts = s
        i += 2
        fact *= i * (i-1)
        num *= x * x
        sign *= -1
        s += num / fact * sign
    getcontext().prec -= 2
    return +s

FAQ sobre Decimal¶

P. É complicado digitar decimal.Decimal('1234.5'). Existe uma maneira de minimizar a digitação ao usar o interpretador interativo?

R. Alguns usuários abreviam o construtor para apenas uma única letra:

>>> D = decimal.Decimal
>>> D('1.23') + D('3.45')
Decimal('4.68')

P. Em uma aplicação de ponto fixo com duas casas decimais, algumas entradas têm muitas casas e precisam ser arredondadas. Outros não devem ter dígitos em excesso e precisam ser validados. Quais métodos devem ser usados?

R. O método quantize() arredonda para um número fixo de casas decimais. Se a armadilha Inexact estiver configurada, também será útil para validação:

>>> TWOPLACES = Decimal(10) ** -2       # same as Decimal('0.01')

>>> # Round to two places
>>> Decimal('3.214').quantize(TWOPLACES)
Decimal('3.21')

>>> # Validate that a number does not exceed two places
>>> Decimal('3.21').quantize(TWOPLACES, context=Context(traps=[Inexact]))
Decimal('3.21')

>>> Decimal('3.214').quantize(TWOPLACES, context=Context(traps=[Inexact]))
Traceback (most recent call last):
   ...
Inexact: None

P. Assim que eu tiver entradas de duas casas válidas, como mantenho essa invariante em uma aplicação?

R. Algumas operações como adição, subtração e multiplicação por um número inteiro preservam automaticamente o ponto fixo. Outras operações, como divisão e multiplicação não inteira, alteram o número de casas decimais e precisam ser seguidas com uma etapa quantize():

>>> a = Decimal('102.72')           # Initial fixed-point values
>>> b = Decimal('3.17')
>>> a + b                           # Addition preserves fixed-point
Decimal('105.89')
>>> a - b
Decimal('99.55')
>>> a * 42                          # So does integer multiplication
Decimal('4314.24')
>>> (a * b).quantize(TWOPLACES)     # Must quantize non-integer multiplication
Decimal('325.62')
>>> (b / a).quantize(TWOPLACES)     # And quantize division
Decimal('0.03')

No desenvolvimento de aplicativos de ponto fixo, é conveniente definir funções para lidar com a etapa quantize():

>>> def mul(x, y, fp=TWOPLACES):
...     return (x * y).quantize(fp)
>>> def div(x, y, fp=TWOPLACES):
...     return (x / y).quantize(fp)

>>> mul(a, b)                       # Automatically preserve fixed-point
Decimal('325.62')
>>> div(b, a)
Decimal('0.03')

P. Existem várias maneiras de expressar o mesmo valor. Os números 200, 200.000, 2E2 e 02E+4 têm todos o mesmo valor em várias precisões. Existe uma maneira de transformá-los em um único valor canônico reconhecível?

R. O método normalize() mapeia todos os valores equivalentes para um único representativo:

>>> values = map(Decimal, '200 200.000 2E2 .02E+4'.split())
>>> [v.normalize() for v in values]
[Decimal('2E+2'), Decimal('2E+2'), Decimal('2E+2'), Decimal('2E+2')]

P. Alguns valores decimais sempre são exibidas com notação exponencial. Existe uma maneira de obter uma representação não exponencial?

R. Para alguns valores, a notação exponencial é a única maneira de expressar o número de casas significativas no coeficiente. Por exemplo, expressar 5.0E+3 como 5000 mantém o valor constante, mas não pode mostrar a significância de duas casa do original.

Se uma aplicação não se importa com o rastreamento da significância, é fácil remover o expoente e os zeros à direita, perdendo a significância, mas mantendo o valor inalterado:

>>> def remove_exponent(d):
...     return d.quantize(Decimal(1)) if d == d.to_integral() else d.normalize()

>>> remove_exponent(Decimal('5E+3'))
Decimal('5000')

P. Existe uma maneira de converter um float comum em um Decimal?

R. Sim, qualquer número de ponto flutuante binário pode ser expresso exatamente como um Decimal, embora uma conversão exata possa exigir mais precisão do que a intuição sugere:

>>> Decimal(math.pi)
Decimal('3.141592653589793115997963468544185161590576171875')

P. Em um cálculo complexo, como posso ter certeza de que não obtive um resultado falso devido à precisão insuficiente ou a anomalias de arredondamento.

R. O módulo decimal facilita o teste de resultados. Uma prática recomendada é executar novamente os cálculos usando maior precisão e com vários modos de arredondamento. Resultados amplamente diferentes indicam precisão insuficiente, problemas no modo de arredondamento, entradas mal condicionadas ou um algoritmo numericamente instável.

P. Notei que a precisão do contexto é aplicada aos resultados das operações, mas não às entradas. Há algo a observar ao misturar valores de diferentes precisões?

R. Sim. O princípio é que todos os valores são considerados exatos, assim como a aritmética desses valores. Somente os resultados são arredondados. A vantagem das entradas é que “o que você vê é o que você obtém”. Uma desvantagem é que os resultados podem parecer estranhos se você esquecer que as entradas não foram arredondadas:

>>> getcontext().prec = 3
>>> Decimal('3.104') + Decimal('2.104')
Decimal('5.21')
>>> Decimal('3.104') + Decimal('0.000') + Decimal('2.104')
Decimal('5.20')

A solução é aumentar a precisão ou forçar o arredondamento das entradas usando a operação unária de mais:

>>> getcontext().prec = 3
>>> +Decimal('1.23456789')      # unary plus triggers rounding
Decimal('1.23')

Como alternativa, as entradas podem ser arredondadas na criação usando o método Context.create_decimal():

>>> Context(prec=5, rounding=ROUND_DOWN).create_decimal('1.2345678')
Decimal('1.2345')

P. A implementação do CPython é rápida para números grandes?

A. Sim. Nas implementações CPython e PyPy3, as versões C/CFFI do módulo decimal integram a biblioteca de alta velocidade libmpdec para precisão arbitrária de aritmética de ponto flutuante decimal corretamente arrendondado 1. libmpdec usa a multiplicação de Karatsuba para números com tamanho médio e a Transformada Numérica de Fourier para números muito grandes.

O contexto deve ser adaptado para uma aritmética exata de precisão arbitrária. Emin e Emax devem sempre ser configurados com os valores máximos, clamp deve sempre ser 0 (o padrão). A configuração de prec requer alguns cuidados.

A abordagem mais fácil para testar a aritmética do bignum é usar o valor máximo para prec também 2:

>>> setcontext(Context(prec=MAX_PREC, Emax=MAX_EMAX, Emin=MIN_EMIN))
>>> x = Decimal(2) ** 256
>>> x / 128
Decimal('904625697166532776746648320380374280103671755200316906558262375061821325312')

Para resultados inexatos, MAX_PREC é muito grande em plataformas de 64 bits e a memória disponível será insuficiente:

>>> Decimal(1) / 3
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
MemoryError

Em sistemas com alocação excessiva (por exemplo, Linux), uma abordagem mais sofisticada é ajustar prec à quantidade de RAM disponível. Suponha que você tenha 8 GB de RAM e espere 10 operandos simultâneos usando no máximo 500 MB cada:

>>> import sys
>>>
>>> # Maximum number of digits for a single operand using 500MB in 8-byte words
>>> # with 19 digits per word (4-byte and 9 digits for the 32-bit build):
>>> maxdigits = 19 * ((500 * 1024**2) // 8)
>>>
>>> # Check that this works:
>>> c = Context(prec=maxdigits, Emax=MAX_EMAX, Emin=MIN_EMIN)
>>> c.traps[Inexact] = True
>>> setcontext(c)
>>>
>>> # Fill the available precision with nines:
>>> x = Decimal(0).logical_invert() * 9
>>> sys.getsizeof(x)
524288112
>>> x + 2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  decimal.Inexact: [<class 'decimal.Inexact'>]

Em geral (e especialmente em sistemas sem alocação excessiva), recomenda-se estimar limites ainda mais apertados e definir a armadilha Inexact se for esperado que todos os cálculos sejam mais precisos.

1: Novo na versão 3.3.
2: Alterado na versão 3.9: Esta abordagem agora funciona para todos os resultados exatos, exceto para potências de números que não sejam inteiros.

`decimal` — Aritmética de ponto fixo decimal e ponto flutuante¶

Tutorial de início rápido¶

Objetos de Decimal¶

Operandos lógicos¶

Objetos de contexto¶

Constantes¶

Modos de arredondamento¶

Sinais¶

Observações sobre ponto flutuante¶

Atenuando o erro de arredondamento com maior precisão¶

Valores especiais¶

Trabalhando com threads¶

Receitas¶

FAQ sobre Decimal¶

Tabela de Conteúdo

Tópico anterior

Próximo tópico

Essa Página

decimal — Aritmética de ponto fixo decimal e ponto flutuante¶

Tutorial de início rápido¶

Objetos de Decimal¶

Operandos lógicos¶

Objetos de contexto¶

Constantes¶

Modos de arredondamento¶

Sinais¶

Observações sobre ponto flutuante¶

Atenuando o erro de arredondamento com maior precisão¶

Valores especiais¶

Trabalhando com threads¶

Receitas¶

FAQ sobre Decimal¶

`decimal` — Aritmética de ponto fixo decimal e ponto flutuante¶