decimal.md
1> **Источник:** https://python-all.ru/3.0/library/decimal.html2>3> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.45---67# `decimal` – арифметика с фиксированной и плавающей запятой89The `decimal` module provides support for decimal floating point arithmetic. It offers several advantages over the [`float`](https://python-all.ru/3.0/library/functions.html#float) datatype:1011- Decimal «основан на модели с плавающей запятой, разработанной с учетом человеческих потребностей, и имеет первостепенный руководящий принцип – компьютеры должны обеспечивать арифметику, работающую так же, как арифметика, которой люди учатся в школе». – отрывок из спецификации десятичной арифметики.12- Десятичные числа можно представить точно. В отличие от этого, такие числа, как `1.1`, не имеют точного представления в двоичной плавающей запятой. Конечные пользователи обычно не ожидают, что `1.1` будет отображаться как `1.1000000000000001`, как это происходит с двоичной плавающей запятой.13- Точность сохраняется и в арифметике. В десятичной арифметике с плавающей точкой `0.1 + 0.1 + 0.1 - 0.3` точно равен нулю. В двоичной арифметике с плавающей точкой результат равен `5.5511151231257827e-017`. Хотя это значение близко к нулю, различия мешают надёжной проверке на равенство, и ошибки могут накапливаться. По этой причине десятичная арифметика предпочтительна в бухгалтерских приложениях, где требуются строгие инварианты равенства.14- Модуль decimal включает понятие значащих разрядов, так что `1.30 + 1.20` равно `2.50`. Замыкающий ноль сохраняется для указания значимости. Это стандартное представление для финансовых приложений. Для умножения «школьный» подход использует все цифры множителей. Например, `1.3 * 1.2` даёт `1.56`, а `1.30 * 1.20` даёт `1.5600`.15- В отличие от аппаратно реализованной двоичной арифметики с плавающей запятой, модуль decimal имеет настраиваемую точность (по умолчанию 28 знаков), которая может быть сколь угодно большой для данной задачи:1617 ```python18 >>> getcontext().prec = 619 >>> Decimal(1) / Decimal(7)20 Decimal('0.142857')21 >>> getcontext().prec = 2822 >>> Decimal(1) / Decimal(7)23 Decimal('0.1428571428571428571428571429')24 ```25- Как двоичная, так и десятичная арифметика с плавающей запятой реализованы в соответствии с опубликованными стандартами. В то время как встроенный тип float предоставляет лишь скромную часть своих возможностей, модуль decimal предоставляет все необходимые части стандарта. При необходимости программист имеет полный контроль над округлением и обработкой сигналов. Это включает возможность принудительного точного выполнения арифметики с помощью исключений для блокировки любых неточных операций.26- Модуль decimal был разработан для поддержки «без каких-либо предпочтений как точной неокруглённой десятичной арифметики (иногда называемой арифметикой с фиксированной запятой), так и округлённой арифметики с плавающей запятой.» – выдержка из спецификации десятичной арифметики.2728Дизайн модуля сосредоточен на трёх концепциях: десятичное число, контекст арифметики и сигналы.2930Десятичное число неизменяемо. Оно имеет знак, цифры коэффициента и показатель степени. Чтобы сохранить значимость, цифры коэффициента не отбрасывают конечные нули. Десятичные числа также включают специальные значения, такие как `Infinity`, `-Infinity` и `NaN`. Стандарт также различает `-0` и `+0`.3132Контекст для арифметики – это окружение, задающее точность, правила округления, ограничения на показатели степени, флаги, указывающие на результаты операций, и включатели ловушек, которые определяют, обрабатываются ли сигналы как исключения. Варианты округления включают `ROUND_CEILING`, `ROUND_DOWN`, `ROUND_FLOOR`, `ROUND_HALF_DOWN`, `ROUND_HALF_EVEN`, `ROUND_HALF_UP`, `ROUND_UP` и `ROUND_05UP`.3334Сигналы – это группы исключительных условий, возникающих в ходе вычислений. В зависимости от потребностей приложения сигналы могут игнорироваться, рассматриваться как информационные или обрабатываться как исключения. Сигналы в модуле decimal: [`Clamped`](https://python-all.ru/3.0/library/decimal.html#decimal.Clamped), [`InvalidOperation`](https://python-all.ru/3.0/library/decimal.html#decimal.InvalidOperation), [`DivisionByZero`](https://python-all.ru/3.0/library/decimal.html#decimal.DivisionByZero), [`Inexact`](https://python-all.ru/3.0/library/decimal.html#decimal.Inexact), [`Rounded`](https://python-all.ru/3.0/library/decimal.html#decimal.Rounded), [`Subnormal`](https://python-all.ru/3.0/library/decimal.html#decimal.Subnormal), [`Overflow`](https://python-all.ru/3.0/library/decimal.html#decimal.Overflow) и [`Underflow`](https://python-all.ru/3.0/library/decimal.html#decimal.Underflow).3536Для каждого сигнала существует флаг и активатор ловушки. Когда сигнал обнаруживается, его флаг устанавливается в единицу, затем, если активатор ловушки установлен в единицу, возбуждается исключение. Флаги сохраняют состояние, поэтому пользователю необходимо сбрасывать их перед мониторингом вычислений.3738> **См. также**39>40> - Спецификация общей десятичной арифметики IBM, [Общая спецификация десятичной арифметики](https://python-all.ru/3.0/library/decimal.html).41> - Стандарт IEEE 854-1987, [Неофициальный текст IEEE 854](https://python-all.ru/3.0/library/decimal.html).4243## Быстрый старт4445Обычно для работы с десятичными числами модуль импортируют, просматривают текущий контекст с помощью [`getcontext()`](https://python-all.ru/3.0/library/decimal.html#decimal.getcontext) и, при необходимости, устанавливают новые значения точности, округления или включённых ловушек:4647```python48>>> from decimal import *49>>> getcontext()50Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999999, Emax=999999999,51 capitals=1, flags=[], traps=[Overflow, DivisionByZero,52 InvalidOperation])5354>>> getcontext().prec = 7 # Установить новую точность55```5657Экземпляры Decimal можно создавать из целых чисел, строк или кортежей. Чтобы создать Decimal из [`float`](https://python-all.ru/3.0/library/functions.html#float), сначала преобразуйте его в строку. Это служит явным напоминанием о деталях преобразования (включая ошибку представления). Десятичные числа включают специальные значения, такие как `NaN`, что означает «Не число», положительную и отрицательную `Infinity`, а также `-0`.5859```python60>>> getcontext().prec = 2861>>> Decimal(10)62Decimal('10')63>>> Decimal('3.14')64Decimal('3.14')65>>> Decimal((0, (3, 1, 4), -2))66Decimal('3.14')67>>> Decimal(str(2.0 ** 0.5))68Decimal('1.41421356237')69>>> Decimal(2) ** Decimal('0.5')70Decimal('1.414213562373095048801688724')71>>> Decimal('NaN')72Decimal('NaN')73>>> Decimal('-Infinity')74Decimal('-Infinity')75```7677Значимость нового Decimal определяется исключительно количеством введённых цифр. Точность контекста и округление вступают в силу только во время арифметических операций.7879```python80>>> getcontext().prec = 681>>> Decimal('3.0')82Decimal('3.0')83>>> Decimal('3.1415926535')84Decimal('3.1415926535')85>>> Decimal('3.1415926535') + Decimal('2.7182818285')86Decimal('5.85987')87>>> getcontext().rounding = ROUND_UP88>>> Decimal('3.1415926535') + Decimal('2.7182818285')89Decimal('5.85988')90```9192Десятичные числа хорошо взаимодействуют с остальной частью Python. Вот небольшой пример разнообразия десятичной арифметики с плавающей точкой:9394```python95>>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))96>>> max(data)97Decimal('9.25')98>>> min(data)99Decimal('0.03')100>>> sorted(data)101[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),102 Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]103>>> sum(data)104Decimal('19.29')105>>> a,b,c = data[:3]106>>> str(a)107'1.34'108>>> float(a)1091.3400000000000001110>>> round(a, 1) # round() сначала преобразует в двоичное число с плавающей точкой.1111.3112>>> int(a)1131114>>> a * 5115Decimal('6.70')116>>> a * b117Decimal('2.5058')118>>> c % a119Decimal('0.77')120```121122Также некоторые математические функции доступны для Decimal:123124```python125>>> getcontext().prec = 28126>>> Decimal(2).sqrt()127Decimal('1.414213562373095048801688724')128>>> Decimal(1).exp()129Decimal('2.718281828459045235360287471')130>>> Decimal('10').ln()131Decimal('2.302585092994045684017991455')132>>> Decimal('10').log10()133Decimal('1')134```135136Метод `quantize()` округляет число до заданного показателя степени. Этот метод полезен для денежных приложений, которые часто округляют результаты до фиксированного количества знаков:137138```python139>>> Decimal('7.325').quantize(Decimal('.01'), rounding=ROUND_DOWN)140Decimal('7.32')141>>> Decimal('7.325').quantize(Decimal('1.'), rounding=ROUND_UP)142Decimal('8')143```144145Как показано выше, функция [`getcontext()`](https://python-all.ru/3.0/library/decimal.html#decimal.getcontext) обращается к текущему контексту и позволяет изменять настройки. Такой подход удовлетворяет потребности большинства приложений.146147Для более сложной работы может быть полезно создавать альтернативные контексты с помощью конструктора Context(). Чтобы сделать альтернативный контекст активным, используйте функцию [`setcontext()`](https://python-all.ru/3.0/library/decimal.html#decimal.setcontext).148149In accordance with the standard, the `Decimal` module provides two ready to use standard contexts, [`BasicContext`](https://python-all.ru/3.0/library/decimal.html#decimal.BasicContext) and [`ExtendedContext`](https://python-all.ru/3.0/library/decimal.html#decimal.ExtendedContext). The former is especially useful for debugging because many of the traps are enabled:150151```python152>>> myothercontext = Context(prec=60, rounding=ROUND_HALF_DOWN)153>>> setcontext(myothercontext)154>>> Decimal(1) / Decimal(7)155Decimal('0.142857142857142857142857142857142857142857142857142857142857')156157>>> ExtendedContext158Context(prec=9, rounding=ROUND_HALF_EVEN, Emin=-999999999, Emax=999999999,159 capitals=1, flags=[], traps=[])160>>> setcontext(ExtendedContext)161>>> Decimal(1) / Decimal(7)162Decimal('0.142857143')163>>> Decimal(42) / Decimal(0)164Decimal('Infinity')165166>>> setcontext(BasicContext)167>>> Decimal(42) / Decimal(0)168Traceback (most recent call last):169 File "<pyshell#143>", line 1, in -toplevel-170 Decimal(42) / Decimal(0)171DivisionByZero: x / 0172```173174Контексты также имеют флаги сигналов для отслеживания исключительных ситуаций, возникающих во время вычислений. Флаги остаются установленными до явного сброса, поэтому лучше всего сбрасывать флаги перед каждой серией отслеживаемых вычислений с помощью метода `clear_flags()`.175176```python177>>> setcontext(ExtendedContext)178>>> getcontext().clear_flags()179>>> Decimal(355) / Decimal(113)180Decimal('3.14159292')181>>> getcontext()182Context(prec=9, rounding=ROUND_HALF_EVEN, Emin=-999999999, Emax=999999999,183 capitals=1, flags=[Inexact, Rounded], traps=[])184```185186Запись *flags* показывает, что рациональное приближение к `Pi` было округлено (цифры за пределами точности контекста были отброшены) и что результат неточен (некоторые отброшенные цифры были ненулевыми).187188Отдельные ловушки устанавливаются с помощью словаря в поле `traps` контекста:189190```python191>>> setcontext(ExtendedContext)192>>> Decimal(1) / Decimal(0)193Decimal('Infinity')194>>> getcontext().traps[DivisionByZero] = 1195>>> Decimal(1) / Decimal(0)196Traceback (most recent call last):197 File "<pyshell#112>", line 1, in -toplevel-198 Decimal(1) / Decimal(0)199DivisionByZero: x / 0200```201202Большинство программ настраивают текущий контекст только один раз, в начале программы. И во многих приложениях данные преобразуются в [`Decimal`](https://python-all.ru/3.0/library/decimal.html#decimal.Decimal) с помощью одного приведения в цикле. После установки контекста и создания десятичных чисел основная часть программы манипулирует данными точно так же, как и с другими числовыми типами Python.203204## Объекты Decimal205206#### `[decimal.Decimal]class decimal.Decimal([value[, context]])`207208Создаёт новый объект [`Decimal`](https://python-all.ru/3.0/library/decimal.html#decimal.Decimal) на основе *value*.209210*value* может быть целым числом, строкой, кортежем или другим объектом [`Decimal`](https://python-all.ru/3.0/library/decimal.html#decimal.Decimal). Если *value* не указано, возвращается `Decimal('0')`. Если *value* является строкой, она должна соответствовать синтаксису десятичной числовой строки после удаления начальных и конечных пробелов:211212```python213sign ::= '+' | '-'214digit ::= '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'215indicator ::= 'e' | 'E'216digits ::= digit [digit]...217decimal-part ::= digits '.' [digits] | ['.'] digits218exponent-part ::= indicator [sign] digits219infinity ::= 'Infinity' | 'Inf'220nan ::= 'NaN' [digits] | 'sNaN' [digits]221numeric-value ::= decimal-part [exponent-part] | infinity222numeric-string ::= [sign] numeric-value | [sign] nan223```224225Если *value* является [`tuple`](https://python-all.ru/3.0/library/functions.html#tuple), он должен иметь три компонента: знак (`0` для положительного или `1` для отрицательного), [`tuple`](https://python-all.ru/3.0/library/functions.html#tuple) цифр и целочисленный показатель степени. Например, `Decimal((0, (1, 4, 1, 4), -3))` возвращает `Decimal('1.414')`.226227Точность *context* не влияет на количество сохраняемых цифр. Оно определяется исключительно количеством цифр в *value*. Например, `Decimal('3.00000')` сохраняет все пять нулей, даже если точность контекста равна только трём.228229Назначение аргумента *context* – определить, что делать, если *value* является некорректной строкой. Если контекст перехватывает сигнал [`InvalidOperation`](https://python-all.ru/3.0/library/decimal.html#decimal.InvalidOperation), вызывается исключение; в противном случае конструктор возвращает новый Decimal со значением `NaN`.230231После создания объекты [`Decimal`](https://python-all.ru/3.0/library/decimal.html#decimal.Decimal) являются неизменяемыми.232233Объекты Decimal с плавающей запятой имеют много общих свойств с другими встроенными числовыми типами, такими как [`float`](https://python-all.ru/3.0/library/functions.html#float) и [`int`](https://python-all.ru/3.0/library/functions.html#int). К ним применимы все обычные математические операции и специальные методы. Кроме того, объекты Decimal можно копировать, сериализовать, выводить на печать, использовать в качестве ключей словаря, элементов множества, сравнивать, сортировать и приводить к другому типу (например, [`float`](https://python-all.ru/3.0/library/functions.html#float) или `long`).234235В дополнение к стандартным числовым свойствам десятичные объекты с плавающей точкой также имеют ряд специализированных методов:236237#### `[decimal.Decimal.adjusted]adjusted()`238239Возвращает скорректированный показатель степени после удаления крайних правых цифр коэффициента, пока не останется только старшая цифра:240241`Decimal('321e+5').adjusted()`242243возвращает семь. Используется для определения положения самой значащей цифры относительно десятичной точки.244245#### `[decimal.Decimal.as_tuple]as_tuple()`246247Возвращает представление числа в виде248249[*именованного кортежа*](https://python-all.ru/3.0/glossary.html#term-named-tuple)250251:252253`DecimalTuple(sign, digits, exponent)`254255.256257#### `[decimal.Decimal.canonical]canonical()`258259Возвращает каноническую кодировку аргумента. В настоящее время кодировка экземпляра260261[`Decimal`](https://python-all.ru/3.0/library/decimal.html#decimal.Decimal)262263всегда канонична, поэтому эта операция возвращает свой аргумент без изменений.264265#### `[decimal.Decimal.compare]compare(other[, context])`266267Сравнивает значения двух экземпляров Decimal. [`compare()`](https://python-all.ru/3.0/library/decimal.html#decimal.Decimal.compare) возвращает экземпляр Decimal, и если любой из операндов является NaN, то результатом будет NaN:268269```python270a or b is a NaN ==> Decimal('NaN')271a < b ==> Decimal('-1')272a == b ==> Decimal('0')273a > b ==> Decimal('1')274```275276#### `[decimal.Decimal.compare_signal]compare_signal(other[, context])`277278Эта операция идентична методу279280[`compare()`](https://python-all.ru/3.0/library/decimal.html#decimal.Decimal.compare)281282, за исключением того, что все NaN сигнализируют. То есть, если ни один операнд не является сигнальным NaN, то любой тихий NaN обрабатывается так, как если бы он был сигнальным NaN.283284#### `[decimal.Decimal.compare_total]compare_total(other)`285286Сравнивает два операнда, используя их абстрактное представление, а не числовое значение. Аналогично методу [`compare()`](https://python-all.ru/3.0/library/decimal.html#decimal.Decimal.compare), но результат даёт полное упорядочение экземпляров [`Decimal`](https://python-all.ru/3.0/library/decimal.html#decimal.Decimal). Два экземпляра [`Decimal`](https://python-all.ru/3.0/library/decimal.html#decimal.Decimal) с одинаковым числовым значением, но разными представлениями сравниваются как неравные в этом упорядочении:287288```python289>>> Decimal('12.0').compare_total(Decimal('12'))290Decimal('-1')291```292293Тихие и сигнальные NaN также включены в полное упорядочение. Результат этой функции равен `Decimal('0')`, если оба операнда имеют одинаковое представление, `Decimal('-1')`, если первый операнд находится ниже в полном порядке, чем второй, и `Decimal('1')`, если первый операнд находится выше в полном порядке, чем второй операнд. Подробнее о полном порядке см. в спецификации.294295#### `[decimal.Decimal.compare_total_mag]compare_total_mag(other)`296297Сравнивает два операнда, используя их абстрактное представление, а не их значение, как в298299[`compare_total()`](https://python-all.ru/3.0/library/decimal.html#decimal.Decimal.compare_total)300301, но игнорируя знак каждого операнда.302303`x.compare_total_mag(y)`304305эквивалентно306307`x.copy_abs().compare_total(y.copy_abs())`308309.310311#### `[decimal.Decimal.conjugate]conjugate()`312313Просто возвращает self; этот метод существует только для соответствия спецификации Decimal.314315#### `[decimal.Decimal.copy_abs]copy_abs()`316317Возвращает абсолютное значение аргумента. Эта операция не зависит от контекста и является тихой: флаги не изменяются и округление не выполняется.318319#### `[decimal.Decimal.copy_negate]copy_negate()`320321Возвращает отрицание аргумента. Эта операция не зависит от контекста и является тихой: флаги не изменяются и округление не выполняется.322323#### `[decimal.Decimal.copy_sign]copy_sign(other)`324325Возвращает копию первого операнда со знаком, установленным таким же, как знак второго операнда. Например:326327```python328>>> Decimal('2.3').copy_sign(Decimal('-1.5'))329Decimal('-2.3')330```331332Эта операция не зависит от контекста и является тихой: никакие флаги не изменяются и округление не выполняется.333334#### `[decimal.Decimal.exp]exp([context])`335336Возвращает значение (натуральной) показательной функции `e**x` для заданного числа. Результат правильно округляется с использованием режима округления `ROUND_HALF_EVEN`.337338```python339>>> Decimal(1).exp()340Decimal('2.718281828459045235360287471')341>>> Decimal(321).exp()342Decimal('2.561702493119680037517373933E+139')343```344345#### `[decimal.Decimal.fma]fma(other, third[, context])`346347Совмещённое умножение-сложение. Возвращает self\*other+third без округления промежуточного произведения self\*other.348349```python350>>> Decimal(2).fma(3, 5)351Decimal('11')352```353354#### `[decimal.Decimal.is_canonical]is_canonical()`355356Возвращает357358[`True`](https://python-all.ru/3.0/library/constants.html#True)359360, если аргумент каноничен, и361362[`False`](https://python-all.ru/3.0/library/constants.html#False)363364в противном случае. В настоящее время экземпляр365366[`Decimal`](https://python-all.ru/3.0/library/decimal.html#decimal.Decimal)367368всегда каноничен, поэтому эта операция всегда возвращает369370[`True`](https://python-all.ru/3.0/library/constants.html#True)371372.373374#### `[decimal.Decimal.is_finite]is_finite()`375376Возвращает377378[`True`](https://python-all.ru/3.0/library/constants.html#True)379380, если аргумент является конечным числом, и381382[`False`](https://python-all.ru/3.0/library/constants.html#False)383384, если аргумент является бесконечностью или NaN.385386#### `[decimal.Decimal.is_infinite]is_infinite()`387388Возвращает389390[`True`](https://python-all.ru/3.0/library/constants.html#True)391392, если аргумент – положительная или отрицательная бесконечность, и393394[`False`](https://python-all.ru/3.0/library/constants.html#False)395396в противном случае.397398#### `[decimal.Decimal.is_nan]is_nan()`399400Возвращает401402[`True`](https://python-all.ru/3.0/library/constants.html#True)403404, если аргумент – тихий или сигнализирующий NaN, и405406[`False`](https://python-all.ru/3.0/library/constants.html#False)407408в противном случае.409410#### `[decimal.Decimal.is_normal]is_normal()`411412Возвращает413414[`True`](https://python-all.ru/3.0/library/constants.html#True)415416, если аргумент –417418*нормальное*419420конечное число. Возвращает421422[`False`](https://python-all.ru/3.0/library/constants.html#False)423424, если аргумент – ноль, субнормальное число, бесконечность или NaN.425426#### `[decimal.Decimal.is_qnan]is_qnan()`427428Возвращает429430[`True`](https://python-all.ru/3.0/library/constants.html#True)431432, если аргумент – тихий NaN, и433434[`False`](https://python-all.ru/3.0/library/constants.html#False)435436в противном случае.437438#### `[decimal.Decimal.is_signed]is_signed()`439440Возвращает441442[`True`](https://python-all.ru/3.0/library/constants.html#True)443444, если аргумент имеет отрицательный знак, и445446[`False`](https://python-all.ru/3.0/library/constants.html#False)447448в противном случае. Обратите внимание, что нули и NaN могут иметь знак.449450#### `[decimal.Decimal.is_snan]is_snan()`451452Возвращает453454[`True`](https://python-all.ru/3.0/library/constants.html#True)455456, если аргумент – сигнализирующий NaN, и457458[`False`](https://python-all.ru/3.0/library/constants.html#False)459460в противном случае.461462#### `[decimal.Decimal.is_subnormal]is_subnormal()`463464Возвращает465466[`True`](https://python-all.ru/3.0/library/constants.html#True)467468, если аргумент субнормальный, и469470[`False`](https://python-all.ru/3.0/library/constants.html#False)471472в противном случае.473474#### `[decimal.Decimal.is_zero]is_zero()`475476Возвращает477478[`True`](https://python-all.ru/3.0/library/constants.html#True)479480, если аргумент – (положительный или отрицательный) ноль, и481482[`False`](https://python-all.ru/3.0/library/constants.html#False)483484в противном случае.485486#### `[decimal.Decimal.ln]ln([context])`487488Возвращает натуральный (по основанию e) логарифм операнда. Результат правильно округляется с использованием режима округления489490`ROUND_HALF_EVEN`491492.493494#### `[decimal.Decimal.log10]log10([context])`495496Возвращает десятичный логарифм операнда. Результат корректно округляется с использованием режима округления497498`ROUND_HALF_EVEN`499500.501502#### `[decimal.Decimal.logb]logb([context])`503504Для ненулевого числа возвращает скорректированный порядок операнда в виде экземпляра505506[`Decimal`](https://python-all.ru/3.0/library/decimal.html#decimal.Decimal)507508. Если операнд – ноль, то возвращается509510`Decimal('-Infinity')`511512и поднимается флаг513514[`DivisionByZero`](https://python-all.ru/3.0/library/decimal.html#decimal.DivisionByZero)515516. Если операнд – бесконечность, то возвращается517518`Decimal('Infinity')`519520.521522#### `[decimal.Decimal.logical_and]logical_and(other[, context])`523524[`logical_and()`](https://python-all.ru/3.0/library/decimal.html#decimal.Decimal.logical_and)525526– логическая операция, принимающая два527528*логических операнда*529530(см.531532[*Логические операнды*](https://python-all.ru/3.0/library/decimal.html#logical-operands-label)533534). Результатом является поразрядное535536`И`537538двух операндов.539540#### `[decimal.Decimal.logical_invert]logical_invert(other[, context])`541542[`logical_invert()`](https://python-all.ru/3.0/library/decimal.html#decimal.Decimal.logical_invert)543544– логическая операция. Аргумент должен быть545546*логическим операндом*547548(см.549550[*Логические операнды*](https://python-all.ru/3.0/library/decimal.html#logical-operands-label)551552). Результат представляет собой поразрядную инверсию операнда.553554#### `[decimal.Decimal.logical_or]logical_or(other[, context])`555556[`logical_or()`](https://python-all.ru/3.0/library/decimal.html#decimal.Decimal.logical_or)557558– логическая операция, принимающая два559560*логических операнда*561562(см.563564[*Логические операнды*](https://python-all.ru/3.0/library/decimal.html#logical-operands-label)565566). Результатом является поразрядное567568`ИЛИ`569570двух операндов.571572#### `[decimal.Decimal.logical_xor]logical_xor(other[, context])`573574[`logical_xor()`](https://python-all.ru/3.0/library/decimal.html#decimal.Decimal.logical_xor)575576– логическая операция, принимающая два577578*логических операнда*579580(см.581582[*Логические операнды*](https://python-all.ru/3.0/library/decimal.html#logical-operands-label)583584). Результатом является поразрядное исключающее ИЛИ двух операндов.585586#### `[decimal.Decimal.max]max(other[, context])`587588Подобно589590`max(self, other)`591592, за исключением того, что правило округления контекста применяется перед возвратом, и что значения593594`NaN`595596либо сигнализируются, либо игнорируются (в зависимости от контекста и от того, являются ли они сигнализирующими или тихими).597598#### `[decimal.Decimal.max_mag]max_mag(other[, context])`599600Похож на метод601602[`max()`](https://python-all.ru/3.0/library/functions.html#max)603604, но сравнение выполняется с использованием абсолютных значений операндов.605606#### `[decimal.Decimal.min]min(other[, context])`607608Как и609610`min(self, other)`611612, но с одним отличием: правило округления контекста применяется перед возвратом результата, а значения613614`NaN`615616либо сигнализируются, либо игнорируются (в зависимости от контекста и от того, являются ли они сигнальными или тихими).617618#### `[decimal.Decimal.min_mag]min_mag(other[, context])`619620Похож на метод621622[`min()`](https://python-all.ru/3.0/library/functions.html#min)623624, но сравнение выполняется с использованием абсолютных значений операндов.625626#### `[decimal.Decimal.next_minus]next_minus([context])`627628Возвращает наибольшее число, представимое в заданном контексте (или в контексте текущего потока, если контекст не задан), которое меньше заданного операнда.629630#### `[decimal.Decimal.next_plus]next_plus([context])`631632Возвращает наименьшее число, представимое в заданном контексте (или в контексте текущего потока, если контекст не задан), которое больше заданного операнда.633634#### `[decimal.Decimal.next_toward]next_toward(other[, context])`635636Если два операнда не равны, возвращает число, ближайшее к первому операнду в направлении второго операнда. Если оба операнда численно равны, возвращает копию первого операнда со знаком, установленным таким же, как знак второго операнда.637638#### `[decimal.Decimal.normalize]normalize([context])`639640Нормализует число, удаляя крайние правые конечные нули и преобразуя любой результат, равный641642`Decimal('0')`643644, в645646`Decimal('0e0')`647648. Используется для получения канонических значений членов класса эквивалентности. Например,649650`Decimal('32.100')`651652и653654`Decimal('0.321000e+2')`655656нормализуются до эквивалентного значения657658`Decimal('32.1')`659660.661662#### `[decimal.Decimal.number_class]number_class([context])`663664Возвращает строку, описывающую *класс* операнда. Возвращаемое значение является одной из следующих десяти строк.665666- `"-Infinity"` – указывает, что операнд является отрицательной бесконечностью.667- `"-Normal"` – указывает, что операнд является отрицательным нормальным числом.668- `"-Subnormal"` – указывает, что операнд отрицателен и является субнормальным.669- `"-Zero"` – указывает, что операнд является отрицательным нулём.670- `"+Zero"` – указывает, что операнд является положительным нулём.671- `"+Subnormal"` – указывает, что операнд положителен и является субнормальным.672- `"+Normal"` – указывает, что операнд является положительным нормальным числом.673- `"+Infinity"` – указывает, что операнд является положительной бесконечностью.674- `"NaN"` – указывает, что операнд является тихим NaN (не числом).675- `"sNaN"` – указывает, что операнд является сигнальным NaN.676677#### `[decimal.Decimal.quantize]quantize(exp[, rounding[, context[, watchexp]]])`678679Возвращает значение, равное первому операнду после округления и имеющее экспоненту второго операнда.680681```python682>>> Decimal('1.41421356').quantize(Decimal('1.000'))683Decimal('1.414')684```685686В отличие от других операций, если длина коэффициента после операции quantize превышает точность, то сигнализируется [`InvalidOperation`](https://python-all.ru/3.0/library/decimal.html#decimal.InvalidOperation). Это гарантирует, что при отсутствии ошибки квантованный порядок всегда равен порядку правого операнда.687688Также, в отличие от других операций, quantize никогда не сигнализирует Underflow, даже если результат субнормален и неточен.689690Если порядок второго операнда больше порядка первого, то может потребоваться округление. В этом случае режим округления определяется аргументом `rounding`, если он задан, иначе – аргументом `context`; если не задан ни один аргумент, используется режим округления контекста текущего потока.691692Если *watchexp* установлен (по умолчанию), то ошибка возвращается всякий раз, когда результирующий порядок больше `Emax` или меньше `Etiny`.693694#### `[decimal.Decimal.radix]radix()`695696Возвращает697698`Decimal(10)`699700– основание системы счисления (базу), в которой класс701702[`Decimal`](https://python-all.ru/3.0/library/decimal.html#decimal.Decimal)703704выполняет все свои арифметические операции. Включён для совместимости со спецификацией.705706#### `[decimal.Decimal.remainder_near]remainder_near(other[, context])`707708Вычисляет модуль как положительное или отрицательное значение в зависимости от того, что ближе к нулю. Например, `Decimal(10).remainder_near(6)` возвращает `Decimal('-2')`, что ближе к нулю, чем `Decimal('4')`.709710Если оба одинаково близки, выбранное значение будет иметь тот же знак, что и *self*.711712#### `[decimal.Decimal.rotate]rotate(other[, context])`713714Возвращает результат вращения цифр первого операнда на величину, заданную вторым операндом. Второй операнд должен быть целым числом в диапазоне от -precision до precision. Абсолютное значение второго операнда задаёт количество позиций для вращения. Если второй операнд положителен, вращение выполняется влево; в противном случае вращение выполняется вправо. Коэффициент первого операнда при необходимости дополняется слева нулями до длины precision. Знак и экспонента первого операнда не изменяются.715716#### `[decimal.Decimal.same_quantum]same_quantum(other[, context])`717718Проверяет, имеют ли self и other одинаковую экспоненту или оба являются719720`NaN`721722.723724#### `[decimal.Decimal.scaleb]scaleb(other[, context])`725726Возвращает первый операнд с экспонентой, скорректированной на второй. Эквивалентно умножению первого операнда на727728`10**other`729730. Второй операнд должен быть целым числом.731732#### `[decimal.Decimal.shift]shift(other[, context])`733734Возвращает результат сдвига цифр первого операнда на величину, заданную вторым операндом. Второй операнд должен быть целым числом в диапазоне от -precision до precision. Абсолютное значение второго операнда задаёт количество позиций для сдвига. Если второй операнд положителен, сдвиг выполняется влево; в противном случае сдвиг выполняется вправо. Вдвигаемые в коэффициент цифры являются нулями. Знак и экспонента первого операнда не изменяются.735736#### `[decimal.Decimal.sqrt]sqrt([context])`737738Возвращает квадратный корень аргумента с полной точностью.739740#### `[decimal.Decimal.to_eng_string]to_eng_string([context])`741742Преобразует в строку инженерного типа.743744В инженерной нотации показатель степени кратен 3, поэтому слева от десятичной запятой может быть до 3 цифр. Например, преобразует `Decimal('123E+1')` в `Decimal('1.23E+3')`745746#### `[decimal.Decimal.to_integral]to_integral([rounding[, context]])`747748Идентичен методу749750[`to_integral_value()`](https://python-all.ru/3.0/library/decimal.html#decimal.Decimal.to_integral_value)751752. Имя753754`to_integral`755756сохранено для совместимости со старыми версиями.757758#### `[decimal.Decimal.to_integral_exact]to_integral_exact([rounding[, context]])`759760Округляет до ближайшего целого, сигнализируя761762[`Inexact`](https://python-all.ru/3.0/library/decimal.html#decimal.Inexact)763764или765766[`Rounded`](https://python-all.ru/3.0/library/decimal.html#decimal.Rounded)767768в зависимости от того, произошло ли округление. Режим округления определяется параметром769770`rounding`771772, если он задан, иначе – заданным773774`context`775776. Если ни один параметр не задан, используется режим округления текущего контекста.777778#### `[decimal.Decimal.to_integral_value]to_integral_value([rounding[, context]])`779780Округляет до ближайшего целого без сигнализации781782[`Inexact`](https://python-all.ru/3.0/library/decimal.html#decimal.Inexact)783784или785786[`Rounded`](https://python-all.ru/3.0/library/decimal.html#decimal.Rounded)787788. Если задан, применяет789790*rounding*791792; в противном случае использует метод округления из предоставленного793794*context*795796или текущего контекста.797798### Логические операнды799800Методы `logical_and()`, `logical_invert()`, `logical_or()` и `logical_xor()` ожидают, что их аргументы являются *логическими операндами*. *Логический операнд* – это экземпляр [`Decimal`](https://python-all.ru/3.0/library/decimal.html#decimal.Decimal), у которого экспонента и знак равны нулю, а цифры – либо `0`, либо `1`.801802## Объекты контекста803804Контексты – это среды для арифметических операций. Они управляют точностью, задают правила округления, определяют, какие сигналы обрабатываются как исключения, и ограничивают диапазон для экспонент.805806Каждый поток имеет свой собственный текущий контекст, доступ к которому осуществляется или изменяется с помощью функций [`getcontext()`](https://python-all.ru/3.0/library/decimal.html#decimal.getcontext) и [`setcontext()`](https://python-all.ru/3.0/library/decimal.html#decimal.setcontext).807808#### `[decimal.getcontext]decimal.getcontext()`809810Возвращает текущий контекст активного потока.811812#### `[decimal.setcontext]decimal.setcontext(c)`813814Устанавливает текущий контекст активного потока в815816*c*817818.819820Также можно использовать оператор [`with`](https://python-all.ru/3.0/reference/compound_stmts.html#with) и функцию [`localcontext()`](https://python-all.ru/3.0/library/decimal.html#decimal.localcontext) для временного изменения активного контекста.821822#### `[decimal.localcontext]decimal.localcontext([c])`823824Возвращает менеджер контекста, который устанавливает текущий контекст для активного потока в копию *c* при входе в оператор with и восстанавливает предыдущий контекст при выходе из оператора with. Если контекст не указан, используется копия текущего контекста.825826Например, следующий код устанавливает текущую точность десятичных чисел в 42 знака, выполняет вычисление и затем автоматически восстанавливает предыдущий контекст:827828```python829from decimal import localcontext830831with localcontext() as ctx:832 ctx.prec = 42 # Выполнить вычисление с высокой точностью833 s = calculate_something()834s = +s # Округлить конечный результат до стандартной точности835```836837Новые контексты также можно создавать с помощью конструктора [`Context`](https://python-all.ru/3.0/library/decimal.html#decimal.Context), описанного ниже. Кроме того, модуль предоставляет три готовых контекста:838839#### `[decimal.BasicContext]class decimal.BasicContext`840841Это стандартный контекст, определённый в спецификации General Decimal Arithmetic. Точность установлена в девять. Округление установлено в `ROUND_HALF_UP`. Все флаги сброшены. Все ловушки включены (обрабатываются как исключения), за исключением [`Inexact`](https://python-all.ru/3.0/library/decimal.html#decimal.Inexact), [`Rounded`](https://python-all.ru/3.0/library/decimal.html#decimal.Rounded) и [`Subnormal`](https://python-all.ru/3.0/library/decimal.html#decimal.Subnormal).842843Поскольку многие ловушки включены, этот контекст полезен для отладки.844845#### `[decimal.ExtendedContext]class decimal.ExtendedContext`846847Это стандартный контекст, определённый в спецификации General Decimal Arithmetic. Точность установлена в девять. Округление установлено в `ROUND_HALF_EVEN`. Все флаги сброшены. Ловушки не включены (так что исключения не возбуждаются при вычислениях).848849Поскольку ловушки отключены, этот контекст полезен для приложений, которые предпочитают получать значение `NaN` или `Infinity` вместо вызова исключений. Это позволяет приложению завершить выполнение при наличии условий, которые в противном случае остановили бы программу.850851#### `[decimal.DefaultContext]class decimal.DefaultContext`852853Этот контекст используется конструктором [`Context`](https://python-all.ru/3.0/library/decimal.html#decimal.Context) как прототип для новых контекстов. Изменение поля (например, точности) приводит к изменению значений по умолчанию для новых контекстов, создаваемых конструктором [`Context`](https://python-all.ru/3.0/library/decimal.html#decimal.Context).854855Этот контекст наиболее полезен в многопоточных средах. Изменение одного из полей до запуска потоков приводит к установке общесистемных значений по умолчанию. Изменять поля после запуска потоков не рекомендуется, так как это потребовало бы синхронизации потоков для предотвращения состояний гонки.856857В однопоточных средах лучше вообще не использовать этот контекст. Вместо этого просто создавайте контексты явно, как описано ниже.858859Значения по умолчанию: precision=28, rounding=ROUND\_HALF\_EVEN, включены ловушки для Overflow, InvalidOperation и DivisionByZero.860861В дополнение к трём предоставленным контекстам новые контексты можно создавать с помощью конструктора [`Context`](https://python-all.ru/3.0/library/decimal.html#decimal.Context).862863#### `[decimal.Context]class decimal.Context(prec=None, rounding=None, traps=None, flags=None, Emin=None, Emax=None, capitals=1)`864865Создаёт новый контекст. Если поле не указано или равно [`None`](https://python-all.ru/3.0/library/constants.html#None), значения по умолчанию копируются из [`DefaultContext`](https://python-all.ru/3.0/library/decimal.html#decimal.DefaultContext). Если поле *flags* не указано или равно [`None`](https://python-all.ru/3.0/library/constants.html#None), все флаги сбрасываются.866867Поле *prec* – это положительное целое число, которое задаёт точность арифметических операций в контексте.868869Параметр *rounding* может принимать одно из следующих значений:870871- `ROUND_CEILING` (в сторону `Infinity`),872- `ROUND_DOWN` (в сторону нуля),873- `ROUND_FLOOR` (в сторону `-Infinity`),874- `ROUND_HALF_DOWN` (к ближайшему, при равенстве – в сторону нуля),875- `ROUND_HALF_EVEN` (к ближайшему, при равенстве – к ближайшему чётному целому),876- `ROUND_HALF_UP` (к ближайшему, при равенстве – от нуля), или877- `ROUND_UP` (от нуля).878- `ROUND_05UP` (от нуля, если последняя цифра после округления в сторону нуля была бы 0 или 5; в противном случае – к нулю)879880Поля *traps* и *flags* содержат список сигналов, которые необходимо установить. Как правило, для новых контекстов следует задавать только ловушки (traps), а флаги (flags) оставлять сброшенными.881882Поля *Emin* и *Emax* – это целые числа, задающие допустимые внешние границы для показателей степени.883884Поле *capitals* может быть равно `0` или `1` (по умолчанию). Если установлено в `1`, показатели степени выводятся с заглавной `E`; в противном случае используется строчная `e`: `Decimal('6.02e+23')`.885886Класс [`Context`](https://python-all.ru/3.0/library/decimal.html#decimal.Context) определяет несколько методов общего назначения, а также большое количество методов для выполнения арифметических операций непосредственно в заданном контексте. Кроме того, для каждого из описанных выше методов [`Decimal`](https://python-all.ru/3.0/library/decimal.html#decimal.Decimal) (за исключением методов `adjusted()` и `as_tuple()`) существует соответствующий метод [`Context`](https://python-all.ru/3.0/library/decimal.html#decimal.Context). Например, `C.exp(x)` эквивалентно `x.exp(context=C)`.887888#### `[decimal.Context.clear_flags]clear_flags()`889890Сбрасывает все флаги в891892`0`893894.895896#### `[decimal.Context.copy]copy()`897898Возвращает копию контекста.899900#### `[decimal.Context.copy_decimal]copy_decimal(num)`901902Возвращает копию экземпляра Decimal num.903904#### `[decimal.Context.create_decimal]create_decimal(num)`905906Создаёт новый экземпляр Decimal из *num*, используя *self* в качестве контекста. В отличие от конструктора [`Decimal`](https://python-all.ru/3.0/library/decimal.html#decimal.Decimal), при преобразовании применяются точность контекста, метод округления, флаги и ловушки.907908Это полезно, поскольку константы часто задаются с большей точностью, чем требуется приложению. Ещё одно преимущество в том, что округление немедленно устраняет нежелательные эффекты от цифр за пределами текущей точности. В следующем примере использование неокруглённых входных данных означает, что добавление нуля к сумме может изменить результат:909910```python911>>> getcontext().prec = 3912>>> Decimal('3.4445') + Decimal('1.0023')913Decimal('4.45')914>>> Decimal('3.4445') + Decimal(0) + Decimal('1.0023')915Decimal('4.44')916```917918Этот метод реализует операцию преобразования в число из спецификации IBM. Если аргумент – строка, начальные и конечные пробелы не допускаются.919920#### `[decimal.Context.Etiny]Etiny()`921922Возвращает значение, равное923924`Emin - prec + 1`925926, которое является минимальным значением показателя степени для субнормальных результатов. В случае антипереполнения (underflow) показатель степени устанавливается равным927928[`Etiny`](https://python-all.ru/3.0/library/decimal.html#decimal.Context.Etiny)929930.931932#### `[decimal.Context.Etop]Etop()`933934Возвращает значение, равное935936`Emax - prec + 1`937938.939940Обычный подход к работе с десятичными числами – создавать экземпляры [`Decimal`](https://python-all.ru/3.0/library/decimal.html#decimal.Decimal), а затем применять арифметические операции, которые выполняются в текущем контексте активного потока. Альтернативный подход – использовать методы контекста для вычислений в заданном контексте. Эти методы аналогичны методам класса [`Decimal`](https://python-all.ru/3.0/library/decimal.html#decimal.Decimal) и здесь лишь кратко перечислены.941942#### `[decimal.Context.abs]abs(x)`943944Возвращает абсолютное значение945946*x*947948.949950#### `[decimal.Context.add]add(x, y)`951952Возвращает сумму953954*x*955956и957958*y*959960.961962#### `[decimal.Context.canonical]canonical(x)`963964Возвращает тот же объект Decimal965966*x*967968.969970#### `[decimal.Context.compare]compare(x, y)`971972Сравнивает973974*x*975976и977978*y*979980численно.981982#### `[decimal.Context.compare_signal]compare_signal(x, y)`983984Сравнивает значения двух операндов численно.985986#### `[decimal.Context.compare_total]compare_total(x, y)`987988Сравнивает два операнда по их абстрактному представлению.989990#### `[decimal.Context.compare_total_mag]compare_total_mag(x, y)`991992Сравнивает два операнда по их абстрактному представлению, игнорируя знак.993994#### `[decimal.Context.copy_abs]copy_abs(x)`995996Возвращает копию997998*x*9991000с установленным в 0 знаком.10011002#### `[decimal.Context.copy_negate]copy_negate(x)`10031004Возвращает копию10051006*x*10071008с инвертированным знаком.10091010#### `[decimal.Context.copy_sign]copy_sign(x, y)`10111012Копирует знак из10131014*y*10151016в10171018*x*10191020.10211022#### `[decimal.Context.divide]divide(x, y)`10231024Возвращает10251026*x*10271028, делённое на10291030*y*10311032.10331034#### `[decimal.Context.divide_int]divide_int(x, y)`10351036Возвращает10371038*x*10391040, делённое на10411042*y*10431044, с усечением до целого.10451046#### `[decimal.Context.divmod]divmod(x, y)`10471048Делит два числа и возвращает целую часть результата.10491050#### `[decimal.Context.exp]exp(x)`10511052Возвращает10531054*e \*\* x*10551056.10571058#### `[decimal.Context.fma]fma(x, y, z)`10591060Возвращает10611062*x*10631064, умноженное на10651066*y*10671068, плюс10691070*z*10711072.10731074#### `[decimal.Context.is_canonical]is_canonical(x)`10751076Возвращает True, если10771078*x*10791080– каноническое число; иначе False.10811082#### `[decimal.Context.is_finite]is_finite(x)`10831084Возвращает True, если10851086*x*10871088– конечное число; иначе False.10891090#### `[decimal.Context.is_infinite]is_infinite(x)`10911092Возвращает True, если10931094*x*10951096– бесконечность; иначе False.10971098#### `[decimal.Context.is_nan]is_nan(x)`10991100Возвращает True, если11011102*x*11031104– qNaN или sNaN; иначе False.11051106#### `[decimal.Context.is_normal]is_normal(x)`11071108Возвращает True, если11091110*x*11111112– нормальное число; иначе False.11131114#### `[decimal.Context.is_qnan]is_qnan(x)`11151116Возвращает True, если11171118*x*11191120– тихий NaN; иначе False.11211122#### `[decimal.Context.is_signed]is_signed(x)`11231124Возвращает True, если11251126*x*11271128– отрицательное число; иначе False.11291130#### `[decimal.Context.is_snan]is_snan(x)`11311132Возвращает True, если11331134*x*11351136– сигнальный NaN; иначе False.11371138#### `[decimal.Context.is_subnormal]is_subnormal(x)`11391140Возвращает True, если11411142*x*11431144– субнормальное число; иначе возвращает False.11451146#### `[decimal.Context.is_zero]is_zero(x)`11471148Возвращает True, если11491150*x*11511152– ноль; иначе возвращает False.11531154#### `[decimal.Context.ln]ln(x)`11551156Возвращает натуральный (по основанию e) логарифм11571158*x*11591160.11611162#### `[decimal.Context.log10]log10(x)`11631164Возвращает десятичный логарифм11651166*x*11671168.11691170#### `[decimal.Context.logb]logb(x)`11711172Возвращает показатель степени величины старшего разряда операнда.11731174#### `[decimal.Context.logical_and]logical_and(x, y)`11751176Применяет логическую операцию11771178*and*11791180к соответствующим цифрам операндов.11811182#### `[decimal.Context.logical_invert]logical_invert(x)`11831184Инвертирует все цифры в11851186*x*11871188.11891190#### `[decimal.Context.logical_or]logical_or(x, y)`11911192Применяет логическую операцию11931194*or*11951196к соответствующим цифрам операндов.11971198#### `[decimal.Context.logical_xor]logical_xor(x, y)`11991200Применяет логическую операцию12011202*xor*12031204к соответствующим цифрам операндов.12051206#### `[decimal.Context.max]max(x, y)`12071208Сравнивает два числа и возвращает наибольшее.12091210#### `[decimal.Context.max_mag]max_mag(x, y)`12111212Сравнивает числа по модулю (игнорируя знак).12131214#### `[decimal.Context.min]min(x, y)`12151216Сравнивает два числа и возвращает наименьшее.12171218#### `[decimal.Context.min_mag]min_mag(x, y)`12191220Сравнивает числа по модулю (игнорируя знак).12211222#### `[decimal.Context.minus]minus(x)`12231224Минус соответствует унарному префиксному оператору минус в Python.12251226#### `[decimal.Context.multiply]multiply(x, y)`12271228Возвращает произведение12291230*x*12311232и12331234*y*12351236.12371238#### `[decimal.Context.next_minus]next_minus(x)`12391240Возвращает наибольшее представимое число, меньшее чем12411242*x*12431244.12451246#### `[decimal.Context.next_plus]next_plus(x)`12471248Возвращает наименьшее представимое число, большее чем12491250*x*12511252.12531254#### `[decimal.Context.next_toward]next_toward(x, y)`12551256Возвращает число, ближайшее к12571258*x*12591260в направлении к12611262*y*12631264.12651266#### `[decimal.Context.normalize]normalize(x)`12671268Приводит12691270*x*12711272к простейшей форме.12731274#### `[decimal.Context.number_class]number_class(x)`12751276Возвращает указание на класс12771278*x*12791280.12811282#### `[decimal.Context.plus]plus(x)`12831284Plus соответствует унарному префиксному оператору плюс в Python. Эта операция применяет точность и округление контекста, поэтому она12851286*не*12871288является тождественной операцией.12891290#### `[decimal.Context.power]power(x, y[, modulo])`12911292Возвращает `x`, возведённое в степень `y`, с приведением по модулю `modulo`, если он задан.12931294С двумя аргументами вычисляет `x**y`. Если `x` отрицательно, то `y` должно быть целым. Результат будет неточным, если только `y` не является целым и результат конечен и может быть точно выражен в цифрах 'precision'. Результат всегда должен быть правильно округлён в соответствии с режимом округления контекста текущего потока.12951296С тремя аргументами вычисляется `(x**y) % modulo`. Для формы с тремя аргументами действуют следующие ограничения:12971298> - все три аргумента должны быть целыми1299> - `y` должно быть неотрицательным1300> - по крайней мере одно из `x` или `y` должно быть ненулевым1301> - `modulo` должно быть ненулевым и содержать не более 'precision' цифр13021303Результат `Context.power(x, y, modulo)` идентичен результату, который был бы получен при вычислении `(x**y) % modulo` с неограниченной точностью, но вычисляется более эффективно. Он всегда точен.13041305#### `[decimal.Context.quantize]quantize(x, y)`13061307Возвращает значение, равное13081309*x*13101311(с округлением), с экспонентой13121313*y*13141315.13161317#### `[decimal.Context.radix]radix()`13181319Просто возвращает 10, так как это Decimal, :)13201321#### `[decimal.Context.remainder]remainder(x, y)`13221323Возвращает остаток от целочисленного деления.13241325Знак результата, если он не равен нулю, совпадает со знаком исходного делимого.13261327#### `[decimal.Context.remainder_near]remainder_near(x, y)`13281329Возвращает13301331`x - y * n`13321333, где13341335*n*13361337– целое число, ближайшее к точному значению13381339`x / y`13401341(если результат равен 0, его знак будет знаком13421343*x*13441345).13461347#### `[decimal.Context.rotate]rotate(x, y)`13481349Возвращает циклически сдвинутую копию13501351*x*13521353на13541355*y*13561357раз.13581359#### `[decimal.Context.same_quantum]same_quantum(x, y)`13601361Возвращает True, если два операнда имеют одинаковую экспоненту.13621363#### `[decimal.Context.scaleb]scaleb(x, y)`13641365Возвращает первый операнд после добавления второго значения к его экспоненте.13661367#### `[decimal.Context.shift]shift(x, y)`13681369Возвращает сдвинутую копию13701371*x*13721373на13741375*y*13761377раз.13781379#### `[decimal.Context.sqrt]sqrt(x)`13801381Квадратный корень неотрицательного числа с точностью контекста.13821383#### `[decimal.Context.subtract]subtract(x, y)`13841385Возвращает разность13861387*x*13881389и13901391*y*13921393.13941395#### `[decimal.Context.to_eng_string]to_eng_string(x)`13961397Преобразует число в строку, используя научную нотацию.13981399#### `[decimal.Context.to_integral_exact]to_integral_exact(x)`14001401Округляет до целого.14021403#### `[decimal.Context.to_sci_string]to_sci_string(x)`14041405Преобразует число в строку, используя научную запись.14061407## Сигналы14081409Сигналы представляют условия, возникающие во время вычислений. Каждый соответствует одному флагу контекста и одному включателю ловушки контекста.14101411Флаг контекста устанавливается при возникновении условия. После вычисления флаги могут быть проверены в информационных целях (например, чтобы определить, было ли вычисление точным). После проверки флагов необходимо очистить все флаги перед началом следующего вычисления.14121413Если для сигнала включён ловушечный переключатель контекста, то условие вызывает возбуждение исключения Python. Например, если установлена ловушка [`DivisionByZero`](https://python-all.ru/3.0/library/decimal.html#decimal.DivisionByZero), то при возникновении условия возбуждается исключение [`DivisionByZero`](https://python-all.ru/3.0/library/decimal.html#decimal.DivisionByZero).14141415#### `[decimal.Clamped]class decimal.Clamped`14161417Изменён показатель степени для соответствия ограничениям представления.14181419Обычно усечение (clamping) происходит, когда показатель степени выходит за пределы контекста `Emin` и `Emax`. Если возможно, показатель уменьшается до допустимого значения путём добавления нулей к коэффициенту.14201421#### `[decimal.DecimalException]class decimal.DecimalException`14221423Базовый класс для остальных сигналов и подкласс14241425[`ArithmeticError`](https://python-all.ru/3.0/library/exceptions.html#exceptions.ArithmeticError)14261427.14281429#### `[decimal.DivisionByZero]class decimal.DivisionByZero`14301431Сигнализирует о делении небесконечного числа на ноль.14321433Может возникнуть при делении, делении по модулю или возведении числа в отрицательную степень. Если эта ловушка не включена, возвращается `Infinity` или `-Infinity`, знак определяется входными данными вычисления.14341435#### `[decimal.Inexact]class decimal.Inexact`14361437Указывает, что произошло округление и результат не является точным.14381439Сигнализирует, когда при округлении были отброшены ненулевые цифры. Возвращается округлённый результат. Флаг сигнала или ловушка используется для обнаружения неточных результатов.14401441#### `[decimal.InvalidOperation]class decimal.InvalidOperation`14421443Выполнена недопустимая операция.14441445Указывает на то, что была запрошена бессмысленная операция. Если ловушка не включена, возвращается `NaN`. Возможные причины включают:14461447```python1448Infinity - Infinity14490 * Infinity1450Infinity / Infinity1451x % 01452Infinity % x1453x._rescale( non-integer )1454sqrt(-x) and x > 014550 ** 01456x ** (non-integer)1457x ** Infinity1458```14591460#### `[decimal.Overflow]class decimal.Overflow`14611462Числовое переполнение.14631464Указывает, что показатель степени превышает `Emax` после округления. Если ловушка не включена, результат зависит от режима округления: либо округление внутрь до наибольшего представимого конечного числа, либо округление наружу до `Infinity`. В любом случае также сигнализируются [`Inexact`](https://python-all.ru/3.0/library/decimal.html#decimal.Inexact) и [`Rounded`](https://python-all.ru/3.0/library/decimal.html#decimal.Rounded).14651466#### `[decimal.Rounded]class decimal.Rounded`14671468Произошло округление, хотя, возможно, информация не была потеряна.14691470Срабатывает при каждом округлении, отбрасывающем цифры, даже если эти цифры нулевые (например, при округлении `5.00` до `5.0`). Если не перехвачено, возвращает результат без изменений. Этот сигнал используется для обнаружения потери значащих цифр.14711472#### `[decimal.Subnormal]class decimal.Subnormal`14731474Exponent was lower than `Emin` prior to rounding.14751476Возникает, когда результат операции является субнормальным (экспонента слишком мала). Если не перехвачено, возвращает результат без изменений.14771478#### `[decimal.Underflow]class decimal.Underflow`14791480Числовое исчерпание с округлением результата до нуля.14811482Occurs when a subnormal result is pushed to zero by rounding. [`Inexact`](https://python-all.ru/3.0/library/decimal.html#decimal.Inexact) and [`Subnormal`](https://python-all.ru/3.0/library/decimal.html#decimal.Subnormal) are also signaled.14831484В следующей таблице приведена иерархия сигналов:14851486```python1487exceptions.ArithmeticError(exceptions.Exception)1488 DecimalException1489 Clamped1490 DivisionByZero(DecimalException, exceptions.ZeroDivisionError)1491 Inexact1492 Overflow(Inexact, Rounded)1493 Underflow(Inexact, Rounded, Subnormal)1494 InvalidOperation1495 Rounded1496 Subnormal1497```14981499## Примечания по числам с плавающей запятой15001501### Снижение ошибки округления за счёт увеличения точности15021503Использование десятичной арифметики с плавающей запятой устраняет ошибку десятичного представления (позволяя точно представить `0.1`); однако некоторые операции всё ещё могут приводить к ошибке округления, когда ненулевые цифры превышают фиксированную точность.15041505Влияние ошибки округления может усиливаться при сложении или вычитании почти компенсирующих друг друга величин, что приводит к потере значимости. Кнут приводит два поучительных примера, в которых округлённая арифметика с плавающей точкой с недостаточной точностью приводит к нарушению ассоциативного и дистрибутивного свойств сложения:15061507```python1508# Примеры из Seminumerical Algorithms, раздел 4.2.2.1509>>> from decimal import Decimal, getcontext1510>>> getcontext().prec = 815111512>>> u, v, w = Decimal(11111113), Decimal(-11111111), Decimal('7.51111111')1513>>> (u + v) + w1514Decimal('9.5111111')1515>>> u + (v + w)1516Decimal('10')15171518>>> u, v, w = Decimal(20000), Decimal(-6), Decimal('6.0000003')1519>>> (u*v) + (u*w)1520Decimal('0.01')1521>>> u * (v+w)1522Decimal('0.0060000')1523```15241525Модуль `decimal` позволяет восстановить тождества, увеличив точность до такой степени, чтобы избежать потери значимости:15261527```python1528>>> getcontext().prec = 201529>>> u, v, w = Decimal(11111113), Decimal(-11111111), Decimal('7.51111111')1530>>> (u + v) + w1531Decimal('9.51111111')1532>>> u + (v + w)1533Decimal('9.51111111')1534>>>1535>>> u, v, w = Decimal(20000), Decimal(-6), Decimal('6.0000003')1536>>> (u*v) + (u*w)1537Decimal('0.0060000')1538>>> u * (v+w)1539Decimal('0.0060000')1540```15411542### Особые значения15431544Система чисел модуля `decimal` предоставляет специальные значения, включая `NaN`, `sNaN`, `-Infinity`, `Infinity`, а также два нуля: `+0` и `-0`.15451546Infinities can be constructed directly with: `Decimal('Infinity')`. Also, they can arise from dividing by zero when the [`DivisionByZero`](https://python-all.ru/3.0/library/decimal.html#decimal.DivisionByZero) signal is not trapped. Likewise, when the [`Overflow`](https://python-all.ru/3.0/library/decimal.html#decimal.Overflow) signal is not trapped, infinity can result from rounding beyond the limits of the largest representable number.15471548Бесконечности являются знаковыми (аффинными) и могут использоваться в арифметических операциях, где они трактуются как очень большие неопределённые числа. Например, прибавление константы к бесконечности даёт другой бесконечный результат.15491550Some operations are indeterminate and return `NaN`, or if the [`InvalidOperation`](https://python-all.ru/3.0/library/decimal.html#decimal.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.15511552A 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.15531554The 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`](https://python-all.ru/3.0/library/constants.html#False) (even when doing `Decimal('NaN')==Decimal('NaN')`), while a test for inequality always returns [`True`](https://python-all.ru/3.0/library/constants.html#True). An attempt to compare two Decimals using any of the `<`, `<=`, `>` or `>=` operators will raise the [`InvalidOperation`](https://python-all.ru/3.0/library/decimal.html#decimal.InvalidOperation) signal if either operand is a `NaN`, and return [`False`](https://python-all.ru/3.0/library/constants.html#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.15551556Знаковые нули могут возникать в результате вычислений, приводящих к исчерпанию. Они сохраняют знак, который получился бы, если бы вычисления выполнялись с большей точностью. Поскольку их величина равна нулю, положительный и отрицательный нули считаются равными, а их знак является информационным.15571558Помимо двух знаковых нулей, которые различны, но равны, существуют различные представления нуля с разной точностью, но эквивалентные по значению. К этому нужно немного привыкнуть. Для глаза, привыкшего к нормализованным представлениям чисел с плавающей точкой, не сразу очевидно, что следующее вычисление возвращает значение, равное нулю:15591560```python1561>>> 1 / Decimal('Infinity')1562Decimal('0E-1000000026')1563```15641565## Работа с потоками15661567Функция [`getcontext()`](https://python-all.ru/3.0/library/decimal.html#decimal.getcontext) обращается к другому объекту [`Context`](https://python-all.ru/3.0/library/decimal.html#decimal.Context) для\\nкаждого потока. Наличие отдельных контекстов для потоков означает, что потоки могут вносить\\nизменения (например, `getcontext.prec=10`) без помех для других потоков.15681569Likewise, the [`setcontext()`](https://python-all.ru/3.0/library/decimal.html#decimal.setcontext) function automatically assigns its target to the current thread.15701571If [`setcontext()`](https://python-all.ru/3.0/library/decimal.html#decimal.setcontext) has not been called before [`getcontext()`](https://python-all.ru/3.0/library/decimal.html#decimal.getcontext), then [`getcontext()`](https://python-all.ru/3.0/library/decimal.html#decimal.getcontext) will automatically create a new context for use in the current thread.15721573The new context is copied from a prototype context called *DefaultContext*. To control the defaults so that each thread will use the same values throughout the application, directly modify the *DefaultContext* object. This should be done *before* any threads are started so that there won’t be a race condition between threads calling [`getcontext()`](https://python-all.ru/3.0/library/decimal.html#decimal.getcontext). For example:15741575```python1576# Установить глобальные настройки по умолчанию для всех потоков, которые будут запущены1577DefaultContext.prec = 121578DefaultContext.rounding = ROUND_DOWN1579DefaultContext.traps = ExtendedContext.traps.copy()1580DefaultContext.traps[InvalidOperation] = 11581setcontext(DefaultContext)15821583# После этого потоки можно запускать1584t1.start()1585t2.start()1586t3.start()1587 . . .1588```15891590## Рецепты15911592Here are a few recipes that serve as utility functions and that demonstrate ways to work with the [`Decimal`](https://python-all.ru/3.0/library/decimal.html#decimal.Decimal) class:15931594```python1595def moneyfmt(value, places=2, curr='', sep=',', dp='.',1596 pos='', neg='-', trailneg=''):1597 """Преобразовать Decimal в строку, отформатированную как денежная сумма.15981599 places: обязательное количество знаков после десятичной точки1600 curr: необязательный символ валюты перед знаком (может быть пустым)1601 sep: необязательный разделитель групп (запятая, точка, пробел или пусто)1602 dp: указатель десятичной точки (запятая или точка)1603 указывать пустым только при places=01604 pos: необязательный знак для положительных чисел: '+', пробел или пусто1605 neg: необязательный знак для отрицательных чисел: '-', '(', пробел или пусто1606 trailneg:необязательный завершающий знак минуса: '-', ')', пробел или пусто16071608 >>> d = Decimal('-1234567.8901')1609 >>> moneyfmt(d, curr='$')1610 '-$1,234,567.89'1611 >>> moneyfmt(d, places=0, sep='.', dp='', neg='', trailneg='-')1612 '1.234.568-'1613 >>> moneyfmt(d, curr='$', neg='(', trailneg=')')1614 '($1,234,567.89)'1615 >>> moneyfmt(Decimal(123456789), sep=' ')1616 '123 456 789.00'1617 >>> moneyfmt(Decimal('-0.02'), neg='<', trailneg='>')1618 '<0.02>'16191620 """1621 q = Decimal(10) ** -places # 2 знака после запятой --> '0.01'1622 sign, digits, exp = value.quantize(q).as_tuple()1623 result = []1624 digits = list(map(str, digits))1625 build, next = result.append, digits.pop1626 if sign:1627 build(trailneg)1628 for i in range(places):1629 build(next() if digits else '0')1630 build(dp)1631 if not digits:1632 build('0')1633 i = 01634 while digits:1635 build(next())1636 i += 11637 if i == 3 and digits:1638 i = 01639 build(sep)1640 build(curr)1641 build(neg if sign else pos)1642 return ''.join(reversed(result))16431644def pi():1645 """Вычислить число Пи с текущей точностью.16461647 >>> print(pi())1648 3.14159265358979323846264338316491650 """1651 getcontext().prec += 2 # дополнительные цифры для промежуточных шагов1652 three = Decimal(3) # подставить "three=3.0" вместо обычных чисел с плавающей точкой1653 lasts, t, s, n, na, d, da = 0, three, 3, 1, 0, 0, 241654 while s != lasts:1655 lasts = s1656 n, na = n+na, na+81657 d, da = d+da, da+321658 t = (t * n) / d1659 s += t1660 getcontext().prec -= 21661 return +s # унарный плюс применяет новую точность16621663def exp(x):1664 """Возвращает e, возведённое в степень x. Тип результата соответствует типу входного значения.16651666 >>> print(exp(Decimal(1)))1667 2.7182818284590452353602874711668 >>> print(exp(Decimal(2)))1669 7.3890560989306502272304274611670 >>> print(exp(2.0))1671 7.389056098931672 >>> print(exp(2+0j))1673 (7.38905609893+0j)16741675 """1676 getcontext().prec += 21677 i, lasts, s, fact, num = 0, 0, 1, 1, 11678 while s != lasts:1679 lasts = s1680 i += 11681 fact *= i1682 num *= x1683 s += num / fact1684 getcontext().prec -= 21685 return +s16861687def cos(x):1688 """Возвращает косинус x, измеренного в радианах.16891690 >>> print(cos(Decimal('0.5')))1691 0.87758256189037271611628158261692 >>> print(cos(0.5))1693 0.877582561891694 >>> print(cos(0.5+0j))1695 (0.87758256189+0j)16961697 """1698 getcontext().prec += 21699 i, lasts, s, fact, num, sign = 0, 0, 1, 1, 1, 11700 while s != lasts:1701 lasts = s1702 i += 21703 fact *= i * (i-1)1704 num *= x * x1705 sign *= -11706 s += num / fact * sign1707 getcontext().prec -= 21708 return +s17091710def sin(x):1711 """Возвращает синус угла x, заданного в радианах.17121713 >>> print(sin(Decimal('0.5')))1714 0.47942553860420300027328793521715 >>> print(sin(0.5))1716 0.4794255386041717 >>> print(sin(0.5+0j))1718 (0.479425538604+0j)17191720 """1721 getcontext().prec += 21722 i, lasts, s, fact, num, sign = 1, 0, x, 1, x, 11723 while s != lasts:1724 lasts = s1725 i += 21726 fact *= i * (i-1)1727 num *= x * x1728 sign *= -11729 s += num / fact * sign1730 getcontext().prec -= 21731 return +s1732```17331734## Вопросы и ответы по Decimal17351736Q. It is cumbersome to type `decimal.Decimal('1234.5')`. Is there a way to minimize typing when using the interactive interpreter?17371738Ответ. Некоторые пользователи сокращают конструктор до одной буквы:17391740```python1741>>> D = decimal.Decimal1742>>> D('1.23') + D('3.45')1743Decimal('4.68')1744```17451746Вопрос. В приложении с фиксированной запятой с двумя десятичными знаками некоторые входные данные имеют много знаков и нуждаются в округлении. Другие не должны содержать лишних цифр и требуют проверки. Какие методы следует использовать?17471748A. The `quantize()` method rounds to a fixed number of decimal places. If the [`Inexact`](https://python-all.ru/3.0/library/decimal.html#decimal.Inexact) trap is set, it is also useful for validation:17491750> ```python1751> >>> TWOPLACES = Decimal(10) ** -2 # то же, что Decimal('0.01')1752> ```1753>1754> ```python1755> >>> # Округлить до двух знаков1756> >>> Decimal('3.214').quantize(TWOPLACES)1757> Decimal('3.21')1758> ```1759>1760> ```python1761> >>> # Проверка, что число не выходит за пределы двух знаков1762> >>> Decimal('3.21').quantize(TWOPLACES, context=Context(traps=[Inexact]))1763> Decimal('3.21')1764> ```1765>1766> ```python1767> >>> Decimal('3.214').quantize(TWOPLACES, context=Context(traps=[Inexact]))1768> Traceback (most recent call last):1769> ...1770> Inexact1771> ```17721773Вопрос. Получив корректные входные данные с двумя знаками, как поддерживать этот инвариант во всём приложении?17741775A. 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:17761777```python1778>>> a = Decimal('102.72') # Начальные значения чисел с фиксированной точкой1779>>> b = Decimal('3.17')1780>>> a + b # Сложение сохраняет фиксированную точку1781Decimal('105.89')1782>>> a - b1783Decimal('99.55')1784>>> a * 42 # Умножение на целое число – тоже1785Decimal('4314.24')1786>>> (a * b).quantize(TWOPLACES) # Результат умножения на нецелое число нужно квантовать1787Decimal('325.62')1788>>> (b / a).quantize(TWOPLACES) # И квантовать результат деления1789Decimal('0.03')1790```17911792In developing fixed-point applications, it is convenient to define functions to handle the `quantize()` step:17931794> ```python1795> >>> def mul(x, y, fp=TWOPLACES):1796> ... return (x * y).quantize(fp)1797> >>> def div(x, y, fp=TWOPLACES):1798> ... return (x / y).quantize(fp)1799> ```1800>1801> ```python1802> >>> mul(a, b) # Автоматически сохранять фиксированную точку1803> Decimal('325.62')1804> >>> div(b, a)1805> Decimal('0.03')1806> ```18071808Q. 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?18091810A. The `normalize()` method maps all equivalent values to a single representative:18111812```python1813>>> values = map(Decimal, '200 200.000 2E2 .02E+4'.split())1814>>> [v.normalize() for v in values]1815[Decimal('2E+2'), Decimal('2E+2'), Decimal('2E+2'), Decimal('2E+2')]1816```18171818Вопрос. Некоторые значения decimal всегда выводятся в экспоненциальной записи. Есть ли способ получить неэкспоненциальное представление?18191820A. 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.18211822Если приложению не важно отслеживать значимость, можно легко удалить экспоненту и хвостовые нули, потеряв значимость, но сохранив значение:18231824> ```python1825> >>> def remove_exponent(d):1826> ... return d.quantize(Decimal(1)) if d == d.to_integral() else d.normalize()1827> ```1828>1829> ```python1830> >>> remove_exponent(Decimal('5E+3'))1831> Decimal('5000')1832> ```18331834Q. Is there a way to convert a regular float to a [`Decimal`](https://python-all.ru/3.0/library/decimal.html#decimal.Decimal)?18351836A. Да, все двоичные числа с плавающей запятой могут быть точно представлены как Decimal. Точное преобразование может потребовать большей точности, чем можно предположить интуитивно, поэтому мы перехватываем [`Inexact`](https://python-all.ru/3.0/library/decimal.html#decimal.Inexact), чтобы сигнализировать о необходимости большей точности:18371838```python1839def float_to_decimal(f):1840 "Convert a floating point number to a Decimal with no loss of information"1841 n, d = f.as_integer_ratio()1842 with localcontext() as ctx:1843 ctx.traps[Inexact] = True1844 while True:1845 try:1846 return Decimal(n) / Decimal(d)1847 except Inexact:1848 ctx.prec += 11849```18501851```python1852>>> float_to_decimal(math.pi)1853Decimal('3.141592653589793115997963468544185161590576171875')1854```18551856Q. Почему функция `float_to_decimal()` не включена в модуль?18571858A. Ведутся споры о том, стоит ли смешивать двоичные и десятичные числа с плавающей запятой. Кроме того, ее использование требует осторожности, чтобы избежать проблем представления, связанных с двоичной плавающей запятой:18591860```python1861>>> float_to_decimal(1.1)1862Decimal('1.100000000000000088817841970012523233890533447265625')1863```18641865Вопрос. В сложном вычислении как я могу убедиться, что не получил ложный результат из-за недостаточной точности или аномалий округления?18661867Ответ. Модуль decimal упрощает проверку результатов. Рекомендуется перезапускать вычисления с большей точностью и различными режимами округления. Сильно различающиеся результаты указывают на недостаточную точность, проблемы с режимом округления, плохо обусловленные входные данные или численно неустойчивый алгоритм.18681869Вопрос. Я заметил, что точность контекста применяется к результатам операций, но не к входным данным. Есть ли что-то, на что следует обращать внимание при смешивании значений разной точности?18701871Ответ. Да. Принцип заключается в том, что все значения считаются точными, как и арифметические операции с ними. Округляются только результаты. Преимущество для входных данных в том, что «что ввёл, то и получил». Недостаток в том, что результаты могут выглядеть странно, если забыть, что входные данные не округлены:18721873```python1874>>> getcontext().prec = 31875>>> Decimal('3.104') + Decimal('2.104')1876Decimal('5.21')1877>>> Decimal('3.104') + Decimal('0.000') + Decimal('2.104')1878Decimal('5.20')1879```18801881Решение – либо увеличить точность, либо принудительно округлить входные данные с помощью унарного плюса:18821883```python1884>>> getcontext().prec = 31885>>> +Decimal('1.23456789') # Унарный плюс вызывает округление1886Decimal('1.23')1887```18881889Alternatively, inputs can be rounded upon creation using the [`Context.create_decimal()`](https://python-all.ru/3.0/library/decimal.html#decimal.Context.create_decimal) method:18901891```python1892>>> Context(prec=5, rounding=ROUND_DOWN).create_decimal('1.2345678')1893Decimal('1.2345')1894```1895