decimal — Aritmética decimal de coma fija y coma flotante

Código fuente: Lib/decimal.py

---

The decimal module provides support for fast correctly rounded decimal floating point arithmetic. It offers several advantages over the float datatype:

• Decimal «se basa en un modelo de coma flotante que se diseñó pensando en las personas, y necesariamente tiene un principio rector supremo: las computadoras deben proporcionar una aritmética que funcione de la misma manera que la aritmética que las personas aprenden en la escuela.» – extracto (traducido) de la especificación de la aritmética decimal.

• Decimal numbers can be represented exactly. In contrast, numbers like 1.1 and 2.2 do not have exact representations in binary floating point. End users typically would not expect 1.1 + 2.2 to display as 3.3000000000000003 as it does with binary floating point.

• The exactness carries over into arithmetic. In decimal floating point, 0.1 + 0.1 + 0.1 - 0.3 is exactly equal to zero. In binary floating point, the result is 5.5511151231257827e-017. While near to zero, the differences prevent reliable equality testing and differences can accumulate. For this reason, decimal is preferred in accounting applications which have strict equality invariants.

• The decimal module incorporates a notion of significant places so that 1.30 + 1.20 is 2.50. The trailing zero is kept to indicate significance. This is the customary presentation for monetary applications. For multiplication, the «schoolbook» approach uses all the figures in the multiplicands. For instance, 1.3 * 1.2 gives 1.56 while 1.30 * 1.20 gives 1.5600.

• A diferencia del punto flotante binario basado en hardware, el módulo decimal tiene una precisión modificable por el usuario (por defecto es de 28 dígitos decimales) que puede ser tan grande como sea necesario para un problema dado:

  >>> from decimal import *
  >>> getcontext().prec = 6
  >>> Decimal(1) / Decimal(7)
  Decimal('0.142857')
  >>> getcontext().prec = 28
  >>> Decimal(1) / Decimal(7)
  Decimal('0.1428571428571428571428571429')
  

• Tanto la representación en coma flotante binaria como la decimal se implementan de acuerdo a estándares publicados. Mientras que el tipo float expone solo una pequeña parte de sus capacidades, el módulo decimal expone todos los componentes requeridos del estándar. Cuando es necesario, el desarrollador tiene control total sobre el redondeo y la gestión de las señales. Esto incluye la capacidad de forzar la aritmética exacta, utilizando excepciones para bloquear cualquier operación inexacta.

• El módulo decimal fue diseñado para admitir «indiscriminadamente, tanto aritmética decimal exacta sin redondeo (a veces llamada aritmética de coma fija) como la aritmética de coma flotante con redondeo.» – extracto (traducido) de la especificación de la aritmética decimal.

El módulo está diseñado en torno a tres conceptos: el número decimal, el contexto aritmético y las señales.

A decimal number is immutable. It has a sign, coefficient digits, and an exponent. To preserve significance, the coefficient digits do not truncate trailing zeros. Decimals also include special values such as Infinity, -Infinity, and NaN. The standard also differentiates -0 from +0.

El contexto aritmético es un entorno que permite especificar una precisión, reglas de redondeo, límites en los exponentes, flags que indican el resultado de las operaciones y habilitadores de trampas que especifican si las señales (reportadas durante operaciones ilegales) son tratadas o no como excepciones de Python. Las opciones de redondeo incluyen ROUND_CEILING, ROUND_DOWN, ROUND_FLOOR, ROUND_HALF_DOWN, ROUND_HALF_EVEN, ROUND_HALF_UP, ROUND_UP y ROUND_05UP.

Las señales son grupos de condiciones excepcionales que ocurren durante el cálculo. Dependiendo de las necesidades de la aplicación, las señales pueden ignorarse, tratarse como información o tratarse como excepciones. Las señales existentes en el módulo decimal son Clamped, InvalidOperation, DivisionByZero, Inexact, Rounded, Subnormal, Overflow, Underflow y FloatOperation.

Por cada señal hay un flag y un habilitador de trampa. Cuando ocurre una operación ilegal, su flag se establece en uno, luego, si su habilitador de trampa está establecido en uno, se lanza una excepción. La configuración de los flags es persistente, por lo que el usuario debe restablecerlos antes de comenzar un cálculo que desee monitorear.

Ver también

• IBM’s General Decimal Arithmetic Specification, The General Decimal Arithmetic Specification.

Tutorial de inicio rápido

El punto de partida habitual para usar decimales es importar el módulo, ver el contexto actual con getcontext() y, si es necesario, establecer nuevos valores para la precisión, el redondeo o trampas de señales habilitadas:

>>> 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

Decimal instances can be constructed from integers, strings, floats, or tuples. Construction from an integer or a float performs an exact conversion of the value of that integer or float. Decimal numbers include special values such as NaN which stands for «Not a number», positive and negative Infinity, and -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')

Si la señal FloatOperation es atrapada, la mezcla accidental de decimales y flotantes en constructores o comparaciones de orden lanzará una excepción:

>>> 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

Nuevo en la versión 3.3.

La significación de un nuevo objeto Decimal es determinada únicamente por el número de dígitos ingresados. La precisión y el redondeo establecidos en el contexto solo entran en juego durante las operaciones 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 lanza una excepción InvalidOperation si durante la construcción de un objeto Decimal se exceden los límites internos de la versión de C:

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

Distinto en la versión 3.3.

Los objetos Decimal interactúan bien con gran parte del resto de Python. Aquí hay un pequeño circo volador de punto flotante 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')

Y algunas funciones matemáticas también están disponibles para 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')

The quantize() method rounds a number to a fixed exponent. This method is useful for monetary applications that often round results to a fixed number of places:

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

Como se muestra arriba, la función getcontext() accede al contexto actual y permite cambiar la configuración. Este enfoque satisface las necesidades de la mayoría de las aplicaciones.

Para trabajos más avanzados, puede resultar útil crear contextos alternativos utilizando el constructor Context(). Para activar un contexto alternativo, usa la función setcontext().

De acuerdo con el estándar, el módulo decimal proporciona dos contextos estándar listos para usar, BasicContext y ExtendedContext. El primero es particularmente útil para la depuración, ya que muchas de las trampas de señales están habilitadas por defecto:

>>> 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

Contexts also have signal flags for monitoring exceptional conditions encountered during computations. The flags remain set until explicitly cleared, so it is best to clear the flags before each set of monitored computations by using the clear_flags() method.

>>> 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=[])

