Esta documentação é de uma versão antiga do Python que não é mais atualizada. Você deveria atualizar e ler a Documentação do Python para versão estável atual.

# `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.