Класс Decimal() модуля decimal в Python.

Создать/преобразовать значение в десятичное число.

Синтаксис:

import decimal

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

Параметры:

value='0' - значение,
context=None - контекст вычислений.

Возвращаемое значение:

новый десятичный объект.

Описание:

Класс Decimal() модуля decimal число (объект) типа decimal.Decimal() из указанного значения в параметре value. По умолчанию value='0'. После создания десятичные объекты являются неизменными.

Объекты типа decimal.Decimal() обладают множеством специализированных методов.

Аргумент value может быть число типа int, float, кортеж или другой объект типа Decimal. Так же это значение может быть строкой, но ее содержание должно соответствовать синтаксису записи чисел типа Decimal.

Допустимыми подстроками являются символы знака: '-' и '+'; символы цифр: '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'; строки специальных значений: 'Infinity', 'Inf', 'NaN', 'Nan', 'sNaN', 'sNan'. А сами строки могут иметь следующий вид:

#  Целочисленное представление:
>>> Decimal('1'), Decimal('12045')
(Decimal('1'), Decimal('12045'))

 #  Десятичные дроби:
>>> Decimal('0.1'), Decimal('.1')
(Decimal('0.1'), Decimal('0.1'))
 
#  Экспоненциальная форма:
>>> Decimal('1.1e2'), Decimal('-1.1E2'), Decimal('e3')
(Decimal('1.1E+2'), Decimal('-1.1E+2'), Decimal('NaN'))

#  Не число:
>>> Decimal('NaN'), Decimal('sNaN')
(Decimal('NaN'), Decimal('sNaN'))

#  Бесконечность:
>>> Decimal('Inf'), Decimal('-Inf'), Decimal('+Inf')
(Decimal('Infinity'), Decimal('-Infinity'), Decimal('Infinity'))

В качестве аргумента value также разрешены десятичные цифры в виде строк Юникода, в том числе и других алфавитов:

>>> Decimal('\uff19')
# Decimal('9')
>>> Decimal('-\uff12\uff10')
# Decimal('-20')
>>> Decimal('-\uff12\uff10E\uff13')
# Decimal('-2.0E+4')

Если значение value является кортежем, оно должно иметь три компонента: знак - 0 для положительного или 1 для отрицательного, кортеж из цифр и показатель экспоненты.

>>> Decimal((0, (1, 4, 1, 4), -3))
# Decimal('1.414')

Числа типа float переводятся в числа типа Decimal() без потерь, т.е. именно так как они хранятся в памяти компьютера. Это преобразование часто может требовать 53 или более цифр точности:

>>> Decimal(float('1.1'))
# Decimal('1.100000000000000088817841970012523233890533447265625')

Точность контекста не влияет на количество сохраняемых цифр. Это определяется исключительно количеством цифр в значении value . Например Decimal ('3.00000') записывает все пять нулей, даже если точность контекста равна только трем.

Цель аргумента context - определить, что делать, если значение является искаженной строкой. Если контекст перехватывает InvalidOperation, возникает исключение. В противном случае конструктор возвращает новое десятичное значение со значением NaN.

>>> getcontext().traps[InvalidOperation] = 0
>>> Decimal('1.1a')
# Decimal('NaN')
>>> getcontext().traps[InvalidOperation] = 1
>>> Decimal('1.1a')
# Traceback (most recent call last):
#   File "<stdin>", line 1, in <module>
# decimal.InvalidOperation: [<class 'decimal.ConversionSyntax'>]

Значениями аргумента context могут быть только контексты вычислений:

>>> Decimal('1.1a', context = ExtendedContext)
# Decimal('NaN')
>>> Decimal('1.1a', context = BasicContext)
# Traceback (most recent call last):
#   File "<stdin>", line 1, in <module>
# decimal.InvalidOperation: [<class 'decimal.ConversionSyntax'>]

Особенности математических операций с типом `Decimal()`.

Числа типа Decimal() во многом могут использоваться точно так же как и числа типа int и float. Есть лишь несколько незначительных отличий. При выполнении операции остатка от деления '%' у чисел типа Decimal знак результата будет таким же как у делимого, а не делителя:

>>> -10 % 4, 10 % -4
# (2, -2)
>>> Decimal(-10) % Decimal(4)
# Decimal('-2')
>>> Decimal(10) % Decimal(-4)
# Decimal('2')

Из-за этого иначе себя ведет и оператор целочисленного деления '//', который так же как и для чисел int и float работает так что бы удовлетворять условию x == (x // y) * y + x % y:

>>> -10 // 4
# -3
>>> Decimal(-10) // Decimal(4)
# Decimal('-2')

Это различие объясняется тем что числа типа decimal.Decimal() выполняют требования общей спецификации десятичной арифметики, в то время как встроенные типы int и float реализованы на языке C и соответственно выполняют требования которые предъявляются к данному языку.

Числа типа Decimal() и float, а так же рациональные дроби fractions.Fraction(), как правило, не могут присутствовать вместе в одном математическом выражении. Однако, операции сравнения могут выполняться между числом Decimal и другим числом любого типа, если только не установлен сигнал decimal.FloatOperation:

>>> Decimal('1.21') > 1.2
# True
>>> from fractions import Fraction
>>> Decimal('1.2') == Fraction(6, 5)
# True