The flags entry shows that the rational approximation to pi was rounded (digits beyond the context precision were thrown away) and that the result is inexact (some of the discarded digits were non-zero).

Individual traps are set using the dictionary in the traps attribute of a context:

>>> 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

La mayoría de los programas ajustan el contexto actual una sola vez, al comienzo del programa. Y, en muchas aplicaciones, los datos se convierten a Decimal mediante una única conversión dentro de un bucle. Con el contexto establecido y los decimales creados, la mayor parte del programa manipula los datos de la misma forma que con otros tipos numéricos de Python.

Objetos Decimal

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

Construye un nuevo objeto Decimal basado en value.

value puede ser un entero, una cadena de caracteres, una tupla, un float u otro objeto Decimal. Si no se proporciona value, retorna Decimal('0'). Si value es una cadena, debe ajustarse a la sintaxis de cadena numérica decimal después de que los espacios en blanco iniciales y finales, así como los guiones bajos, sean eliminados:

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

También se permiten otros dígitos decimales Unicode en aquellos lugares en los que arriba aparece digit. Estos incluyen dígitos decimales de otros alfabetos (por ejemplo, dígitos del alfabeto árabe-índico y devanāgarī) junto con los dígitos de ancho completo desde '\uff10' a '\uff19'.

If value is a tuple, it should have three components, a sign (0 for positive or 1 for negative), a tuple of digits, and an integer exponent. For example, Decimal((0, (1, 4, 1, 4), -3)) returns Decimal('1.414').

Si value es un float, el valor binario de coma flotante se convierte sin pérdidas a su equivalente decimal exacto. Esta conversión a menudo puede requerir 53 o más dígitos de precisión. Por ejemplo, Decimal(float('1.1')) se convierte en Decimal('1.100000000000000088817841970012523233890533447265625').

La precisión de context no afecta a la cantidad de dígitos almacenados. Eso está determinado exclusivamente por el número de dígitos en value. Por ejemplo, Decimal('3.00000') registra los cinco ceros incluso si la precisión del contexto es solo tres.

The purpose of the context argument is determining what to do if value is a malformed string. If the context traps InvalidOperation, an exception is raised; otherwise, the constructor returns a new Decimal with the value of NaN.

Una vez construidos, los objetos Decimal son inmutables.

Distinto en la versión 3.2: Ahora se permite que el argumento del constructor sea una instancia float.

Distinto en la versión 3.3: Los argumentos float ahora generan una excepción si se establece la trampa FloatOperation. Por defecto, la trampa está desactivada.

Distinto en la versión 3.6: Se permiten guiones bajos para la agrupación, como ocurre en el código con los literales enteros y de punto flotante.

Los objetos de coma flotante decimal comparten muchas propiedades con los otros tipos numéricos integrados, como float e int. Se aplican todas las operaciones matemáticas habituales y los métodos especiales. Asimismo, los objetos decimales se pueden copiar, serializar con pickle, imprimir, usar como claves de un diccionario o como elementos de un conjunto, comparar, ordenar y convertir a otros tipos (como float o int).

Hay algunas pequeñas diferencias entre la aritmética en objetos decimales y la aritmética en enteros y flotantes. Cuando el operador de resto % se aplica a objetos Decimal, el signo del resultado es el signo del dividendo en lugar del signo del divisor:

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

El operador de división entera // se comporta de manera análoga, retornando la parte entera del cociente verdadero (truncando hacia cero) en lugar del resultado de aplicarle la función suelo. Esto se hace con la finalidad de preservar la identidad habitual x == (x // y) * y + x % y:

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

Los operadores % y // implementan las operaciones remainder y divide-integer (respectivamente) como se describe en la especificación.

Los objetos de la clase Decimal generalmente no se pueden combinar con flotantes o instancias de fractions.Fraction en operaciones aritméticas: un intento de agregar un objeto Decimal a un float, por ejemplo, lanzará una excepción TypeError. Sin embargo, es posible usar los operadores de comparación de Python para comparar una instancia de Decimal x con otro número y. Esto evita resultados confusos al hacer comparaciones de igualdad entre números de diferentes tipos.

Distinto en la versión 3.2: Las comparaciones de tipo mixto entre instancias de Decimal y otros tipos numéricos ahora son totalmente compatibles.

Además de las propiedades numéricas estándar, los objetos de coma flotante decimal también tienen varios métodos especializados:

adjusted()

Retorna el exponente ajustado después de desplazar los dígitos del extremo derecho del coeficiente hasta que solo quede el dígito principal: Decimal('321e+5').adjusted() retorna siete. Se utiliza para determinar la posición del dígito más significativo con respecto al punto decimal.

as_integer_ratio()

Retorna un par de enteros (n, d) que representan la instancia de Decimal proporcionada como una fracción irreducible y con un denominador positivo:

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

La conversión es exacta. Lanza una excepción OverflowError si se proporcionan valores infinitos y ValueError con valores NaN.

Nuevo en la versión 3.6.

as_tuple()

Retorna una representación en forma de named tuple del número: DecimalTuple(sign, digits, exponent).

canonical()

Retorna la codificación canónica del argumento. Actualmente, la codificación de una instancia de Decimal es siempre canónica, por lo que esta operación retorna su argumento sin cambios.

compare(other, context=None)

Compara los valores de dos instancias de Decimal. El método compare() retorna una instancia de Decimal, y si alguno de los operandos es un NaN, el resultado es un 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 operación es idéntica al método compare(), excepto que todos los valores NaN generan una señal. Es decir, si ninguno de los operandos es un NaN señalizador, cualquier operando de NaN silencioso se trata como si fuera un NaN señalizador.

compare_total(other, context=None)

Compara dos operandos utilizando su representación abstracta en lugar de su valor numérico. Similar al método compare(), pero el resultado proporciona un ordenamiento total en las instancias de Decimal. Dos instancias de Decimal con el mismo valor numérico, pero diferentes representaciones, se comparan como desiguales usando este orden:

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

Los NaN silenciosos y señalizadores también se incluyen en el ordenamiento total. El resultado de esta función es Decimal('0') si ambos operandos tienen la misma representación, Decimal('-1') si el primer operando es menor en el orden total que el segundo y Decimal('1') si el primer operando es mayor en el orden total que el segundo operando. Consulta las especificaciones para obtener detalles sobre el ordenamiento total.

Esta operación no se ve afectada por el contexto y es silenciosa: no se cambian los flags y no se realiza ningún redondeo. Como excepción, la versión de C puede lanzar InvalidOperation si el segundo operando no se puede convertir exactamente.

