decimal.md
1> **Источник:** https://python-all.ru/3.2/library/decimal.html2>3> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.45---67# 8.4. [`decimal`](https://python-all.ru/3.2/library/decimal.html#module-decimal) – десятичная арифметика с фиксированной и плавающей точкой89Модуль [`decimal`](https://python-all.ru/3.2/library/decimal.html#module-decimal) обеспечивает поддержку десятичной арифметики с плавающей точкой. Он предлагает несколько преимуществ по сравнению с типом данных [`float`](https://python-all.ru/3.2/library/functions.html#float):1011- Decimal «основан на модели с плавающей запятой, разработанной с учетом человеческих потребностей, и имеет первостепенный руководящий принцип – компьютеры должны обеспечивать арифметику, работающую так же, как арифметика, которой люди учатся в школе». – отрывок из спецификации десятичной арифметики.12- Десятичные числа могут быть представлены точно. В отличие от этого, такие числа, как `1.1` и `2.2`, не имеют точного представления в двоичной арифметике с плавающей запятой. Конечные пользователи обычно не ожидают, что `1.1 + 2.2` будет отображаться как `3.3000000000000003`, как это происходит в двоичной арифметике с плавающей запятой.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 >>> from decimal import *19 >>> getcontext().prec = 620 >>> Decimal(1) / Decimal(7)21 Decimal('0.142857')22 >>> getcontext().prec = 2823 >>> Decimal(1) / Decimal(7)24 Decimal('0.1428571428571428571428571429')25 ```26- Как двоичная, так и десятичная арифметика с плавающей запятой реализованы в соответствии с опубликованными стандартами. В то время как встроенный тип float предоставляет лишь скромную часть своих возможностей, модуль decimal предоставляет все необходимые части стандарта. При необходимости программист имеет полный контроль над округлением и обработкой сигналов. Это включает возможность принудительного точного выполнения арифметики с помощью исключений для блокировки любых неточных операций.27- Модуль decimal был разработан для поддержки «без каких-либо предпочтений как точной неокруглённой десятичной арифметики (иногда называемой арифметикой с фиксированной запятой), так и округлённой арифметики с плавающей запятой.» – выдержка из спецификации десятичной арифметики.2829Дизайн модуля сосредоточен на трёх концепциях: десятичное число, контекст арифметики и сигналы.3031Десятичное число неизменяемо. Оно имеет знак, цифры коэффициента и показатель степени. Чтобы сохранить значимость, цифры коэффициента не отбрасывают конечные нули. Десятичные числа также включают специальные значения, такие как `Infinity`, `-Infinity` и `NaN`. Стандарт также различает `-0` и `+0`.3233Контекст для арифметики – это окружение, задающее точность, правила округления, ограничения на показатели степени, флаги, указывающие на результаты операций, и включатели ловушек, которые определяют, обрабатываются ли сигналы как исключения. Варианты округления включают `ROUND_CEILING`, `ROUND_DOWN`, `ROUND_FLOOR`, `ROUND_HALF_DOWN`, `ROUND_HALF_EVEN`, `ROUND_HALF_UP`, `ROUND_UP` и `ROUND_05UP`.3435Сигналы – это группы исключительных условий, возникающих в ходе вычислений. В зависимости от потребностей приложения сигналы могут игнорироваться, рассматриваться как информационные или обрабатываться как исключения. Сигналы в модуле decimal: [`Clamped`](https://python-all.ru/3.2/library/decimal.html#decimal.Clamped), [`InvalidOperation`](https://python-all.ru/3.2/library/decimal.html#decimal.InvalidOperation), [`DivisionByZero`](https://python-all.ru/3.2/library/decimal.html#decimal.DivisionByZero), [`Inexact`](https://python-all.ru/3.2/library/decimal.html#decimal.Inexact), [`Rounded`](https://python-all.ru/3.2/library/decimal.html#decimal.Rounded), [`Subnormal`](https://python-all.ru/3.2/library/decimal.html#decimal.Subnormal), [`Overflow`](https://python-all.ru/3.2/library/decimal.html#decimal.Overflow) и [`Underflow`](https://python-all.ru/3.2/library/decimal.html#decimal.Underflow).3637Для каждого сигнала существует флаг и активатор ловушки. Когда сигнал обнаруживается, его флаг устанавливается в единицу, затем, если активатор ловушки установлен в единицу, возбуждается исключение. Флаги сохраняют состояние, поэтому пользователю необходимо сбрасывать их перед мониторингом вычислений.3839> **См. также**40>41> - Спецификация общей десятичной арифметики IBM, [Общая спецификация десятичной арифметики](https://python-all.ru/3.2/library/decimal.html).42> - Стандарт IEEE 854-1987, [Неофициальный текст IEEE 854](https://python-all.ru/3.2/library/decimal.html).4344## 8.4.1. Краткое руководство4546Обычно для работы с десятичными числами модуль импортируют, просматривают текущий контекст с помощью [`getcontext()`](https://python-all.ru/3.2/library/decimal.html#decimal.getcontext) и, при необходимости, устанавливают новые значения точности, округления или включённых ловушек:4748```python49>>> from decimal import *50>>> getcontext()51Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999999, Emax=999999999,52 capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,53 InvalidOperation])5455>>> getcontext().prec = 7 # Установить новую точность56```5758Экземпляры Decimal можно создавать из целых чисел, строк, чисел с плавающей точкой или кортежей. Создание из целого числа или числа с плавающей точкой выполняет точное преобразование значения этого целого числа или числа с плавающей точкой. Десятичные числа включают специальные значения, такие как `NaN`, что означает «Не число», положительная и отрицательная `Infinity` и `-0`.5960```python61>>> getcontext().prec = 2862>>> Decimal(10)63Decimal('10')64>>> Decimal('3.14')65Decimal('3.14')66>>> Decimal(3.14)67Decimal('3.140000000000000124344978758017532527446746826171875')68>>> Decimal((0, (3, 1, 4), -2))69Decimal('3.14')70>>> Decimal(str(2.0 ** 0.5))71Decimal('1.4142135623730951')72>>> Decimal(2) ** Decimal('0.5')73Decimal('1.414213562373095048801688724')74>>> Decimal('NaN')75Decimal('NaN')76>>> Decimal('-Infinity')77Decimal('-Infinity')78```7980Значимость нового Decimal определяется исключительно количеством введённых цифр. Точность контекста и округление вступают в силу только во время арифметических операций.8182```python83>>> getcontext().prec = 684>>> Decimal('3.0')85Decimal('3.0')86>>> Decimal('3.1415926535')87Decimal('3.1415926535')88>>> Decimal('3.1415926535') + Decimal('2.7182818285')89Decimal('5.85987')90>>> getcontext().rounding = ROUND_UP91>>> Decimal('3.1415926535') + Decimal('2.7182818285')92Decimal('5.85988')93```9495Десятичные числа хорошо взаимодействуют с остальной частью Python. Вот небольшой пример разнообразия десятичной арифметики с плавающей точкой:9697```python98>>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))99>>> max(data)100Decimal('9.25')101>>> min(data)102Decimal('0.03')103>>> sorted(data)104[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),105 Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]106>>> sum(data)107Decimal('19.29')108>>> a,b,c = data[:3]109>>> str(a)110'1.34'111>>> float(a)1121.34113>>> round(a, 1)114Decimal('1.3')115>>> int(a)1161117>>> a * 5118Decimal('6.70')119>>> a * b120Decimal('2.5058')121>>> c % a122Decimal('0.77')123```124125Также некоторые математические функции доступны для Decimal:126127```python128>>> getcontext().prec = 28129>>> Decimal(2).sqrt()130Decimal('1.414213562373095048801688724')131>>> Decimal(1).exp()132Decimal('2.718281828459045235360287471')133>>> Decimal('10').ln()134Decimal('2.302585092994045684017991455')135>>> Decimal('10').log10()136Decimal('1')137```138139Метод `quantize()` округляет число до заданного показателя степени. Этот метод полезен для денежных приложений, которые часто округляют результаты до фиксированного количества знаков:140141```python142>>> Decimal('7.325').quantize(Decimal('.01'), rounding=ROUND_DOWN)143Decimal('7.32')144>>> Decimal('7.325').quantize(Decimal('1.'), rounding=ROUND_UP)145Decimal('8')146```147148Как показано выше, функция [`getcontext()`](https://python-all.ru/3.2/library/decimal.html#decimal.getcontext) обращается к текущему контексту и позволяет изменять настройки. Такой подход удовлетворяет потребности большинства приложений.149150Для более сложной работы может быть полезно создавать альтернативные контексты с помощью конструктора Context(). Чтобы сделать альтернативный контекст активным, используйте функцию [`setcontext()`](https://python-all.ru/3.2/library/decimal.html#decimal.setcontext).151152In accordance with the standard, the `Decimal` module provides two ready to use standard contexts, [`BasicContext`](https://python-all.ru/3.2/library/decimal.html#decimal.BasicContext) and [`ExtendedContext`](https://python-all.ru/3.2/library/decimal.html#decimal.ExtendedContext). The former is especially useful for debugging because many of the traps are enabled:153154```python155>>> myothercontext = Context(prec=60, rounding=ROUND_HALF_DOWN)156>>> setcontext(myothercontext)157>>> Decimal(1) / Decimal(7)158Decimal('0.142857142857142857142857142857142857142857142857142857142857')159160>>> ExtendedContext161Context(prec=9, rounding=ROUND_HALF_EVEN, Emin=-999999999, Emax=999999999,162 capitals=1, clamp=0, flags=[], traps=[])163>>> setcontext(ExtendedContext)164>>> Decimal(1) / Decimal(7)165Decimal('0.142857143')166>>> Decimal(42) / Decimal(0)167Decimal('Infinity')168169>>> setcontext(BasicContext)170>>> Decimal(42) / Decimal(0)171Traceback (most recent call last):172 File "<pyshell#143>", line 1, in -toplevel-173 Decimal(42) / Decimal(0)174DivisionByZero: x / 0175```176177Контексты также имеют флаги сигналов для отслеживания исключительных ситуаций, возникающих во время вычислений. Флаги остаются установленными до явного сброса, поэтому лучше всего сбрасывать флаги перед каждой серией отслеживаемых вычислений с помощью метода `clear_flags()`.178179```python180>>> setcontext(ExtendedContext)181>>> getcontext().clear_flags()182>>> Decimal(355) / Decimal(113)183Decimal('3.14159292')184>>> getcontext()185Context(prec=9, rounding=ROUND_HALF_EVEN, Emin=-999999999, Emax=999999999,186 capitals=1, clamp=0, flags=[Inexact, Rounded], traps=[])187```188189Запись *flags* показывает, что рациональное приближение к `Pi` было округлено (цифры за пределами точности контекста были отброшены) и что результат неточен (некоторые отброшенные цифры были ненулевыми).190191Отдельные ловушки устанавливаются с помощью словаря в поле `traps` контекста:192193```python194>>> setcontext(ExtendedContext)195>>> Decimal(1) / Decimal(0)196Decimal('Infinity')197>>> getcontext().traps[DivisionByZero] = 1198>>> Decimal(1) / Decimal(0)199Traceback (most recent call last):200 File "<pyshell#112>", line 1, in -toplevel-201 Decimal(1) / Decimal(0)202DivisionByZero: x / 0203```204205Большинство программ настраивают текущий контекст только один раз, в начале программы. И во многих приложениях данные преобразуются в [`Decimal`](https://python-all.ru/3.2/library/decimal.html#decimal.Decimal) с помощью одного приведения в цикле. После установки контекста и создания десятичных чисел основная часть программы манипулирует данными точно так же, как и с другими числовыми типами Python.206207## 8.4.2. Объекты Decimal208209#### `class decimal.Decimal(value="0", context=None)`210211Создаёт новый объект [`Decimal`](https://python-all.ru/3.2/library/decimal.html#decimal.Decimal) на основе *value*.212213*value* может быть целым числом, строкой, кортежем, [`float`](https://python-all.ru/3.2/library/functions.html#float) или другим объектом [`Decimal`](https://python-all.ru/3.2/library/decimal.html#decimal.Decimal). Если *value* не указан, возвращается `Decimal('0')`. Если *value* – строка, она должна соответствовать синтаксису десятичной числовой строки после удаления начальных и конечных пробельных символов:214215```python216sign ::= '+' | '-'217digit ::= '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'218indicator ::= 'e' | 'E'219digits ::= digit [digit]...220decimal-part ::= digits '.' [digits] | ['.'] digits221exponent-part ::= indicator [sign] digits222infinity ::= 'Infinity' | 'Inf'223nan ::= 'NaN' [digits] | 'sNaN' [digits]224numeric-value ::= decimal-part [exponent-part] | infinity225numeric-string ::= [sign] numeric-value | [sign] nan226```227228Другие десятичные цифры Unicode также допускаются там, где выше указано `digit`. К ним относятся десятичные цифры из различных других алфавитов (например, арабо-индийские цифры и деванагари), а также полноширинные цифры от `'\uff10'` до `'\uff19'`.229230Если *value* является [`tuple`](https://python-all.ru/3.2/library/functions.html#tuple), он должен иметь три компонента: знак (`0` для положительного или `1` для отрицательного), [`tuple`](https://python-all.ru/3.2/library/functions.html#tuple) цифр и целочисленный показатель степени. Например, `Decimal((0, (1, 4, 1, 4), -3))` возвращает `Decimal('1.414')`.231232Если *value* является [`float`](https://python-all.ru/3.2/library/functions.html#float), двоичное значение с плавающей точкой без потерь преобразуется в его точный десятичный эквивалент. Это преобразование часто может потребовать 53 или более цифр точности. Например, `Decimal(float('1.1'))` преобразуется в `Decimal('1.100000000000000088817841970012523233890533447265625')`.233234Точность *context* не влияет на количество сохраняемых цифр. Оно определяется исключительно количеством цифр в *value*. Например, `Decimal('3.00000')` сохраняет все пять нулей, даже если точность контекста равна только трём.235236Назначение аргумента *context* – определить, что делать, если *value* является некорректной строкой. Если контекст перехватывает сигнал [`InvalidOperation`](https://python-all.ru/3.2/library/decimal.html#decimal.InvalidOperation), вызывается исключение; в противном случае конструктор возвращает новый Decimal со значением `NaN`.237238После создания объекты [`Decimal`](https://python-all.ru/3.2/library/decimal.html#decimal.Decimal) являются неизменяемыми.239240Изменено в версии 3.2: Аргумент конструктора теперь может быть экземпляром [`float`](https://python-all.ru/3.2/library/functions.html#float) .241242Объекты Decimal имеют много общего с другими встроенными числовыми типами, такими как [`float`](https://python-all.ru/3.2/library/functions.html#float) и [`int`](https://python-all.ru/3.2/library/functions.html#int). Для них определены все стандартные математические операции и специальные методы. Кроме того, десятичные объекты можно копировать, сериализовать (pickle), выводить на печать, использовать в качестве ключей словаря, элементов множества, сравнивать, сортировать и преобразовывать в другой тип (например, [`float`](https://python-all.ru/3.2/library/functions.html#float) или [`int`](https://python-all.ru/3.2/library/functions.html#int)).243244Существуют небольшие различия между арифметикой над объектами Decimal и арифметикой над целыми числами и числами с плавающей запятой. Когда оператор остатка `%` применяется к объектам Decimal, знак результата совпадает со знаком *dividend*, а не со знаком делителя:245246```python247>>> (-7) % 42481249>>> Decimal(-7) % Decimal(4)250Decimal('-3')251```252253Оператор целочисленного деления `//` ведёт себя аналогично: возвращает целую часть истинного частного (с округлением в сторону нуля), а не его пол, чтобы сохранить обычное тождество `x == (x // y) * y + x % y`:254255```python256>>> -7 // 4257-2258>>> Decimal(-7) // Decimal(4)259Decimal('-1')260```261262Операторы `%` и `//` реализуют операции `остаток` и `целочисленное-деление` (соответственно) в соответствии со спецификацией.263264Объекты Decimal обычно нельзя комбинировать с числами float или экземплярами [`fractions.Fraction`](https://python-all.ru/3.2/library/fractions.html#fractions.Fraction) в арифметических операциях: попытка добавить [`Decimal`](https://python-all.ru/3.2/library/decimal.html#decimal.Decimal) к [`float`](https://python-all.ru/3.2/library/functions.html#float), например, вызовет [`TypeError`](https://python-all.ru/3.2/library/exceptions.html#TypeError). Однако можно использовать операторы сравнения Python для сравнения экземпляра [`Decimal`](https://python-all.ru/3.2/library/decimal.html#decimal.Decimal) `x` с другим числом `y`. Это позволяет избежать путаницы при проверках на равенство между числами разных типов.265266Изменено в версии 3.2: Сравнения смешанных типов между экземплярами [`Decimal`](https://python-all.ru/3.2/library/decimal.html#decimal.Decimal) и другими числовыми типами теперь полностью поддерживаются.267268В дополнение к стандартным числовым свойствам десятичные объекты с плавающей точкой также имеют ряд специализированных методов:269270#### `adjusted()`271272Возвращает скорректированный показатель степени после удаления крайних правых цифр коэффициента, пока не останется только старшая цифра: `Decimal('321e+5').adjusted()` возвращает семь. Используется для определения положения самой значащей цифры относительно десятичной точки.273274#### `as_tuple()`275276Возвращает представление числа в виде [*именованного кортежа*](https://python-all.ru/3.2/glossary.html#term-named-tuple): `DecimalTuple(sign, digits, exponent)`.277278#### `canonical()`279280Возвращает каноническую кодировку аргумента. В настоящее время кодировка экземпляра [`Decimal`](https://python-all.ru/3.2/library/decimal.html#decimal.Decimal) всегда канонична, поэтому эта операция возвращает свой аргумент без изменений.281282#### `compare(other[, context])`283284Сравнивает значения двух экземпляров Decimal. [`compare()`](https://python-all.ru/3.2/library/decimal.html#decimal.Decimal.compare) возвращает экземпляр Decimal, и если любой из операндов является NaN, то результатом будет NaN:285286```python287a or b is a NaN ==> Decimal('NaN')288a < b ==> Decimal('-1')289a == b ==> Decimal('0')290a > b ==> Decimal('1')291```292293#### `compare_signal(other[, context])`294295Эта операция идентична методу [`compare()`](https://python-all.ru/3.2/library/decimal.html#decimal.Decimal.compare), за исключением того, что все NaN сигнализируют. То есть, если ни один операнд не является сигнальным NaN, то любой тихий NaN обрабатывается так, как если бы он был сигнальным NaN.296297#### `compare_total(other)`298299Сравнивает два операнда, используя их абстрактное представление, а не числовое значение. Аналогично методу [`compare()`](https://python-all.ru/3.2/library/decimal.html#decimal.Decimal.compare), но результат даёт полное упорядочение экземпляров [`Decimal`](https://python-all.ru/3.2/library/decimal.html#decimal.Decimal). Два экземпляра [`Decimal`](https://python-all.ru/3.2/library/decimal.html#decimal.Decimal) с одинаковым числовым значением, но разными представлениями сравниваются как неравные в этом упорядочении:300301```python302>>> Decimal('12.0').compare_total(Decimal('12'))303Decimal('-1')304```305306Тихие и сигнальные NaN также включены в полное упорядочение. Результат этой функции равен `Decimal('0')`, если оба операнда имеют одинаковое представление, `Decimal('-1')`, если первый операнд находится ниже в полном порядке, чем второй, и `Decimal('1')`, если первый операнд находится выше в полном порядке, чем второй операнд. Подробнее о полном порядке см. в спецификации.307308#### `compare_total_mag(other)`309310Сравнивает два операнда, используя их абстрактное представление, а не их значение, как в [`compare_total()`](https://python-all.ru/3.2/library/decimal.html#decimal.Decimal.compare_total), но игнорируя знак каждого операнда. `x.compare_total_mag(y)` эквивалентно `x.copy_abs().compare_total(y.copy_abs())`.311312#### `conjugate()`313314Просто возвращает self; этот метод существует только для соответствия спецификации Decimal.315316#### `copy_abs()`317318Возвращает абсолютное значение аргумента. Эта операция не зависит от контекста и является тихой: флаги не изменяются и округление не выполняется.319320#### `copy_negate()`321322Возвращает отрицание аргумента. Эта операция не зависит от контекста и является тихой: флаги не изменяются и округление не выполняется.323324#### `copy_sign(other)`325326Возвращает копию первого операнда со знаком, установленным таким же, как знак второго операнда. Например:327328```python329>>> Decimal('2.3').copy_sign(Decimal('-1.5'))330Decimal('-2.3')331```332333Эта операция не зависит от контекста и является тихой: никакие флаги не изменяются и округление не выполняется.334335#### `exp([context])`336337Возвращает значение (натуральной) показательной функции `e**x` для заданного числа. Результат правильно округляется с использованием режима округления `ROUND_HALF_EVEN`.338339```python340>>> Decimal(1).exp()341Decimal('2.718281828459045235360287471')342>>> Decimal(321).exp()343Decimal('2.561702493119680037517373933E+139')344```345346#### `from_float(f)`347348Метод класса, который преобразует число с плавающей точкой в десятичное число точно.349350Примечание: *Decimal.from\_float(0.1)* не то же самое, что *Decimal('0.1')*. Поскольку 0.1 нельзя точно представить в двоичной арифметике с плавающей точкой, значение хранится как ближайшее представимое значение, равное *0x1.999999999999ap-4*. Эквивалентное десятичное значение – это *0.1000000000000000055511151231257827021181583404541015625*.351352> **Примечание**353>354> Начиная с Python 3.2, экземпляр [`Decimal`](https://python-all.ru/3.2/library/decimal.html#decimal.Decimal) также можно создать напрямую из [`float`](https://python-all.ru/3.2/library/functions.html#float).355356```python357>>> Decimal.from_float(0.1)358Decimal('0.1000000000000000055511151231257827021181583404541015625')359>>> Decimal.from_float(float('nan'))360Decimal('NaN')361>>> Decimal.from_float(float('inf'))362Decimal('Infinity')363>>> Decimal.from_float(float('-inf'))364Decimal('-Infinity')365```366367Новое в версии 3.1.368369#### `fma(other, third[, context])`370371Совмещённое умножение-сложение. Возвращает self\*other+third без округления промежуточного произведения self\*other.372373```python374>>> Decimal(2).fma(3, 5)375Decimal('11')376```377378#### `is_canonical()`379380Возвращает [`True`](https://python-all.ru/3.2/library/constants.html#True), если аргумент каноничен, и [`False`](https://python-all.ru/3.2/library/constants.html#False) в противном случае. В настоящее время экземпляр [`Decimal`](https://python-all.ru/3.2/library/decimal.html#decimal.Decimal) всегда каноничен, поэтому эта операция всегда возвращает [`True`](https://python-all.ru/3.2/library/constants.html#True).381382#### `is_finite()`383384Возвращает [`True`](https://python-all.ru/3.2/library/constants.html#True), если аргумент является конечным числом, и [`False`](https://python-all.ru/3.2/library/constants.html#False), если аргумент является бесконечностью или NaN.385386#### `is_infinite()`387388Возвращает [`True`](https://python-all.ru/3.2/library/constants.html#True), если аргумент – положительная или отрицательная бесконечность, и [`False`](https://python-all.ru/3.2/library/constants.html#False) в противном случае.389390#### `is_nan()`391392Возвращает [`True`](https://python-all.ru/3.2/library/constants.html#True), если аргумент – тихий или сигнализирующий NaN, и [`False`](https://python-all.ru/3.2/library/constants.html#False) в противном случае.393394#### `is_normal()`395396Возвращает [`True`](https://python-all.ru/3.2/library/constants.html#True), если аргумент – *нормальное* конечное число. Возвращает [`False`](https://python-all.ru/3.2/library/constants.html#False), если аргумент – ноль, субнормальное число, бесконечность или NaN.397398#### `is_qnan()`399400Возвращает [`True`](https://python-all.ru/3.2/library/constants.html#True), если аргумент – тихий NaN, и [`False`](https://python-all.ru/3.2/library/constants.html#False) в противном случае.401402#### `is_signed()`403404Возвращает [`True`](https://python-all.ru/3.2/library/constants.html#True), если аргумент имеет отрицательный знак, и [`False`](https://python-all.ru/3.2/library/constants.html#False) в противном случае. Обратите внимание, что нули и NaN могут иметь знак.405406#### `is_snan()`407408Возвращает [`True`](https://python-all.ru/3.2/library/constants.html#True), если аргумент – сигнализирующий NaN, и [`False`](https://python-all.ru/3.2/library/constants.html#False) в противном случае.409410#### `is_subnormal()`411412Возвращает [`True`](https://python-all.ru/3.2/library/constants.html#True), если аргумент субнормальный, и [`False`](https://python-all.ru/3.2/library/constants.html#False) в противном случае.413414#### `is_zero()`415416Возвращает [`True`](https://python-all.ru/3.2/library/constants.html#True), если аргумент – (положительный или отрицательный) ноль, и [`False`](https://python-all.ru/3.2/library/constants.html#False) в противном случае.417418#### `ln([context])`419420Return the natural (base e) logarithm of the operand. The result is correctly rounded using the `ROUND_HALF_EVEN` rounding mode.421422#### `log10([context])`423424Return the base ten logarithm of the operand. The result is correctly rounded using the `ROUND_HALF_EVEN` rounding mode.425426#### `logb([context])`427428Для ненулевого числа возвращает скорректированный порядок операнда в виде экземпляра [`Decimal`](https://python-all.ru/3.2/library/decimal.html#decimal.Decimal). Если операнд – ноль, то возвращается `Decimal('-Infinity')` и поднимается флаг [`DivisionByZero`](https://python-all.ru/3.2/library/decimal.html#decimal.DivisionByZero). Если операнд – бесконечность, то возвращается `Decimal('Infinity')`.429430#### `logical_and(other[, context])`431432[`logical_and()`](https://python-all.ru/3.2/library/decimal.html#decimal.Decimal.logical_and) – логическая операция, принимающая два *логических операнда* (см. [*Логические операнды*](https://python-all.ru/3.2/library/decimal.html#logical-operands-label)). Результатом является поразрядное `И` двух операндов.433434#### `logical_invert([context])`435436[`logical_invert()`](https://python-all.ru/3.2/library/decimal.html#decimal.Decimal.logical_invert) – логическая операция. Результатом является поразрядная инверсия операнда.437438#### `logical_or(other[, context])`439440[`logical_or()`](https://python-all.ru/3.2/library/decimal.html#decimal.Decimal.logical_or) – логическая операция, принимающая два *логических операнда* (см. [*Логические операнды*](https://python-all.ru/3.2/library/decimal.html#logical-operands-label)). Результатом является поразрядное `ИЛИ` двух операндов.441442#### `logical_xor(other[, context])`443444[`logical_xor()`](https://python-all.ru/3.2/library/decimal.html#decimal.Decimal.logical_xor) – логическая операция, принимающая два *логических операнда* (см. [*Логические операнды*](https://python-all.ru/3.2/library/decimal.html#logical-operands-label)). Результатом является поразрядное исключающее ИЛИ двух операндов.445446#### `max(other[, context])`447448Подобно `max(self, other)`, за исключением того, что правило округления контекста применяется перед возвратом, и что значения `NaN` либо сигнализируются, либо игнорируются (в зависимости от контекста и от того, являются ли они сигнализирующими или тихими).449450#### `max_mag(other[, context])`451452Похож на метод [`max()`](https://python-all.ru/3.2/library/decimal.html#decimal.Decimal.max), но сравнение выполняется с использованием абсолютных значений операндов.453454#### `min(other[, context])`455456Как и `min(self, other)`, но с одним отличием: правило округления контекста применяется перед возвратом результата, а значения `NaN` либо сигнализируются, либо игнорируются (в зависимости от контекста и от того, являются ли они сигнальными или тихими).457458#### `min_mag(other[, context])`459460Похож на метод [`min()`](https://python-all.ru/3.2/library/decimal.html#decimal.Decimal.min), но сравнение выполняется с использованием абсолютных значений операндов.461462#### `next_minus([context])`463464Возвращает наибольшее число, представимое в заданном контексте (или в контексте текущего потока, если контекст не задан), которое меньше заданного операнда.465466#### `next_plus([context])`467468Возвращает наименьшее число, представимое в заданном контексте (или в контексте текущего потока, если контекст не задан), которое больше заданного операнда.469470#### `next_toward(other[, context])`471472Если два операнда не равны, возвращает число, ближайшее к первому операнду в направлении второго операнда. Если оба операнда численно равны, возвращает копию первого операнда со знаком, установленным таким же, как знак второго операнда.473474#### `normalize([context])`475476Нормализует число, удаляя конечные нули справа и преобразуя любой результат, равный `Decimal('0')`, в `Decimal('0e0')`. Используется для получения канонических значений атрибутов класса эквивалентности. Например, `Decimal('32.100')` и `Decimal('0.321000e+2')` оба нормализуются до эквивалентного значения `Decimal('32.1')`.477478#### `number_class([context])`479480Возвращает строку, описывающую *класс* операнда. Возвращаемое значение является одной из следующих десяти строк.481482- `"-Infinity"` – указывает, что операнд является отрицательной бесконечностью.483- `"-Normal"` – указывает, что операнд является отрицательным нормальным числом.484- `"-Subnormal"` – указывает, что операнд отрицателен и является субнормальным.485- `"-Zero"` – указывает, что операнд является отрицательным нулём.486- `"+Zero"` – указывает, что операнд является положительным нулём.487- `"+Subnormal"` – указывает, что операнд положителен и является субнормальным.488- `"+Normal"` – указывает, что операнд является положительным нормальным числом.489- `"+Infinity"` – указывает, что операнд является положительной бесконечностью.490- `"NaN"` – указывает, что операнд является тихим NaN (не числом).491- `"sNaN"` – указывает, что операнд является сигнальным NaN.492493#### `quantize(exp[, rounding[, context[, watchexp]]])`494495Возвращает значение, равное первому операнду после округления и имеющее экспоненту второго операнда.496497```python498>>> Decimal('1.41421356').quantize(Decimal('1.000'))499Decimal('1.414')500```501502В отличие от других операций, если длина коэффициента после операции quantize превышает точность, то сигнализируется [`InvalidOperation`](https://python-all.ru/3.2/library/decimal.html#decimal.InvalidOperation). Это гарантирует, что при отсутствии ошибки квантованный порядок всегда равен порядку правого операнда.503504Также, в отличие от других операций, quantize никогда не сигнализирует Underflow, даже если результат субнормален и неточен.505506Если порядок второго операнда больше порядка первого, то может потребоваться округление. В этом случае режим округления определяется аргументом `rounding`, если он задан, иначе – аргументом `context`; если не задан ни один аргумент, используется режим округления контекста текущего потока.507508Если *watchexp* установлен (по умолчанию), то ошибка возвращается всякий раз, когда результирующий порядок больше `Emax` или меньше `Etiny`.509510#### `radix()`511512Возвращает `Decimal(10)` – основание системы счисления (базу), в которой класс [`Decimal`](https://python-all.ru/3.2/library/decimal.html#decimal.Decimal) выполняет все свои арифметические операции. Включён для совместимости со спецификацией.513514#### `remainder_near(other[, context])`515516Возвращает остаток от деления *self* на *other*. Отличается от `self % other` тем, что знак остатка выбирается так, чтобы минимизировать его абсолютное значение. Точнее, возвращаемое значение равно `self - n * other`, где `n` – целое число, ближайшее к точному значению `self / other`, а если два целых числа одинаково близки, то выбирается чётное.517518Если результат равен нулю, его знак будет знаком *self*.519520```python521>>> Decimal(18).remainder_near(Decimal(10))522Decimal('-2')523>>> Decimal(25).remainder_near(Decimal(10))524Decimal('5')525>>> Decimal(35).remainder_near(Decimal(10))526Decimal('-5')527```528529#### `rotate(other[, context])`530531Возвращает результат вращения цифр первого операнда на величину, заданную вторым операндом. Второй операнд должен быть целым числом в диапазоне от -precision до precision. Абсолютное значение второго операнда задаёт количество позиций для вращения. Если второй операнд положителен, вращение выполняется влево; в противном случае вращение выполняется вправо. Коэффициент первого операнда при необходимости дополняется слева нулями до длины precision. Знак и экспонента первого операнда не изменяются.532533#### `same_quantum(other[, context])`534535Проверяет, имеют ли self и other одинаковую экспоненту или оба являются `NaN`.536537#### `scaleb(other[, context])`538539Возвращает первый операнд с экспонентой, скорректированной на второй. Эквивалентно умножению первого операнда на `10**other`. Второй операнд должен быть целым числом.540541#### `shift(other[, context])`542543Возвращает результат сдвига цифр первого операнда на величину, заданную вторым операндом. Второй операнд должен быть целым числом в диапазоне от -precision до precision. Абсолютное значение второго операнда задаёт количество позиций для сдвига. Если второй операнд положителен, сдвиг выполняется влево; в противном случае сдвиг выполняется вправо. Вдвигаемые в коэффициент цифры являются нулями. Знак и экспонента первого операнда не изменяются.544545#### `sqrt([context])`546547Возвращает квадратный корень аргумента с полной точностью.548549#### `to_eng_string([context])`550551Преобразует в строку инженерного типа.552553В инженерной нотации показатель степени кратен 3, поэтому слева от десятичной запятой может быть до 3 цифр. Например, преобразует `Decimal('123E+1')` в `Decimal('1.23E+3')`554555#### `to_integral([rounding[, context]])`556557Идентичен методу [`to_integral_value()`](https://python-all.ru/3.2/library/decimal.html#decimal.Decimal.to_integral_value). Имя `to_integral` сохранено для совместимости со старыми версиями.558559#### `to_integral_exact([rounding[, context]])`560561Округляет до ближайшего целого, сигнализируя [`Inexact`](https://python-all.ru/3.2/library/decimal.html#decimal.Inexact) или [`Rounded`](https://python-all.ru/3.2/library/decimal.html#decimal.Rounded) в зависимости от того, произошло ли округление. Режим округления определяется параметром `rounding`, если он задан, иначе – заданным `context`. Если ни один параметр не задан, используется режим округления текущего контекста.562563#### `to_integral_value([rounding[, context]])`564565Округляет до ближайшего целого без сигнализации [`Inexact`](https://python-all.ru/3.2/library/decimal.html#decimal.Inexact) или [`Rounded`](https://python-all.ru/3.2/library/decimal.html#decimal.Rounded). Если задан, применяет *rounding*; в противном случае использует метод округления из предоставленного *context* или текущего контекста.566567### 8.4.2.1. Логические операнды568569Методы `logical_and()`, `logical_invert()`, `logical_or()` и `logical_xor()` ожидают, что их аргументы являются *логическими операндами*. *Логический операнд* – это экземпляр [`Decimal`](https://python-all.ru/3.2/library/decimal.html#decimal.Decimal), у которого экспонента и знак равны нулю, а цифры – либо `0`, либо `1`.570571## 8.4.3. Объекты контекста572573Контексты – это среды для арифметических операций. Они управляют точностью, задают правила округления, определяют, какие сигналы обрабатываются как исключения, и ограничивают диапазон для экспонент.574575Каждый поток имеет свой собственный текущий контекст, доступ к которому осуществляется или изменяется с помощью функций [`getcontext()`](https://python-all.ru/3.2/library/decimal.html#decimal.getcontext) и [`setcontext()`](https://python-all.ru/3.2/library/decimal.html#decimal.setcontext).576577#### `decimal.getcontext()`578579Возвращает текущий контекст активного потока.580581#### `decimal.setcontext(c)`582583Устанавливает текущий контекст активного потока в *c*.584585Также можно использовать оператор [`with`](https://python-all.ru/3.2/reference/compound_stmts.html#with) и функцию [`localcontext()`](https://python-all.ru/3.2/library/decimal.html#decimal.localcontext) для временного изменения активного контекста.586587#### `decimal.localcontext([c])`588589Возвращает менеджер контекста, который устанавливает текущий контекст для активного потока в копию *c* при входе в оператор with и восстанавливает предыдущий контекст при выходе из оператора with. Если контекст не указан, используется копия текущего контекста.590591Например, следующий код устанавливает текущую точность десятичных чисел в 42 знака, выполняет вычисление и затем автоматически восстанавливает предыдущий контекст:592593```python594from decimal import localcontext595596with localcontext() as ctx:597 ctx.prec = 42 # Выполнить вычисление с высокой точностью598 s = calculate_something()599s = +s # Округлить конечный результат до стандартной точности600```601602Новые контексты также можно создавать с помощью конструктора [`Context`](https://python-all.ru/3.2/library/decimal.html#decimal.Context), описанного ниже. Кроме того, модуль предоставляет три готовых контекста:603604#### `class decimal.BasicContext`605606Это стандартный контекст, определённый в спецификации General Decimal Arithmetic. Точность установлена в девять. Округление установлено в `ROUND_HALF_UP`. Все флаги сброшены. Все ловушки включены (обрабатываются как исключения), за исключением [`Inexact`](https://python-all.ru/3.2/library/decimal.html#decimal.Inexact), [`Rounded`](https://python-all.ru/3.2/library/decimal.html#decimal.Rounded) и [`Subnormal`](https://python-all.ru/3.2/library/decimal.html#decimal.Subnormal).607608Поскольку многие ловушки включены, этот контекст полезен для отладки.609610#### `class decimal.ExtendedContext`611612Это стандартный контекст, определённый в спецификации General Decimal Arithmetic. Точность установлена в девять. Округление установлено в `ROUND_HALF_EVEN`. Все флаги сброшены. Ловушки не включены (так что исключения не возбуждаются при вычислениях).613614Поскольку ловушки отключены, этот контекст полезен для приложений, которые предпочитают получать значение `NaN` или `Infinity` вместо вызова исключений. Это позволяет приложению завершить выполнение при наличии условий, которые в противном случае остановили бы программу.615616#### `class decimal.DefaultContext`617618Этот контекст используется конструктором [`Context`](https://python-all.ru/3.2/library/decimal.html#decimal.Context) в качестве прототипа для новых контекстов. Изменение поля (например, точности) меняет значение по умолчанию для новых контекстов, создаваемых конструктором [`Context`](https://python-all.ru/3.2/library/decimal.html#decimal.Context).619620Этот контекст наиболее полезен в многопоточных средах. Изменение одного из полей до запуска потоков приводит к установке общесистемных значений по умолчанию. Изменять поля после запуска потоков не рекомендуется, так как это потребовало бы синхронизации потоков для предотвращения состояний гонки.621622В однопоточных средах лучше вообще не использовать этот контекст. Вместо этого просто создавайте контексты явно, как описано ниже.623624Значения по умолчанию: precision=28, rounding=ROUND\_HALF\_EVEN, включены ловушки для Overflow, InvalidOperation и DivisionByZero.625626В дополнение к трём предоставленным контекстам новые контексты можно создавать с помощью конструктора [`Context`](https://python-all.ru/3.2/library/decimal.html#decimal.Context).627628#### `class decimal.Context(prec=None, rounding=None, traps=None, flags=None, Emin=None, Emax=None, capitals=None, clamp=None)`629630Создаёт новый контекст. Если поле не указано или равно [`None`](https://python-all.ru/3.2/library/constants.html#None), значения по умолчанию копируются из [`DefaultContext`](https://python-all.ru/3.2/library/decimal.html#decimal.DefaultContext). Если поле *flags* не указано или равно [`None`](https://python-all.ru/3.2/library/constants.html#None), все флаги сбрасываются.631632Поле *prec* – это положительное целое число, которое задаёт точность арифметических операций в контексте.633634Параметр *rounding* может принимать одно из следующих значений:635636- `ROUND_CEILING` (в сторону `Infinity`),637- `ROUND_DOWN` (в сторону нуля),638- `ROUND_FLOOR` (в сторону `-Infinity`),639- `ROUND_HALF_DOWN` (к ближайшему, при равенстве – в сторону нуля),640- `ROUND_HALF_EVEN` (к ближайшему, при равенстве – к ближайшему чётному целому),641- `ROUND_HALF_UP` (к ближайшему, при равенстве – от нуля), или642- `ROUND_UP` (от нуля).643- `ROUND_05UP` (от нуля, если последняя цифра после округления в сторону нуля была бы 0 или 5; в противном случае – к нулю)644645Поля *traps* и *flags* содержат список сигналов, которые необходимо установить. Как правило, для новых контекстов следует задавать только ловушки (traps), а флаги (flags) оставлять сброшенными.646647Поля *Emin* и *Emax* – это целые числа, задающие допустимые внешние границы для показателей степени.648649Поле *capitals* может быть равно `0` или `1` (по умолчанию). Если установлено в `1`, показатели степени выводятся с заглавной `E`; в противном случае используется строчная `e`: `Decimal('6.02e+23')`.650651Поле *clamp* может быть равно `0` (по умолчанию) или `1`. Если установлено в `1`, показатель степени `e` экземпляра [`Decimal`](https://python-all.ru/3.2/library/decimal.html#decimal.Decimal), представимого в этом контексте, строго ограничивается диапазоном `Emin - prec + 1 <= e <= Emax - prec + 1`. Если *clamp* равно `0`, то выполняется более слабое условие: скорректированный показатель степени экземпляра [`Decimal`](https://python-all.ru/3.2/library/decimal.html#decimal.Decimal) не превышает `Emax`. Когда *clamp* равно `1`, большое нормальное число, по возможности, уменьшает свой показатель степени и добавляет соответствующее количество нулей к коэффициенту, чтобы соблюсти ограничения на показатель степени; это сохраняет значение числа, но теряет информацию о значимых конечных нулях. Например:652653```python654>>> Context(prec=6, Emax=999, clamp=1).create_decimal('1.23e999')655Decimal('1.23000E+999')656```657658Значение *clamp*, равное `1`, обеспечивает совместимость с форматами обмена десятичными числами фиксированной ширины, определёнными в IEEE 754.659660Класс [`Context`](https://python-all.ru/3.2/library/decimal.html#decimal.Context) определяет несколько методов общего назначения, а также большое количество методов для непосредственного выполнения арифметических операций в заданном контексте. Кроме того, для каждого из методов [`Decimal`](https://python-all.ru/3.2/library/decimal.html#decimal.Decimal), описанных выше (за исключением методов `adjusted()` и `as_tuple()`), существует соответствующий метод [`Context`](https://python-all.ru/3.2/library/decimal.html#decimal.Context). Например, для экземпляра [`Context`](https://python-all.ru/3.2/library/decimal.html#decimal.Context) `C` и экземпляра [`Decimal`](https://python-all.ru/3.2/library/decimal.html#decimal.Decimal) `x` вызов `C.exp(x)` эквивалентен `x.exp(context=C)`. Каждый метод [`Context`](https://python-all.ru/3.2/library/decimal.html#decimal.Context) принимает целое число Python (экземпляр [`int`](https://python-all.ru/3.2/library/functions.html#int)) везде, где ожидается экземпляр Decimal.661662#### `clear_flags()`663664Сбрасывает все флаги в `0`.665666#### `copy()`667668Возвращает копию контекста.669670#### `copy_decimal(num)`671672Возвращает копию экземпляра Decimal num.673674#### `create_decimal(num)`675676Создаёт новый экземпляр Decimal из *num*, используя *self* в качестве контекста. В отличие от конструктора [`Decimal`](https://python-all.ru/3.2/library/decimal.html#decimal.Decimal), при преобразовании применяются точность контекста, метод округления, флаги и ловушки.677678Это полезно, поскольку константы часто задаются с большей точностью, чем требуется приложению. Ещё одно преимущество в том, что округление немедленно устраняет нежелательные эффекты от цифр за пределами текущей точности. В следующем примере использование неокруглённых входных данных означает, что добавление нуля к сумме может изменить результат:679680```python681>>> getcontext().prec = 3682>>> Decimal('3.4445') + Decimal('1.0023')683Decimal('4.45')684>>> Decimal('3.4445') + Decimal(0) + Decimal('1.0023')685Decimal('4.44')686```687688Этот метод реализует операцию преобразования в число из спецификации IBM. Если аргумент – строка, начальные и конечные пробелы не допускаются.689690#### `create_decimal_from_float(f)`691692Создаёт новый экземпляр Decimal из числа с плавающей запятой *f*, выполняя округление с использованием *self* в качестве контекста. В отличие от метода класса [`Decimal.from_float()`](https://python-all.ru/3.2/library/decimal.html#decimal.Decimal.from_float), при преобразовании применяются точность контекста, метод округления, флаги и ловушки.693694```python695>>> context = Context(prec=5, rounding=ROUND_DOWN)696>>> context.create_decimal_from_float(math.pi)697Decimal('3.1415')698>>> context = Context(prec=5, traps=[Inexact])699>>> context.create_decimal_from_float(math.pi)700Traceback (most recent call last):701 ...702decimal.Inexact: None703```704705Новое в версии 3.1.706707#### `Etiny()`708709Возвращает значение, равное `Emin - prec + 1`, которое является минимальным значением показателя степени для субнормальных результатов. В случае антипереполнения (underflow) показатель степени устанавливается равным [`Etiny`](https://python-all.ru/3.2/library/decimal.html#decimal.Context.Etiny).710711#### `Etop()`712713Возвращает значение, равное `Emax - prec + 1`.714715Обычный подход к работе с десятичными числами – создавать экземпляры [`Decimal`](https://python-all.ru/3.2/library/decimal.html#decimal.Decimal), а затем применять арифметические операции, которые выполняются в текущем контексте активного потока. Альтернативный подход – использовать методы контекста для вычислений в заданном контексте. Эти методы аналогичны методам класса [`Decimal`](https://python-all.ru/3.2/library/decimal.html#decimal.Decimal) и здесь лишь кратко перечислены.716717#### `abs(x)`718719Возвращает абсолютное значение *x*.720721#### `add(x, y)`722723Возвращает сумму *x* и *y*.724725#### `canonical(x)`726727Возвращает тот же объект Decimal *x*.728729#### `compare(x, y)`730731Сравнивает *x* и *y* численно.732733#### `compare_signal(x, y)`734735Сравнивает значения двух операндов численно.736737#### `compare_total(x, y)`738739Сравнивает два операнда по их абстрактному представлению.740741#### `compare_total_mag(x, y)`742743Сравнивает два операнда по их абстрактному представлению, игнорируя знак.744745#### `copy_abs(x)`746747Возвращает копию *x* с установленным в 0 знаком.748749#### `copy_negate(x)`750751Возвращает копию *x* с инвертированным знаком.752753#### `copy_sign(x, y)`754755Копирует знак из *y* в *x*.756757#### `divide(x, y)`758759Возвращает *x*, делённое на *y*.760761#### `divide_int(x, y)`762763Возвращает *x*, делённое на *y*, с усечением до целого.764765#### `divmod(x, y)`766767Делит два числа и возвращает целую часть результата.768769#### `exp(x)`770771Возвращает *e \*\* x*.772773#### `fma(x, y, z)`774775Возвращает *x*, умноженное на *y*, плюс *z*.776777#### `is_canonical(x)`778779Возвращает True, если *x* – каноническое число; иначе False.780781#### `is_finite(x)`782783Возвращает True, если *x* – конечное число; иначе False.784785#### `is_infinite(x)`786787Возвращает True, если *x* – бесконечность; иначе False.788789#### `is_nan(x)`790791Возвращает True, если *x* – qNaN или sNaN; иначе False.792793#### `is_normal(x)`794795Возвращает True, если *x* – нормальное число; иначе False.796797#### `is_qnan(x)`798799Возвращает True, если *x* – тихий NaN; иначе False.800801#### `is_signed(x)`802803Возвращает True, если *x* – отрицательное число; иначе False.804805#### `is_snan(x)`806807Возвращает True, если *x* – сигнальный NaN; иначе False.808809#### `is_subnormal(x)`810811Возвращает True, если *x* – субнормальное число; иначе возвращает False.812813#### `is_zero(x)`814815Возвращает True, если *x* – ноль; иначе возвращает False.816817#### `ln(x)`818819Возвращает натуральный (по основанию e) логарифм *x*.820821#### `log10(x)`822823Возвращает десятичный логарифм *x*.824825#### `logb(x)`826827Возвращает показатель степени величины старшего разряда операнда.828829#### `logical_and(x, y)`830831Применяет логическую операцию *and* к соответствующим цифрам операндов.832833#### `logical_invert(x)`834835Инвертирует все цифры в *x*.836837#### `logical_or(x, y)`838839Применяет логическую операцию *or* к соответствующим цифрам операндов.840841#### `logical_xor(x, y)`842843Применяет логическую операцию *xor* к соответствующим цифрам операндов.844845#### `max(x, y)`846847Сравнивает два числа и возвращает наибольшее.848849#### `max_mag(x, y)`850851Сравнивает числа по модулю (игнорируя знак).852853#### `min(x, y)`854855Сравнивает два числа и возвращает наименьшее.856857#### `min_mag(x, y)`858859Сравнивает числа по модулю (игнорируя знак).860861#### `minus(x)`862863Минус соответствует унарному префиксному оператору минус в Python.864865#### `multiply(x, y)`866867Возвращает произведение *x* и *y*.868869#### `next_minus(x)`870871Возвращает наибольшее представимое число, меньшее чем *x*.872873#### `next_plus(x)`874875Возвращает наименьшее представимое число, большее чем *x*.876877#### `next_toward(x, y)`878879Возвращает число, ближайшее к *x* в направлении к *y*.880881#### `normalize(x)`882883Приводит *x* к простейшей форме.884885#### `number_class(x)`886887Возвращает указание на класс *x*.888889#### `plus(x)`890891Plus соответствует унарному префиксному оператору плюс в Python. Эта операция применяет точность и округление контекста, поэтому она *не* является тождественной операцией.892893#### `power(x, y[, modulo])`894895Возвращает `x`, возведённое в степень `y`, с приведением по модулю `modulo`, если он задан.896897С двумя аргументами вычисляет `x**y`. Если `x` отрицательно, то `y` должно быть целым. Результат будет неточным, если только `y` не является целым и результат конечен и может быть точно выражен в цифрах 'precision'. Результат всегда должен быть правильно округлён в соответствии с режимом округления контекста текущего потока.898899С тремя аргументами вычисляется `(x**y) % modulo`. Для формы с тремя аргументами действуют следующие ограничения:900901> - все три аргумента должны быть целыми902> - `y` должно быть неотрицательным903> - по крайней мере одно из `x` или `y` должно быть ненулевым904> - `modulo` должно быть ненулевым и содержать не более 'precision' цифр905906Значение, полученное из `Context.power(x, y, modulo)`, равно значению, которое было бы получено при вычислении `(x**y) % modulo` с неограниченной точностью, но вычисляется более эффективно. Экспонента результата равна нулю независимо от экспонент `x`, `y` и `modulo`. Результат всегда точен.907908#### `quantize(x, y)`909910Возвращает значение, равное *x* (с округлением), с экспонентой *y*.911912#### `radix()`913914Просто возвращает 10, так как это Decimal, :)915916#### `remainder(x, y)`917918Возвращает остаток от целочисленного деления.919920Знак результата, если он не равен нулю, совпадает со знаком исходного делимого.921922#### `remainder_near(x, y)`923924Возвращает `x - y * n`, где *n* – целое число, ближайшее к точному значению `x / y` (если результат равен 0, его знак будет знаком *x*).925926#### `rotate(x, y)`927928Возвращает циклически сдвинутую копию *x* на *y* раз.929930#### `same_quantum(x, y)`931932Возвращает True, если два операнда имеют одинаковую экспоненту.933934#### `scaleb(x, y)`935936Возвращает первый операнд после добавления второго значения к его экспоненте.937938#### `shift(x, y)`939940Возвращает сдвинутую копию *x* на *y* раз.941942#### `sqrt(x)`943944Квадратный корень неотрицательного числа с точностью контекста.945946#### `subtract(x, y)`947948Возвращает разность *x* и *y*.949950#### `to_eng_string(x)`951952Преобразует число в строку, используя научную нотацию.953954#### `to_integral_exact(x)`955956Округляет до целого.957958#### `to_sci_string(x)`959960Преобразует число в строку, используя научную запись.961962## 8.4.4. Сигналы963964Сигналы представляют условия, возникающие во время вычислений. Каждый соответствует одному флагу контекста и одному включателю ловушки контекста.965966Флаг контекста устанавливается при возникновении условия. После вычисления флаги могут быть проверены в информационных целях (например, чтобы определить, было ли вычисление точным). После проверки флагов необходимо очистить все флаги перед началом следующего вычисления.967968Если для сигнала включён ловушечный переключатель контекста, то условие вызывает возбуждение исключения Python. Например, если установлена ловушка [`DivisionByZero`](https://python-all.ru/3.2/library/decimal.html#decimal.DivisionByZero), то при возникновении условия возбуждается исключение [`DivisionByZero`](https://python-all.ru/3.2/library/decimal.html#decimal.DivisionByZero).969970#### `class decimal.Clamped`971972Изменён показатель степени для соответствия ограничениям представления.973974Обычно усечение (clamping) происходит, когда показатель степени выходит за пределы контекста `Emin` и `Emax`. Если возможно, показатель уменьшается до допустимого значения путём добавления нулей к коэффициенту.975976#### `class decimal.DecimalException`977978Базовый класс для остальных сигналов и подкласс [`ArithmeticError`](https://python-all.ru/3.2/library/exceptions.html#ArithmeticError).979980#### `class decimal.DivisionByZero`981982Сигнализирует о делении небесконечного числа на ноль.983984Может возникнуть при делении, делении по модулю или возведении числа в отрицательную степень. Если эта ловушка не включена, возвращается `Infinity` или `-Infinity`, знак определяется входными данными вычисления.985986#### `class decimal.Inexact`987988Указывает, что произошло округление и результат не является точным.989990Сигнализирует, когда при округлении были отброшены ненулевые цифры. Возвращается округлённый результат. Флаг сигнала или ловушка используется для обнаружения неточных результатов.991992#### `class decimal.InvalidOperation`993994Выполнена недопустимая операция.995996Указывает на то, что была запрошена бессмысленная операция. Если ловушка не включена, возвращается `NaN`. Возможные причины включают:997998```python999Infinity - Infinity10000 * Infinity1001Infinity / Infinity1002x % 01003Infinity % x1004x._rescale( non-integer )1005sqrt(-x) and x > 010060 ** 01007x ** (non-integer)1008x ** Infinity1009```10101011#### `class decimal.Overflow`10121013Числовое переполнение.10141015Указывает, что показатель степени превышает `Emax` после округления. Если ловушка не включена, результат зависит от режима округления: либо округление внутрь до наибольшего представимого конечного числа, либо округление наружу до `Infinity`. В любом случае также сигнализируются [`Inexact`](https://python-all.ru/3.2/library/decimal.html#decimal.Inexact) и [`Rounded`](https://python-all.ru/3.2/library/decimal.html#decimal.Rounded).10161017#### `class decimal.Rounded`10181019Произошло округление, хотя, возможно, информация не была потеряна.10201021Срабатывает при каждом округлении, отбрасывающем цифры, даже если эти цифры нулевые (например, при округлении `5.00` до `5.0`). Если не перехвачено, возвращает результат без изменений. Этот сигнал используется для обнаружения потери значащих цифр.10221023#### `class decimal.Subnormal`10241025Exponent was lower than `Emin` prior to rounding.10261027Возникает, когда результат операции является субнормальным (экспонента слишком мала). Если не перехвачено, возвращает результат без изменений.10281029#### `class decimal.Underflow`10301031Числовое исчерпание с округлением результата до нуля.10321033Occurs when a subnormal result is pushed to zero by rounding. [`Inexact`](https://python-all.ru/3.2/library/decimal.html#decimal.Inexact) and [`Subnormal`](https://python-all.ru/3.2/library/decimal.html#decimal.Subnormal) are also signaled.10341035В следующей таблице приведена иерархия сигналов:10361037```python1038exceptions.ArithmeticError(exceptions.Exception)1039 DecimalException1040 Clamped1041 DivisionByZero(DecimalException, exceptions.ZeroDivisionError)1042 Inexact1043 Overflow(Inexact, Rounded)1044 Underflow(Inexact, Rounded, Subnormal)1045 InvalidOperation1046 Rounded1047 Subnormal1048```10491050## 8.4.5. Примечания по числам с плавающей запятой10511052### 8.4.5.1. Уменьшение ошибки округления за счёт повышенной точности10531054Использование десятичной арифметики с плавающей запятой устраняет ошибку десятичного представления (позволяя точно представить `0.1`); однако некоторые операции всё ещё могут приводить к ошибке округления, когда ненулевые цифры превышают фиксированную точность.10551056Влияние ошибки округления может усиливаться при сложении или вычитании почти компенсирующих друг друга величин, что приводит к потере значимости. Кнут приводит два поучительных примера, в которых округлённая арифметика с плавающей точкой с недостаточной точностью приводит к нарушению ассоциативного и дистрибутивного свойств сложения:10571058```python1059# Примеры из Seminumerical Algorithms, раздел 4.2.2.1060>>> from decimal import Decimal, getcontext1061>>> getcontext().prec = 810621063>>> u, v, w = Decimal(11111113), Decimal(-11111111), Decimal('7.51111111')1064>>> (u + v) + w1065Decimal('9.5111111')1066>>> u + (v + w)1067Decimal('10')10681069>>> u, v, w = Decimal(20000), Decimal(-6), Decimal('6.0000003')1070>>> (u*v) + (u*w)1071Decimal('0.01')1072>>> u * (v+w)1073Decimal('0.0060000')1074```10751076The [`decimal`](https://python-all.ru/3.2/library/decimal.html#module-decimal) module makes it possible to restore the identities by expanding the precision sufficiently to avoid loss of significance:10771078```python1079>>> getcontext().prec = 201080>>> u, v, w = Decimal(11111113), Decimal(-11111111), Decimal('7.51111111')1081>>> (u + v) + w1082Decimal('9.51111111')1083>>> u + (v + w)1084Decimal('9.51111111')1085>>>1086>>> u, v, w = Decimal(20000), Decimal(-6), Decimal('6.0000003')1087>>> (u*v) + (u*w)1088Decimal('0.0060000')1089>>> u * (v+w)1090Decimal('0.0060000')1091```10921093### 8.4.5.2. Особые значения10941095The number system for the [`decimal`](https://python-all.ru/3.2/library/decimal.html#module-decimal) module provides special values including `NaN`, `sNaN`, `-Infinity`, `Infinity`, and two zeros, `+0` and `-0`.10961097Infinities can be constructed directly with: `Decimal('Infinity')`. Also, they can arise from dividing by zero when the [`DivisionByZero`](https://python-all.ru/3.2/library/decimal.html#decimal.DivisionByZero) signal is not trapped. Likewise, when the [`Overflow`](https://python-all.ru/3.2/library/decimal.html#decimal.Overflow) signal is not trapped, infinity can result from rounding beyond the limits of the largest representable number.10981099Бесконечности являются знаковыми (аффинными) и могут использоваться в арифметических операциях, где они трактуются как очень большие неопределённые числа. Например, прибавление константы к бесконечности даёт другой бесконечный результат.11001101Some operations are indeterminate and return `NaN`, or if the [`InvalidOperation`](https://python-all.ru/3.2/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.11021103A 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.11041105The 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.2/library/constants.html#False) (even when doing `Decimal('NaN')==Decimal('NaN')`), while a test for inequality always returns [`True`](https://python-all.ru/3.2/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.2/library/decimal.html#decimal.InvalidOperation) signal if either operand is a `NaN`, and return [`False`](https://python-all.ru/3.2/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.11061107Знаковые нули могут возникать в результате вычислений, приводящих к исчерпанию. Они сохраняют знак, который получился бы, если бы вычисления выполнялись с большей точностью. Поскольку их величина равна нулю, положительный и отрицательный нули считаются равными, а их знак является информационным.11081109Помимо двух знаковых нулей, которые различны, но равны, существуют различные представления нуля с разной точностью, но эквивалентные по значению. К этому нужно немного привыкнуть. Для глаза, привыкшего к нормализованным представлениям чисел с плавающей точкой, не сразу очевидно, что следующее вычисление возвращает значение, равное нулю:11101111```python1112>>> 1 / Decimal('Infinity')1113Decimal('0E-1000000026')1114```11151116## 8.4.6. Работа с потоками11171118Функция [`getcontext()`](https://python-all.ru/3.2/library/decimal.html#decimal.getcontext) обращается к другому объекту [`Context`](https://python-all.ru/3.2/library/decimal.html#decimal.Context) для\\nкаждого потока. Наличие отдельных контекстов для потоков означает, что потоки могут вносить\\nизменения (например, `getcontext.prec=10`) без помех для других потоков.11191120Likewise, the [`setcontext()`](https://python-all.ru/3.2/library/decimal.html#decimal.setcontext) function automatically assigns its target to the current thread.11211122If [`setcontext()`](https://python-all.ru/3.2/library/decimal.html#decimal.setcontext) has not been called before [`getcontext()`](https://python-all.ru/3.2/library/decimal.html#decimal.getcontext), then [`getcontext()`](https://python-all.ru/3.2/library/decimal.html#decimal.getcontext) will automatically create a new context for use in the current thread.11231124The 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.2/library/decimal.html#decimal.getcontext). For example:11251126```python1127# Установить глобальные настройки по умолчанию для всех потоков, которые будут запущены1128DefaultContext.prec = 121129DefaultContext.rounding = ROUND_DOWN1130DefaultContext.traps = ExtendedContext.traps.copy()1131DefaultContext.traps[InvalidOperation] = 11132setcontext(DefaultContext)11331134# После этого потоки можно запускать1135t1.start()1136t2.start()1137t3.start()1138 . . .1139```11401141## 8.4.7. Рецепты11421143Here are a few recipes that serve as utility functions and that demonstrate ways to work with the [`Decimal`](https://python-all.ru/3.2/library/decimal.html#decimal.Decimal) class:11441145```python1146def moneyfmt(value, places=2, curr='', sep=',', dp='.',1147 pos='', neg='-', trailneg=''):1148 """Преобразовать Decimal в строку, отформатированную как денежная сумма.11491150 places: обязательное количество знаков после десятичной точки1151 curr: необязательный символ валюты перед знаком (может быть пустым)1152 sep: необязательный разделитель групп (запятая, точка, пробел или пусто)1153 dp: указатель десятичной точки (запятая или точка)1154 указывать пустым только при places=01155 pos: необязательный знак для положительных чисел: '+', пробел или пусто1156 neg: необязательный знак для отрицательных чисел: '-', '(', пробел или пусто1157 trailneg:необязательный завершающий знак минуса: '-', ')', пробел или пусто11581159 >>> d = Decimal('-1234567.8901')1160 >>> moneyfmt(d, curr='$')1161 '-$1,234,567.89'1162 >>> moneyfmt(d, places=0, sep='.', dp='', neg='', trailneg='-')1163 '1.234.568-'1164 >>> moneyfmt(d, curr='$', neg='(', trailneg=')')1165 '($1,234,567.89)'1166 >>> moneyfmt(Decimal(123456789), sep=' ')1167 '123 456 789.00'1168 >>> moneyfmt(Decimal('-0.02'), neg='<', trailneg='>')1169 '<0.02>'11701171 """1172 q = Decimal(10) ** -places # 2 знака после запятой --> '0.01'1173 sign, digits, exp = value.quantize(q).as_tuple()1174 result = []1175 digits = list(map(str, digits))1176 build, next = result.append, digits.pop1177 if sign:1178 build(trailneg)1179 for i in range(places):1180 build(next() if digits else '0')1181 if places:1182 build(dp)1183 if not digits:1184 build('0')1185 i = 01186 while digits:1187 build(next())1188 i += 11189 if i == 3 and digits:1190 i = 01191 build(sep)1192 build(curr)1193 build(neg if sign else pos)1194 return ''.join(reversed(result))11951196def pi():1197 """Вычислить число Пи с текущей точностью.11981199 >>> print(pi())1200 3.14159265358979323846264338312011202 """1203 getcontext().prec += 2 # дополнительные цифры для промежуточных шагов1204 three = Decimal(3) # подставить "three=3.0" вместо обычных чисел с плавающей точкой1205 lasts, t, s, n, na, d, da = 0, three, 3, 1, 0, 0, 241206 while s != lasts:1207 lasts = s1208 n, na = n+na, na+81209 d, da = d+da, da+321210 t = (t * n) / d1211 s += t1212 getcontext().prec -= 21213 return +s # унарный плюс применяет новую точность12141215def exp(x):1216 """Возвращает e, возведённое в степень x. Тип результата соответствует типу входного значения.12171218 >>> print(exp(Decimal(1)))1219 2.7182818284590452353602874711220 >>> print(exp(Decimal(2)))1221 7.3890560989306502272304274611222 >>> print(exp(2.0))1223 7.389056098931224 >>> print(exp(2+0j))1225 (7.38905609893+0j)12261227 """1228 getcontext().prec += 21229 i, lasts, s, fact, num = 0, 0, 1, 1, 11230 while s != lasts:1231 lasts = s1232 i += 11233 fact *= i1234 num *= x1235 s += num / fact1236 getcontext().prec -= 21237 return +s12381239def cos(x):1240 """Возвращает косинус x, измеренного в радианах.12411242 Аппроксимация рядом Тейлора даёт наилучший результат при малых значениях x.1243 Для больших значений сначала вычислите x = x % (2 * pi).12441245 >>> print(cos(Decimal('0.5')))1246 0.87758256189037271611628158261247 >>> print(cos(0.5))1248 0.877582561891249 >>> print(cos(0.5+0j))1250 (0.87758256189+0j)12511252 """1253 getcontext().prec += 21254 i, lasts, s, fact, num, sign = 0, 0, 1, 1, 1, 11255 while s != lasts:1256 lasts = s1257 i += 21258 fact *= i * (i-1)1259 num *= x * x1260 sign *= -11261 s += num / fact * sign1262 getcontext().prec -= 21263 return +s12641265def sin(x):1266 """Возвращает синус угла x, заданного в радианах.12671268 Аппроксимация рядом Тейлора даёт наилучший результат при малых значениях x.1269 Для больших значений сначала вычислите x = x % (2 * pi).12701271 >>> print(sin(Decimal('0.5')))1272 0.47942553860420300027328793521273 >>> print(sin(0.5))1274 0.4794255386041275 >>> print(sin(0.5+0j))1276 (0.479425538604+0j)12771278 """1279 getcontext().prec += 21280 i, lasts, s, fact, num, sign = 1, 0, x, 1, x, 11281 while s != lasts:1282 lasts = s1283 i += 21284 fact *= i * (i-1)1285 num *= x * x1286 sign *= -11287 s += num / fact * sign1288 getcontext().prec -= 21289 return +s1290```12911292## 8.4.8. Часто задаваемые вопросы по Decimal12931294Q. It is cumbersome to type `decimal.Decimal('1234.5')`. Is there a way to minimize typing when using the interactive interpreter?12951296Ответ. Некоторые пользователи сокращают конструктор до одной буквы:12971298```python1299>>> D = decimal.Decimal1300>>> D('1.23') + D('3.45')1301Decimal('4.68')1302```13031304Вопрос. В приложении с фиксированной запятой с двумя десятичными знаками некоторые входные данные имеют много знаков и нуждаются в округлении. Другие не должны содержать лишних цифр и требуют проверки. Какие методы следует использовать?13051306A. The `quantize()` method rounds to a fixed number of decimal places. If the [`Inexact`](https://python-all.ru/3.2/library/decimal.html#decimal.Inexact) trap is set, it is also useful for validation:13071308```python1309>>> TWOPLACES = Decimal(10) ** -2 # то же, что Decimal('0.01')1310```13111312```python1313>>> # Округлить до двух знаков1314>>> Decimal('3.214').quantize(TWOPLACES)1315Decimal('3.21')1316```13171318```python1319>>> # Проверка, что число не выходит за пределы двух знаков1320>>> Decimal('3.21').quantize(TWOPLACES, context=Context(traps=[Inexact]))1321Decimal('3.21')1322```13231324```python1325>>> Decimal('3.214').quantize(TWOPLACES, context=Context(traps=[Inexact]))1326Traceback (most recent call last):1327 ...1328Inexact: None1329```13301331Вопрос. Получив корректные входные данные с двумя знаками, как поддерживать этот инвариант во всём приложении?13321333A. 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:13341335```python1336>>> a = Decimal('102.72') # Начальные значения чисел с фиксированной точкой1337>>> b = Decimal('3.17')1338>>> a + b # Сложение сохраняет фиксированную точку1339Decimal('105.89')1340>>> a - b1341Decimal('99.55')1342>>> a * 42 # Умножение на целое число – тоже1343Decimal('4314.24')1344>>> (a * b).quantize(TWOPLACES) # Результат умножения на нецелое число нужно квантовать1345Decimal('325.62')1346>>> (b / a).quantize(TWOPLACES) # И квантовать результат деления1347Decimal('0.03')1348```13491350In developing fixed-point applications, it is convenient to define functions to handle the `quantize()` step:13511352```python1353>>> def mul(x, y, fp=TWOPLACES):1354... return (x * y).quantize(fp)1355>>> def div(x, y, fp=TWOPLACES):1356... return (x / y).quantize(fp)1357```13581359```python1360>>> mul(a, b) # Автоматически сохранять фиксированную точку1361Decimal('325.62')1362>>> div(b, a)1363Decimal('0.03')1364```13651366Q. 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?13671368A. The `normalize()` method maps all equivalent values to a single representative:13691370```python1371>>> values = map(Decimal, '200 200.000 2E2 .02E+4'.split())1372>>> [v.normalize() for v in values]1373[Decimal('2E+2'), Decimal('2E+2'), Decimal('2E+2'), Decimal('2E+2')]1374```13751376Вопрос. Некоторые значения decimal всегда выводятся в экспоненциальной записи. Есть ли способ получить неэкспоненциальное представление?13771378A. 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.13791380Если приложению не важно отслеживать значимость, можно легко удалить экспоненту и хвостовые нули, потеряв значимость, но сохранив значение:13811382```python1383>>> def remove_exponent(d):1384... return d.quantize(Decimal(1)) if d == d.to_integral() else d.normalize()1385```13861387```python1388>>> remove_exponent(Decimal('5E+3'))1389Decimal('5000')1390```13911392Q. Is there a way to convert a regular float to a [`Decimal`](https://python-all.ru/3.2/library/decimal.html#decimal.Decimal)?13931394A. Да, любое двоичное число с плавающей точкой может быть точно выражено как Decimal, хотя для точного преобразования может потребоваться больше точности, чем подсказывает интуиция:13951396```python1397>>> Decimal(math.pi)1398Decimal('3.141592653589793115997963468544185161590576171875')1399```14001401Вопрос. В сложном вычислении как я могу убедиться, что не получил ложный результат из-за недостаточной точности или аномалий округления?14021403Ответ. Модуль decimal упрощает проверку результатов. Рекомендуется перезапускать вычисления с большей точностью и различными режимами округления. Сильно различающиеся результаты указывают на недостаточную точность, проблемы с режимом округления, плохо обусловленные входные данные или численно неустойчивый алгоритм.14041405Вопрос. Я заметил, что точность контекста применяется к результатам операций, но не к входным данным. Есть ли что-то, на что следует обращать внимание при смешивании значений разной точности?14061407Ответ. Да. Принцип заключается в том, что все значения считаются точными, как и арифметические операции с ними. Округляются только результаты. Преимущество для входных данных в том, что «что ввёл, то и получил». Недостаток в том, что результаты могут выглядеть странно, если забыть, что входные данные не округлены:14081409```python1410>>> getcontext().prec = 31411>>> Decimal('3.104') + Decimal('2.104')1412Decimal('5.21')1413>>> Decimal('3.104') + Decimal('0.000') + Decimal('2.104')1414Decimal('5.20')1415```14161417Решение – либо увеличить точность, либо принудительно округлить входные данные с помощью унарного плюса:14181419```python1420>>> getcontext().prec = 31421>>> +Decimal('1.23456789') # Унарный плюс вызывает округление1422Decimal('1.23')1423```14241425Alternatively, inputs can be rounded upon creation using the [`Context.create_decimal()`](https://python-all.ru/3.2/library/decimal.html#decimal.Context.create_decimal) method:14261427```python1428>>> Context(prec=5, rounding=ROUND_DOWN).create_decimal('1.2345678')1429Decimal('1.2345')1430```1431