compare_total_mag(other, context=None)

Compara dos operandos usando su representación abstracta en lugar de su valor, como en compare_total(), pero ignorando el signo de cada operando. x.compare_total_mag(y) es equivalente a x.copy_abs().compare_total(y.copy_abs()).

Esta operación no se ve afectada por el contexto y es silenciosa: no se cambian los flags y no se realiza ningún redondeo. Como excepción, la versión de C puede lanzar InvalidOperation si el segundo operando no se puede convertir exactamente.

conjugate()

Simplemente retorna self (el propio objeto al que pertenece el método invocado). Este método existe solo para cumplir con la Especificación decimal.

copy_abs()

Retorna el valor absoluto del argumento. Esta operación no se ve afectada por el contexto y es silenciosa: no se modifican los flags y no se realiza ningún redondeo.

copy_negate()

Retorna la negación del argumento. Esta operación no se ve afectada por el contexto y es silenciosa: no se cambian los flags y no se realiza ningún redondeo.

copy_sign(other, context=None)

Retorna una copia del primer operando pero con el signo establecido para que sea el mismo que el del segundo operando. Por ejemplo:

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

Esta operación no se ve afectada por el contexto y es silenciosa: no se cambian los flags y no se realiza ningún redondeo. Como excepción, la versión de C puede lanzar InvalidOperation si el segundo operando no se puede convertir exactamente.

exp(context=None)

Retorna el valor de la función exponencial (natural) e**x en el número dado. El resultado es correctamente redondeado utilizando el modo de redondeo ROUND_HALF_EVEN.

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

classmethod from_float(f)

Alternative constructor that only accepts instances of float or int.

Note Decimal.from_float(0.1) is not the same as Decimal('0.1'). Since 0.1 is not exactly representable in binary floating point, the value is stored as the nearest representable value which is 0x1.999999999999ap-4. That equivalent value in decimal is 0.1000000000000000055511151231257827021181583404541015625.

Nota

Desde Python 3.2 en adelante, una instancia de Decimal también se puede construir directamente desde una instancia de 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')

Nuevo en la versión 3.1.

fma(other, third, context=None)

Fusión de la multiplicación y la suma. Retorna self*other+third sin redondeo del producto intermedio self*other.

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

is_canonical()

Retorna True si el argumento es canónico y False en caso contrario. Actualmente, una instancia de Decimal es siempre canónica, por lo que esta operación siempre retorna True.

is_finite()

Retorna True si el argumento es un número finito y False si el argumento es un valor infinito o un NaN.

is_infinite()

Retorna True si el argumento es un valor infinito positivo o negativo y False en caso contrario.

is_nan()

Retorna True si el argumento es un NaN (silencioso o señalizador) y False en caso contrario.

is_normal(context=None)

Retorna True si el argumento es un número finito normal. Retorna False si el argumento es cero, subnormal, infinito o un NaN.

is_qnan()

Retorna True si el argumento es un NaN silencioso y False en caso contrario.

is_signed()

Retorna True si el argumento tiene signo negativo y False en caso contrario. Ten en cuenta que tanto los ceros como los NaN pueden tener signo.

is_snan()

Retorna True si el argumento es un NaN señalizador y False en caso contrario.

is_subnormal(context=None)

Retorna True si el argumento es subnormal y False en caso contrario.

is_zero()

Retorna True si el argumento es un cero (positivo o negativo) y False en caso contrario.

ln(context=None)

Retorna el logaritmo natural (base e) del operando. El resultado es correctamente redondeado utilizando el modo de redondeo ROUND_HALF_EVEN.

log10(context=None)

Retorna el logaritmo en base diez del operando. El resultado es correctamente redondeado utilizando el modo de redondeo ROUND_HALF_EVEN.

logb(context=None)

Para un número distinto de cero, retorna el exponente ajustado de su operando como una instancia de Decimal. Si el operando es cero, se retorna Decimal('-Infinity') y se activa el flag DivisionByZero. Si el operando es infinito, se retorna Decimal('Infinity').

logical_and(other, context=None)

logic_and() es una operación lógica que toma dos operandos lógicos (consultar Operandos lógicos). El resultado es el and dígito por dígito de los dos operandos.

logical_invert(context=None)

logic_invert() es una operación lógica. El resultado es la inversión dígito a dígito del operando.

logical_or(other, context=None)

logical_or() es una operación lógica que toma dos operandos lógicos (consultar Operandos lógicos). El resultado es un or dígito a dígito de los dos operandos.

logical_xor(other, context=None)

logic_xor() es una operación lógica que toma dos operandos lógicos (consultar Operandos lógicos). El resultado es la disyunción exclusiva («exclusive or») dígito a dígito de ambos operandos.

max(other, context=None)

Like max(self, other) except that the context rounding rule is applied before returning and that NaN values are either signaled or ignored (depending on the context and whether they are signaling or quiet).

max_mag(other, context=None)

Similar al método max(), pero la comparación se realiza utilizando los valores absolutos de los operandos.

min(other, context=None)

Like min(self, other) except that the context rounding rule is applied before returning and that NaN values are either signaled or ignored (depending on the context and whether they are signaling or quiet).

min_mag(other, context=None)

Similar al método min(), pero la comparación se realiza utilizando los valores absolutos de los operandos.

next_minus(context=None)

Retorna el número más grande representable en el contexto proporcionado (o en el contexto del hilo actual si no se proporciona un contexto) que sea más pequeño que el operando proporcionado.

next_plus(context=None)

Retorna el número más pequeño representable en el contexto proporcionado (o en el contexto del hilo actual si no se proporciona ningún contexto) que sea más grande que el operando proporcionado.

next_toward(other, context=None)

Si los dos operandos no son iguales, retorna el número más cercano al primer operando en la dirección del segundo operando. Si ambos operandos son numéricamente iguales, retorna una copia del primer operando con el signo establecido para que sea el mismo que el signo del segundo operando.

normalize(context=None)

Normalize the number by stripping the rightmost trailing zeros and converting any result equal to Decimal('0') to Decimal('0e0'). Used for producing canonical values for attributes of an equivalence class. For example, Decimal('32.100') and Decimal('0.321000e+2') both normalize to the equivalent value Decimal('32.1').

number_class(context=None)

Retorna una cadena de caracteres que describe la class del operando. El valor retornado es una de las siguientes diez cadenas de caracteres.

• "-Infinity", que indica que el operando es un infinito negativo.

• "-Normal", que indica que el operando es un número normal negativo.

• "-Subnormal", que indica que el operando es negativo y subnormal.

• "-Zero", que indica que el operando es un cero negativo.

• "+Zero", que indica que el operando es un cero positivo.

• "+Subnormal",que indica que el operando es positivo y subnormal.

• "+Normal", que indica que el operando es un número normal positivo.

• "+Infinity", que indica que el operando es un infinito positivo.

• "NaN", que indica que el operando es un NaN (no es un número) silencioso.

• "sNaN", que indica que el operando es un NaN (no es un número) señalizador.

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

Retorna un valor igual al primer operando después de ser redondeado y de asignarle el exponente del segundo operando.

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

A diferencia de otras operaciones, se genera una señal InvalidOperation si la longitud del coeficiente después de la operación quantize es mayor que la precisión. Esto garantiza que, a menos que exista una condición de error, el exponente cuantificado sea siempre igual al del operando de la derecha.

Además, a diferencia de otras operaciones, quantize nunca genera una señal Underflow, incluso si el resultado es subnormal e inexacto.

Si el exponente del segundo operando es mayor que el del primero, puede ser necesario redondear. En este caso, el modo de redondeo está determinado por el argumento rounding, si se proporciona, o por el argumento context en caso contrario. Si no se proporciona ninguno de estos dos argumentos, se utiliza el modo de redondeo establecido en el contexto del hilo actual.

An error is returned whenever the resulting exponent is greater than Emax or less than Etiny().

radix()

Retorna Decimal(10), que es la raíz (base) en la que la clase Decimal hace toda su aritmética. Este método está incluido solo por compatibilidad con la especificación.

remainder_near(other, context=None)

Retorna el resto de dividir self entre other. Esto difiere de la operación self%other, en la que el signo del resto se elige para minimizar su valor absoluto. Más precisamente, el valor de retorno es self - n * other, donde n es el número entero más cercano al valor exacto de self / other. Si dos enteros están igualmente cerca, entonces el valor par es el elegido.

Si el resultado es cero, entonces su signo será el signo 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 el resultado de rotar los dígitos del primer operando en una cantidad especificada por el segundo operando. El segundo operando debe ser un número entero en el rango comprendido desde -precisión hasta precisión. El valor absoluto del segundo operando da el número de lugares a rotar. Si el segundo operando es positivo, la rotación es hacia la izquierda; de lo contrario, la rotación es hacia la derecha. El coeficiente del primer operando se rellena con ceros a la izquierda para satisfacer la precisión de longitud si es necesario. El signo y el exponente del primer operando no se modifican.

same_quantum(other, context=None)

Test whether self and other have the same exponent or whether both are NaN.

Esta operación no se ve afectada por el contexto y es silenciosa: no se cambian los flags y no se realiza ningún redondeo. Como excepción, la versión de C puede lanzar InvalidOperation si el segundo operando no se puede convertir exactamente.

scaleb(other, context=None)

Retorna el primer operando con su exponente ajustado por el segundo. De manera equivalente, retorna el primer operando multiplicado por 10**other. El segundo operando debe ser un número entero.

shift(other, context=None)

Retorna el resultado de cambiar los dígitos del primer operando en una cantidad especificada por el segundo operando. El segundo operando debe ser un número entero en el rango comprendido desde -precisión hasta precisión. El valor absoluto del segundo operando da el número de lugares a desplazar. Si el segundo operando es positivo, el desplazamiento es hacia la izquierda; de lo contrario, el desplazamiento es hacia la derecha. Los dígitos desplazados en el coeficiente son ceros. El signo y el exponente del primer operando no se modifican.

sqrt(context=None)

Retorna la raíz cuadrada del argumento con precisión total.

to_eng_string(context=None)

Convierte a una cadena de caracteres, usando notación de ingeniería si se necesita un exponente.

La notación de ingeniería tiene como exponente un múltiplo de 3. Esto puede dejar hasta 3 dígitos a la izquierda del punto decimal y puede requerir la adición de uno o dos ceros finales.

Por ejemplo, este método convierte Decimal('123E+1') en Decimal('1.23E+3').

to_integral(rounding=None, context=None)

Idéntico al método to_integral_value(). El nombre to_integral se ha mantenido por compatibilidad con versiones anteriores.

to_integral_exact(rounding=None, context=None)

Redondea al entero más cercano, generando la señal Inexact o Rounded, según corresponda, si se produce un redondeo. El modo de redondeo está determinado por el parámetro rounding si es proporcionado, o por el establecido en el context proporcionado en caso contrario. Si no se proporciona ninguno de estos dos parámetros, se utiliza el modo de redondeo establecido en el contexto actual.

to_integral_value(rounding=None, context=None)

Redondea al entero más cercano sin generar la señal Inexact o Rounded. Si se proporciona, se aplica el método de redondeo especificado por rounding; en caso contrario, se utiliza el método de redondeo del context proporcionado o el del contexto actual.

Operandos lógicos

The logical_and(), logical_invert(), logical_or(), and logical_xor() methods expect their arguments to be logical operands. A logical operand is a Decimal instance whose exponent and sign are both zero, and whose digits are all either 0 or 1.

Objetos Context

Los contextos son entornos para operaciones aritméticas. Gobiernan la precisión, establecen reglas para el redondeo, determinan qué señales se tratan como excepciones y limitan el rango para los exponentes.

Cada hilo tiene su propio contexto actual, al que se accede o se reemplaza usando las funciones getcontext() y setcontext() respectivamente:

decimal.getcontext()

Retorna el contexto actual del hilo activo.

decimal.setcontext(c)

Establece c como contexto actual para el hilo activo.

También puedes usar la declaración with y la función localcontext() para cambiar temporalmente el contexto activo.

decimal.localcontext(ctx=None)

Retorna un gestor de contexto que establecerá el contexto actual para el hilo activo en una copia de ctx al ingresar en la declaración with y restaurará el contexto anterior al salir de la misma. Si no se especifica ningún contexto, se utiliza una copia del contexto actual.

Por ejemplo, el siguiente código establece la precisión decimal actual en 42 lugares, realiza un cálculo y luego restaura automáticamente el 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

También se pueden crear nuevos contextos utilizando el constructor de la clase Context que se describe a continuación. Además, el módulo proporciona tres contextos prediseñados:

class decimal.BasicContext

Este es un contexto estándar definido por la Especificación general de la aritmética decimal. La precisión se establece en nueve. El redondeo se establece en ROUND_HALF_UP. Se restablecen todos los flags. Todas las trampas están habilitadas (las señales son tratadas como excepciones) excepto Inexact, Rounded y Subnormal.

Debido a que la mayoría de las trampas están habilitadas, este contexto es especialmente útil para la depuración.

class decimal.ExtendedContext

Este es un contexto estándar definido por la Especificación general de la aritmética decimal. La precisión se establece en nueve. El redondeo se establece en ROUND_HALF_EVEN. Se restablecen todos los flags. No se habilitan trampas (para que no se generen excepciones durante los cálculos).

Because the traps are disabled, this context is useful for applications that prefer to have result value of NaN or Infinity instead of raising exceptions. This allows an application to complete a run in the presence of conditions that would otherwise halt the program.

class decimal.DefaultContext

Este contexto es utilizado por el constructor de la clase Context como un prototipo para nuevos contextos. Cambiar un campo (como la precisión) tiene el efecto de cambiar el valor predeterminado para los nuevos contextos creados por el constructor de Context.

Este contexto es más útil en entornos con múltiples hilos. Cambiar uno de los campos antes de que se inicien los hilos tiene el efecto de establecer valores predeterminados en todo el sistema. No se recomienda cambiar los campos después de que se hayan iniciado los hilos, ya que requeriría el uso de mecanismos de sincronización para evitar condiciones de carrera entre los hilos.

En entornos de un solo hilo, es preferible no utilizar este contexto en absoluto. En su lugar, simplemente crea contextos explícitamente como se describe a continuación.

The default values are Context.prec=28, Context.rounding=ROUND_HALF_EVEN, and enabled traps for Overflow, InvalidOperation, and DivisionByZero.

Además de los tres contextos proporcionados, se pueden crear nuevos contextos mediante el constructor de la clase Context.

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

Crea un nuevo contexto. Si no se especifica un campo, o es None, los valores predeterminados se copian de DefaultContext. Si el campo flags no está especificado, o es None, se restablecen todas los flags.

prec is an integer in the range [1, MAX_PREC] that sets the precision for arithmetic operations in the context.

La opción rounding es una de las constantes enumeradas en la sección Rounding Modes.

Los campos traps y flags enumeran las señales que se deben establecer. Generalmente, los nuevos contextos solo deben establecer trampas y dejar los flags sin establecer.

The Emin and Emax fields are integers specifying the outer limits allowable for exponents. Emin must be in the range [MIN_EMIN, 0], Emax in the range [0, MAX_EMAX].

The capitals field is either 0 or 1 (the default). If set to 1, exponents are printed with a capital E; otherwise, a lowercase e is used: Decimal('6.02e+23').

The clamp field is either 0 (the default) or 1. If set to 1, the exponent e of a Decimal instance representable in this context is strictly limited to the range Emin - prec + 1 <= e <= Emax - prec + 1. If clamp is 0 then a weaker condition holds: the adjusted exponent of the Decimal instance is at most Emax. When clamp is 1, a large normal number will, where possible, have its exponent reduced and a corresponding number of zeros added to its coefficient, in order to fit the exponent constraints; this preserves the value of the number but loses information about significant trailing zeros. For example:

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

A clamp value of 1 allows compatibility with the fixed-width decimal interchange formats specified in IEEE 754.

The Context class defines several general purpose methods as well as a large number of methods for doing arithmetic directly in a given context. In addition, for each of the Decimal methods described above (with the exception of the adjusted() and as_tuple() methods) there is a corresponding Context method. For example, for a Context instance C and Decimal instance x, C.exp(x) is equivalent to x.exp(context=C). Each Context method accepts a Python integer (an instance of int) anywhere that a Decimal instance is accepted.

clear_flags()

Resets all of the flags to 0.

clear_traps()

Resets all of the traps to 0.

Nuevo en la versión 3.3.

copy()

Retorna un duplicado del contexto.

copy_decimal(num)

Retorna una copia de la instancia de Decimal num.

create_decimal(num)

Crea una nueva instancia de Decimal a partir de num pero usando self como contexto. A diferencia del constructor de Decimal, la precisión del contexto, el método de redondeo, los flags y las trampas se aplican a la conversión.

Esto es útil porque las constantes a menudo se proporcionan con una precisión mayor que la que necesita la aplicación. Otro beneficio es que el redondeo elimina inmediatamente los efectos no deseados de los dígitos más allá de la precisión actual. En el siguiente ejemplo, usar entradas no redondeadas significa que agregar cero a una suma puede cambiar el 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 la operación to-number de la especificación de IBM. Si el argumento es una cadena de caracteres, no se permiten espacios en blanco ni guiones bajos, ni al principio ni al final.

create_decimal_from_float(f)

Crea una nueva instancia de Decimal a partir de un flotante f, pero redondeando usando self como contexto. A diferencia del método de clase Decimal.from_float(), la precisión del contexto, el método de redondeo, los flags y las trampas se aplican a la conversión.

>>> 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

Nuevo en la versión 3.1.

Etiny()

Retorna un valor igual a Emin - prec + 1 que es el valor mínimo del exponente para resultados subnormales. Cuando ocurre un desbordamiento numérico negativo («underflow»), el exponente se establece en Etiny.

Etop()

Retorna un valor igual a Emax - prec + 1.

El enfoque habitual para trabajar con decimales es crear instancias de la clase Decimal y luego aplicar operaciones aritméticas que tienen lugar dentro del contexto actual para el hilo activo. Un enfoque alternativo es utilizar métodos de contexto para calcular dentro de un contexto específico. Los métodos son similares a los de la clase Decimal y aquí solo se relatan brevemente.

abs(x)

Retorna el valor absoluto de x.

add(x, y)

Retorna la suma de x e y.

canonical(x)

Retorna el mismo objeto Decimal x.

compare(x, y)

Compara x e y numéricamente.

compare_signal(x, y)

Compara los valores de los dos operandos numéricamente.

compare_total(x, y)

Compara los dos operandos utilizando su representación abstracta.

compare_total_mag(x, y)

Compara los dos operandos utilizando su representación abstracta, ignorando el signo.

copy_abs(x)

Retorna una copia de x con el signo establecido en 0.

copy_negate(x)

Retorna una copia de x con el signo invertido.

copy_sign(x, y)

Copia el signo de y en x.

divide(x, y)

Retorna x dividido entre y.

divide_int(x, y)

Retorna x dividido entre y, truncando el resultado a un número entero.

divmod(x, y)

Divide dos números y retorna la parte entera del resultado.

exp(x)

Returns e ** x.

fma(x, y, z)

Retorna x multiplicado por y, más z.

is_canonical(x)

Retorna True si x está en forma canónica, en caso contrario retorna False.

is_finite(x)

Retorna True si x es un valor finito, en caso contrario retorna False.

is_infinite(x)

Retorna True si x es un valor infinito, en caso contrario retorna False.

is_nan(x)

Retorna True si x es un valor qNaN o sNaN , en caso contrario retorna False.

is_normal(x)

Retorna True si x es un número normal, en caso contrario retorna False.

is_qnan(x)

Retorna True si x es un NaN silencioso, en caso contrario retorna False.

is_signed(x)

Retorna True si x es un valor negativo, en caso contrario retorna False.

is_snan(x)

Retorna True si x es un NaN señalizador, en caso contrario retorna False.

is_subnormal(x)

Retorna True si x es un número subnormal, en caso contrario retorna False.

is_zero(x)

Retorna True si x es un cero, en caso contrario retorna False.

ln(x)

Retorna el logaritmo natural (base e) de x.

log10(x)

Retorna el logaritmo en base 10 de x.

logb(x)

Retorna el exponente de la magnitud del MSD («dígito más significativo») del operando.

logical_and(x, y)

Aplica la operación lógica and entre los dígitos de cada operando.

logical_invert(x)

Invierte todos los dígitos en x.

logical_or(x, y)

Aplica la operación lógica or entre los dígitos de cada operando.

logical_xor(x, y)

Aplica la operación lógica xor entre los dígitos de cada operando.

max(x, y)

Compara dos valores numéricamente y retorna el mayor de ellos.

max_mag(x, y)

Compara los valores numéricamente ignorando sus signos.

min(x, y)

Compara dos valores numéricamente y retorna el menor de ellos.

min_mag(x, y)

Compara los valores numéricamente ignorando sus signos.

minus(x)

Se corresponde con el operador unario de resta (prefijo) de Python.

multiply(x, y)

Retorna el producto de x por y.

next_minus(x)

Retorna el número más grande representable menor que x.

next_plus(x)

Retorna el número más pequeño representable mayor que x.

next_toward(x, y)

Retorna el número más cercano a x, en la dirección de y.

normalize(x)

Reduce x a su forma más simple.

number_class(x)

Retorna una cadena de caracteres indicando la clase de x.

plus(x)

Se corresponde con el operador unario de suma (prefijo) de Python. Esta operación aplica la precisión y el redondeo establecidos en el contexto, por lo que no es una operación de identidad.

power(x, y, modulo=None)

Retorna x elevado a la potencia y, reconduciendo al módulo modulo si se proporciona.

With two arguments, compute x**y. If x is negative then y must be integral. The result will be inexact unless y is integral and the result is finite and can be expressed exactly in “precision” digits. The rounding mode of the context is used. Results are always correctly rounded in the Python version.

Decimal(0) ** Decimal(0) da como resultado InvalidOperation, y si InvalidOperation no es atrapada, entonces da como resultado Decimal('NaN').

Distinto en la versión 3.3: The C module computes power() in terms of the correctly rounded exp() and ln() functions. The result is well-defined but only «almost always correctly rounded».

Con tres argumentos, calcula (x**y) % modulo. Para la forma de tres argumentos, se mantienen las siguientes restricciones sobre los argumentos:

• los tres argumentos deben ser enteros

• y debe ser un valor no negativo

• al menos uno, x o y , no debe ser cero

• modulo no debe ser cero y tener como mínimo los dígitos de la “precisión”

El valor resultante de Context.power(x, y, modulo) es igual al valor que se obtendría calculando (x**y) % modulo con precisión ilimitada, la diferencia es que se calcula de manera más eficiente . El exponente del resultado es cero, independientemente de los exponentes de x, y y modulo. El resultado siempre es exacto.

quantize(x, y)

Retorna un valor igual a x (redondeado), pero que tiene el exponente de y.

radix()

Simplemente retorna 10, ya que es Decimal, :)

remainder(x, y)

Retorna el resto de la división entera.

El signo del resultado, si no es cero, es el mismo que el del dividendo original.

remainder_near(x, y)

Retorna x - y * n, donde n es el número entero más cercano al valor exacto de x / y (si el resultado es 0, entonces su signo será el signo de x).

rotate(x, y)

Retorna una copia de x rotada y veces.

same_quantum(x, y)

Retorna True si los dos operandos tienen el mismo exponente.

scaleb(x, y)

Retorna el primer operando después de agregar el segundo valor a su exponente.

shift(x, y)

Retorna una copia de x desplazada y veces.

sqrt(x)

Retorna la raíz cuadrada de un número no negativo para la precisión del contexto.

subtract(x, y)

Retorna la diferencia entre x e y.

to_eng_string(x)

Convierte a una cadena de caracteres, usando notación de ingeniería si se necesita un exponente.

La notación de ingeniería tiene como exponente un múltiplo de 3. Esto puede dejar hasta 3 dígitos a la izquierda del punto decimal y puede requerir la adición de uno o dos ceros finales.

to_integral_exact(x)

Redondea a un entero.

to_sci_string(x)

Convierte un número en una cadena de caracteres usando notación científica.

Constantes

Las constantes detalladas en esta sección solo son relevantes para el módulo de C. Se incluyen también en la versión pura de Python por compatibilidad.

	32-bit	64-bit
decimal.MAX_PREC	425000000	999999999999999999
decimal.MAX_EMAX	425000000	999999999999999999
decimal.MIN_EMIN	-425000000	-999999999999999999
decimal.MIN_ETINY	-849999999	-1999999999999999997

decimal.HAVE_THREADS

El valor es True. Está obsoleta, debido ha que Python ahora siempre tiene soporte para hilos.

Obsoleto desde la versión 3.9.

decimal.HAVE_CONTEXTVAR

El valor predeterminado es True. Si Python se configura usando --without-decimal-contextvar, la versión de C usa un contexto de hilos-locales en lugar de un contexto de corrutinas-locales y el valor de la constante es False. Esto es algo más rápido en algunos escenarios de contexto anidado.

Nuevo en la versión 3.9: retro-portado a las versiones 3.7 y 3.8.

Modos de redondeo

decimal.ROUND_CEILING

Round towards Infinity.

decimal.ROUND_DOWN

Redondear hacia cero.

decimal.ROUND_FLOOR

Round towards -Infinity.

decimal.ROUND_HALF_DOWN

Redondear al valor contiguo más cercano, con empates hacia cero.

decimal.ROUND_HALF_EVEN

Redondear al valor contiguo más cercano, con empates al entero par contiguo.

decimal.ROUND_HALF_UP

Redondear al valor contiguo más cercano, con empates alejándose de cero.

decimal.ROUND_UP

Redondear alejándose de cero.

decimal.ROUND_05UP

Si el último dígito después de redondear hacia cero es 0 ó 5, redondear alejándose de cero, en caso contrario, redondear hacia cero.

Señales

Las señales representan condiciones que surgen durante el cálculo. Cada una se corresponde con un solo flag de contexto y un habilitador de trampas de contexto.

El flag de contexto se establece siempre que se encuentra la condición. Después del cálculo, los flags pueden comprobarse con fines informativos (por ejemplo, para determinar si un cálculo fue exacto). Después de verificar los flags, asegúrate de borrarlos antes de comenzar con el siguiente cálculo.

Si el habilitador de trampas del contexto está configurado para la señal, entonces la condición hace que se lance una excepción de Python. Por ejemplo, si se establece la trampa DivisionByZero, se genera una excepción DivisionByZero al encontrar la condición.

class decimal.Clamped

Cambia un exponente para ajustar las restricciones de representación.

Typically, clamping occurs when an exponent falls outside the context’s Emin and Emax limits. If possible, the exponent is reduced to fit by adding zeros to the coefficient.

class decimal.DecimalException

Clase base para otras señales. Es una subclase de ArithmeticError.

class decimal.DivisionByZero

Señala la división de un número no infinito entre cero.

Can occur with division, modulo division, or when raising a number to a negative power. If this signal is not trapped, returns Infinity or -Infinity with the sign determined by the inputs to the calculation.

class decimal.Inexact

Indica que se produjo un redondeo y el resultado no es exacto.

Señala que se descartaron dígitos distintos de cero durante el redondeo. Se retorna el resultado redondeado. El flag o la trampa de señal se utiliza para detectar cuando los resultados son inexactos.

class decimal.InvalidOperation

Señala que se realizó una operación no válida.

Indicates that an operation was requested that does not make sense. If not trapped, returns NaN. Possible causes include:

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

Desbordamiento numérico.

Indicates the exponent is larger than Context.Emax after rounding has occurred. If not trapped, the result depends on the rounding mode, either pulling inward to the largest representable finite number or rounding outward to Infinity. In either case, Inexact and Rounded are also signaled.

class decimal.Rounded

Se produjo un redondeo, aunque posiblemente no hubo pérdida de información.

Signaled whenever rounding discards digits; even if those digits are zero (such as rounding 5.00 to 5.0). If not trapped, returns the result unchanged. This signal is used to detect loss of significant digits.

class decimal.Subnormal

Exponent was lower than Emin prior to rounding.

Ocurre cuando el resultado de una operación es subnormal (el exponente es demasiado pequeño). Si no está atrapada, se retorna el resultado sin cambios.

class decimal.Underflow

Desbordamiento numérico negativo con resultado redondeado a cero.

Ocurre cuando un resultado subnormal se lleva a cero mediante redondeo. Inexact y Subnormal también se señalan.

class decimal.FloatOperation

Habilita una semántica más estricta para mezclar flotantes y objetos Decimal.

Si la señal no está atrapada (predeterminado), se permite mezclar flotantes y objetos Decimal en el constructor de Decimal, en el método create_decimal() y en todos los operadores de comparación. Tanto la conversión como las comparaciones son exactas. Cualquier ocurrencia de una operación mixta se registra silenciosamente estableciendo FloatOperation a los flags del contexto. Las conversiones explícitas usando from_float() o create_decimal_from_float() no establecen el flag.

En caso contrario (la señal está atrapada), solo las comparaciones de igualdad y las conversiones explícitas permanecen silenciadas. Todas las demás operaciones mixtas lanzan una excepción FloatOperation.

La siguiente tabla resume la jerarquía de señales:

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)

Notas sobre la representación en coma flotante

Mitigación del error de redondeo usando mayor precisión

The use of decimal floating point eliminates decimal representation error (making it possible to represent 0.1 exactly); however, some operations can still incur round-off error when non-zero digits exceed the fixed precision.

Los efectos del error de redondeo pueden amplificarse mediante la suma o resta de cantidades casi compensadas, lo que da como resultado una pérdida de significación. Knuth proporciona dos ejemplos instructivos en los que la aritmética de coma flotante redondeada con precisión insuficiente provoca la ruptura de las propiedades asociativas y distributivas de la suma:

# 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')

El módulo decimal permite restaurar las identidades ampliando la precisión lo suficiente para evitar la pérdida de significación:

>>> 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 especiales

The number system for the decimal module provides special values including NaN, sNaN, -Infinity, Infinity, and two zeros, +0 and -0.

Los infinitos se pueden construir directamente con Decimal('Infinity'). Además, pueden surgir al dividir entre cero cuando la señal DivisionByZero no es interceptada. Asimismo, cuando la señal Overflow no es interceptada, un infinito puede resultar del redondeo más allá de los límites del mayor número representable.

Los infinitos tienen signo (afín) y se pueden usar en operaciones aritméticas donde se tratan como números muy grandes e indeterminados. Por ejemplo, adicionar una constante a infinito resulta en otro infinito.

Some operations are indeterminate and return NaN, or if the InvalidOperation signal is trapped, raise an exception. For example, 0/0 returns NaN which means «not a number». This variety of NaN is quiet and, once created, will flow through other computations always resulting in another NaN. This behavior can be useful for a series of computations that occasionally have missing inputs — it allows the calculation to proceed while flagging specific results as invalid.

A variant is sNaN which signals rather than remaining quiet after every operation. This is a useful return value when an invalid result needs to interrupt a calculation for special handling.

The behavior of Python’s comparison operators can be a little surprising where a NaN is involved. A test for equality where one of the operands is a quiet or signaling NaN always returns False (even when doing Decimal('NaN')==Decimal('NaN')), while a test for inequality always returns True. An attempt to compare two Decimals using any of the <, <=, > or >= operators will raise the InvalidOperation signal if either operand is a NaN, and return False if this signal is not trapped. Note that the General Decimal Arithmetic specification does not specify the behavior of direct comparisons; these rules for comparisons involving a NaN were taken from the IEEE 854 standard (see Table 3 in section 5.7). To ensure strict standards-compliance, use the compare() and compare_signal() methods instead.

Los ceros con signo pueden resultar de cálculos que desbordan la precisión establecida. Mantienen el signo que habría resultado si el cálculo se hubiera realizado con mayor precisión. Dado que su magnitud es cero, los ceros positivos y negativos se tratan como iguales y su signo es solo informativo.

Además de los dos ceros con signo, que son distintos pero iguales, hay varias representaciones del cero con diferente precisión pero equivalentes en valor. Esto requiere de algo de tiempo para acostumbrarse. Para un ojo habituado a las representaciones normalizadas de coma flotante, no es inmediatamente obvio que el siguiente cálculo retorne un valor igual a cero:

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

Trabajando con hilos

La función getcontext() accede a un objeto Context diferente para cada hilo. Tener contextos de hilo separados significa que los hilos pueden realizar cambios (como getcontext().prec=10) sin interferir con otros hilos.

Asimismo, la función setcontext() asigna automáticamente su objetivo al hilo actual.

Si setcontext() no ha sido invocada antes de getcontext(), entonces getcontext() creará automáticamente un nuevo contexto para usar en el hilo actual.

El nuevo contexto es copiado a partir de un contexto prototipo llamado DefaultContext. Modifica directamente el objeto DefaultContext para controlar los valores predeterminados, de modo que cada hilo utilice los mismos valores en toda la aplicación. Esto debe hacerse antes de que se inicien los hilos, para evitar que tenga lugar una condición de carrera entre los mismos al invocar a getcontext(). Por ejemplo:

# 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()
 . . .

Casos prácticos

A continuación hay algunos casos prácticos que sirven como funciones de utilidad y que muestran formas de trabajar con la clase 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

Preguntas frecuentes sobre Decimal

P. Es engorroso escribir decimal.Decimal('1234.5'). ¿Hay alguna forma de minimizar la escritura cuando se usa el intérprete interactivo?

R. Algunos usuarios abrevian el constructor a una sola letra:

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

P. En una aplicación de coma fija con dos decimales, algunas entradas tienen muchos dígitos decimales y deben redondearse. En cambio, otras no tienen dígitos en exceso y deben ser validadas. ¿Qué métodos deben utilizarse?

A. The quantize() method rounds to a fixed number of decimal places. If the Inexact trap is set, it is also useful for validation:

>>> 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. Si tengo entradas validadas con dos dígitos decimales, ¿cómo mantengo eso invariante en una aplicación?

A. Some operations like addition, subtraction, and multiplication by an integer will automatically preserve fixed point. Others operations, like division and non-integer multiplication, will change the number of decimal places and need to be followed-up with a quantize() step:

>>> 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')

In developing fixed-point applications, it is convenient to define functions to handle the quantize() step:

>>> 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')

Q. There are many ways to express the same value. The numbers 200, 200.000, 2E2, and .02E+4 all have the same value at various precisions. Is there a way to transform them to a single recognizable canonical value?

A. The normalize() method maps all equivalent values to a single representative:

>>> 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. Algunos valores decimales siempre se imprimen usando notación exponencial. ¿Hay alguna forma de obtener una representación no exponencial?

A. For some values, exponential notation is the only way to express the number of significant places in the coefficient. For example, expressing 5.0E+3 as 5000 keeps the value constant but cannot show the original’s two-place significance.

Si una aplicación no necesita preocuparse por el seguimiento de significación, es fácil eliminar el exponente y los ceros finales, perdiendo significación, pero manteniendo el valor sin cambios:

>>> 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. ¿Hay alguna forma de convertir un flotante regular en un Decimal?

R. Sí, cualquier número de coma flotante binario se puede expresar exactamente mediante un Decimal, aunque una conversión exacta puede requerir más precisión de la que sugiere la intuición:

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

P. Dentro de un cálculo complejo, cómo puedo asegurarme de que no he obtenido un resultado adulterado debido a una precisión insuficiente o anomalías de redondeo.

R. El módulo decimal facilita la comprobación de resultados. Una buena práctica es volver a ejecutar los cálculos con mayor precisión y con varios modos de redondeo. La obtención de resultados muy dispares indica una precisión insuficiente, problemas relacionados con el modo de redondeo, entradas mal acondicionadas o un algoritmo numéricamente inestable.

P. Noté que la precisión del contexto se aplica a los resultados de las operaciones pero no a las entradas. ¿Hay algo a tener en cuenta al mezclar valores con distintas precisiones?

R. Sí. El principio es que todos los valores se consideran exactos y también lo es la aritmética de esos valores. Solo se redondean los resultados. La ventaja para las entradas es que «lo que escribes es lo que obtienes». Una desventaja es que los resultados pueden parecer extraños si olvidas que las entradas no se han redondeado:

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

La solución es aumentar la precisión o forzar el redondeo de las entradas utilizando la operación unaria más:

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

Alternativamente, las entradas se pueden redondear en el momento que se crean usando el método Context.create_decimal():

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

P. ¿La implementación de CPython es rápida para números grandes?

A. Yes. In the CPython and PyPy3 implementations, the C/CFFI versions of the decimal module integrate the high speed libmpdec library for arbitrary precision correctly rounded decimal floating point arithmetic 1. libmpdec uses Karatsuba multiplication for medium-sized numbers and the Number Theoretic Transform for very large numbers.

The context must be adapted for exact arbitrary precision arithmetic. Emin and Emax should always be set to the maximum values, clamp should always be 0 (the default). Setting prec requires some care.

The easiest approach for trying out bignum arithmetic is to use the maximum value for prec as well 2:

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

Para resultados inexactos, MAX_PREC es demasiado grande en plataformas de 64 bits y la memoria disponible será insuficiente:

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

On systems with overallocation (e.g. Linux), a more sophisticated approach is to adjust prec to the amount of available RAM. Suppose that you have 8GB of RAM and expect 10 simultaneous operands using a maximum of 500MB each:

>>> 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'>]

En general (y especialmente en sistemas sin sobreasignación), se recomienda estimar límites aún más estrictos y establecer la trampa Inexact si se espera que todos los cálculos sean exactos.

1

Nuevo en la versión 3.3.

2

Distinto en la versión 3.9: Este enfoque ahora funciona para todos los resultados exactos excepto para las potencias no enteras. También retro-portado a 3.7 y 3.8.