Decimal python что это

1

Decimal python что это

При работе с числами с плавающей точкой (то есть float) мы сталкиваемся с тем, что в результате вычислений мы получаем не совсем верный результат:

Проблему может решить использование функции round() , которая округлит число. Однако есть и другой способ, который заключается в использовании встроенного модуля decimal .

Ключевым компонентом для работы с числами в этом модуле является класс Decimal . Для его применения нам надо создать его объект с помощью конструктора. В конструктор передается строковое значение, которое представляет число:

После этого объект Decimal можно использовать в арифметических операциях:

В операциях с Decimal можно использовать целые числа:

Однако нельзя смешивать в операциях дробные числа float и Decimal:

С помощью дополнительных знаков мы можем определить, сколько будет символов в дробной части числа:

Строка «0.10» определяет два знака в дробной части, даже если последние символы будут представлять ноль. Соответственно «0.100» представляет три знака в дробной части.

Округление чисел

Объекты Decimal имеют метод quantize() , который позволяет округлять числа. В этот метод в качестве первого аргумента передается также объект Decimal, который указывает формат округления числа:

Используемая строка «1.00» указывает, что округление будет идти до двух знаков в дробной части.

По умолчанию округление описывается константой ROUND_HALF_EVEN , при котором округление происходит до ближайшего четного числа, если округляемая часть равна 5. Например:

Стратегия округления передается в качестве второго параметра в quantize.

Строка «1.00» означает, что округление будет идти до двух чисел в дробной части. Но в первом случае «10.025» — вторым знаком идет 2 — четное число, поэтому, несмотря на то, что следующее число 5, двойка не округляется до тройки.

Во втором случае «10.035» — вторым знаком идет 3 — нечетное число, ближайшим четным числом будет 4, поэтому 35 округляется до 40.

Данное поведение при округлении, возможно, не всем покажется желательным, и в этом случае его можно переопределить, использовав одну из следующих констант:

ROUND_HALF_UP : округляет число в сторону повышения, если после него идет число 5 или выше

ROUND_HALF_DOWN : округляет число в сторону повышения, если после него идет число больше 5

ROUND_05UP : округляет 0 до единицы, если после него идет число 5 и выше

ROUND_CEILING : округляет число в большую сторону вне зависимости от того, какое число идет после него

ROUND_FLOOR : не округляет число вне зависимости от того, какое число идет после него

Десятичный модуль(Decimal) Python

В этой статье мы рассмотрим один из интересных модулей — модуль Python Decimal.

Мы часто сталкиваемся с необходимостью поиска функций для выполнения математических операций. Десятичный модуль в Python предоставляет нам все необходимые математические функции.

Что такое десятичный модуль в Python?

Десятичный модуль Python содержит различные функции для обработки числовых данных и выполнения с ними различных математических операций. Используя модуль decimal, мы можем эффективно обрабатывать десятичные числа в программе.

The decimal module предоставляет нам функции для управления и преодоления проблемы точности десятичных значений.

Чтобы использовать функции, нам нужно импортировать модуль, как показано ниже:

Функции и реализация

Различные арифметические операции могут выполняться с десятичными или числовыми данными для улучшения результата.

Мы можем определить числа с десятичной запятой, используя decimal.Decimal() function как показано ниже.

Кроме того, мы можем контролировать значение точности результатов чисел с десятичной запятой, используя встроенную функцию десятичного модуля — decimal.getcontext().prec .

Описанные ниже функции помогают нам выполнять арифметические операции с десятичной запятой эффективно и с большой скоростью.

Функция exp() — вычисление экспоненты

Функция exp() function вычисляет значение экспоненты, то есть e ^ x конкретного числа переданной десятичной точки.

Обратите внимание, что общее количество цифр в нашем выводе равно 5. Это из-за значения точности, которое мы здесь установили.

Следует помнить, что значение точности применяется, когда вы выполняете математические операции с двумя десятичными знаками, а не когда вы напрямую инициируете переменную со значениями, как показано с переменной «no_math» выше.

Функция sqrt() — квадратный корень

Функция sqrt() вычисляет и возвращает значение квадратного корня из переданного десятичного числа.

Снова обратите внимание, как объявленное значение содержит полное десятичное число, в то время как вычисленное значение соответствует нашему набору точности из 3 цифр.

3 Логарифмические функции

Модуль предоставляет нам следующие функции для вычисления логарифмических значений чисел с десятичной запятой:

• decimal.ln();
• decimal.log10().

Функция decimal.ln() function возвращает значение натурального десятичного числа, как показано ниже.

Функция decimal.log10() используется для вычисления значения журнала по основанию 10 переданного ей десятичного числа.

Функция compare()

Функция decimal.compare() function сравнивает два числа с десятичной запятой и возвращает значения в зависимости от условий следующим образом:

• Возвращает -1, если первое десятичное число меньше второго десятичного числа.
• Возвращает 1, если первое десятичное число больше второго десятичного числа.
• Возвращает 0, если оба значения десятичной точки равны.

Функция copy_abs()

Функция decimal.copy_abs() function возвращает абсолютные значения переданного ей десятичного числа со знаком.

Максимальные и минимальные

Десятичный модуль содержит следующие функции для вычисления минимального и максимального значений десятичной запятой.

• Функция min(): возвращает минимум двух десятичных значений.
• Функция max(): возвращает максимальное из двух десятичных значений.

Логические операции с десятичным модулем

Decimal содержит набор встроенных функций для выполнения логических операций с десятичными числами, таких как AND, OR, XOR и т. Д.

decimal — вычисления с заданной точностью

Модуль decimal позволяет устранить недостатки, которые иногда возникают при работе с встроенными числами типа float, а именно:

Начнем с того, что некоторые числа типа float не могут быть точно представлены в двоичной системе счисления, например:

Однако, числа типа Decimal всегда ведут себя как истинные десятичные дроби:

Конечно, такая запись простого выражения кажется неоправданно громоздкой. Но в некоторых ситауциях такая «громоздкость» – это мелочь в сравнении с проблемами, которые могут возникнуть в отсутствии необходимой точности.

Очень часто с числами типа float проблематично выполнять операции сравнения:

Поэтому использование лишь чисел типа float очень затрудняет разработку финансовых приложений.

Еще, ведя денежные расчеты, бывает необходимо отображать значимые разряды, например 1.500 + 1.500 должно быть равно 3.000 , но:

Числа типа float имеют фиксированную точность, в то время как числа типа Decimal настраиваемую:

Кроме того модуль decimal позволяет полность контролировать все вычисления и их точность, т.е. не просто задавать нужное количество цифр после запятой, а именно перехватывать ситуации в которых эта точность нарушается. Что позволяет не просто блокировать неточные операции, но и строить приложения, которые полностью соответствуют Общей спецификации десятичной арифметики.

Устройство модуля decimal

Модуль decimal базируется на трех понятиях: десятичное число, контекст вычислений и сигналы.

Десятичное число в данном модуле относится к немутирующему (неизменяемому) типу данных, т.е. как и все основные числа в Python они не могут быть изменены напрямую. Десятичное число может обладать знаком, состоять из мантисы и экспоненты. Для сохранения значимости конечные нули не усекаются. Такие специальные значения, как -inf, inf и nan так относятся к десятичным числам. В данном модуле значения \(-0\) и \(+0\) считаются различными.

Контекст вычислений определяет точность, правила округления, ограничения на экспоненты, флаги результатов операций и средства активации исключений.

Сигналы – это специальные условия, которые возникают в процессе вычислений. Опционально, данные условия могут рассматриваться, как исключительные (вызывать ошибку) или информационные, а могут и просто игнорироваться.

Каждый сигнал обладает отдельным флагом и активатором его перехвата. При возникновении сигнала, его флаг устанавливается в единицу и если активатор его перехвата так же установлен в единицу, то вызывается исключение. Следует помнить, что значения флагов не сбрасываются после обработки исключений, т.е. каждый раз их значения необходимо сбрасывать.

Как использовать модуль?

Все начинается с импорта модуля:

Я думаю, что вы уже заметили какими громоздкими становятся выражения при использовании данного модуля, поэтому данный способ импорта, является наиболее удобным (хотя и не обязательным).

Следующим шагом (опять же необязательным) может быть просмотр текущего контекста с помощью метода getcontext() :

Ну и чаще всего нас интересует параметр prec , т.е. количество десятичных цифр, доступных для записи числа, сейчас их доступно 28 знаков. Давайте сделаем 15 знаков:

Теперь можем переходить к созданию чисел типа Decimal, а создаются они с помощью одноименного метода Decimal() , которому можно передать, например, число типа int:

Если же передать число типа float, то следует иметь в виду, что число типа Decimal будет создано, не из того числа, которое вы видите, а из того числа, которое хранится в компьютере. Попытаемся сделать число Decimal из постоянной Планка:

Появившийся «хвост» числа как раз и демонстрирует нам то, что с ним происходит после погружения в двоичный мир компьютера и обратного преобразования в десятичную систему счисления. А именно то что конечная десятичная дробь в двоичной системе счисления может быть бесконечной, что приводит к неизбежному округлению и следовательно к потере точности:

Подобного поведения можно избежать если передать Decimal() вместо числа, его строковое представление:

Можно использовать встроенную функцию str() :

А можем и не пользоваться, так как числа типа Decimal поддерживают все математические операции:

В математических выражениях мы можем комбинировать числа типа int с числами типа Decimal:

Есть еще один любопытный способ создания – передача числа в виде кортежа:

Кортеж должен иметь следующий вид (sign, (digit, digit, . digit), m) , где sign – это знак числа: \(0\) – число положительное, \(1\) – отрицательное; digit – это любая десятичная цифра; m – это мантисса.

Значение prec не изменяет количество значимых цифр вводимого числа, но обязательно изменит его после выполнения математических операций:

Надо сказать, что по началу модуль decimal реально кажется громоздким и неуклюжим, но благодаря тому, что он прекрасно поддерживает большинство встроенных функций, это ощущение довольно быстро пропадает. Ниже приведены несколько примеров, которые позволяют в этом убедиться.

Как-то так можно вычислить основание натурального логарифма:

В общем, после импорта библиотеки, числа типа Decimal ведут себя точно так же как встроенные числовые типы, т.е. все привычные действия могут выполняться практически так как мы к этому привыкли. Например, если нам понадобится список десятичных чисел фиксированной длинны то мы можем создать его как-то так с помощью генератора:

Обратите внимание на команду 1*Decimal(random()) , по сути мы добавили умножение на \(1\) только для того что бы сработало ограничение getcontext().prec = 5 , которое как мы помним срабатывает только после выполнения математических операций. Если попробовать обойтись без него, то получится что-то вроде:

В общем, умножение на \(1\) (прибавление \(0\)) распространенная практика. Что ж продолжим, мы создали список data , дальше мы можем проделывать с ним все, к чему привыкли:

Некоторые математические функции реализованы как методы класса Decimal:

Округлить число до необходимого количества значащих цифр можно с помощью метода quantize() :

Всего рассмотренного выше, в принципе, уже достаточно для создания простых и даже финансовых приложений. Но для более сложных вычислений может потребоваться контекст, который должен отвечать специфике задачи. Мы уже видели, что обратиться к контексту и зменять его параметры можно с помощью функции getcontext() . Создать собственный контекст вычислений можно с помощью конструктора Context() , а сделать его активным позволяет функция setcontext() :

Так же в соответствии со стандартом модуль предоставляет два готовых контекста BasicContext и ExtendedContext:

Если приглядеться к BasicContext, то мы увидим что у него установлено гораздо больше сигналов ошибок, что может быть полезно при отладке приложений:

Для мониторинга ошибок или других интересующих нюансов вычислений контексты имеют сигналы, которые отслеживаются с помощью флагов. Данные флаги остаются активными до явного сброса, поэтому для повторного отслеживания интересующих сигналов их нужно явно сбросить. Посмотрите на параметр flags до и после вычислений:

В конечном итоге в списке флагов мы видим, что выполнялось деление на \(0\), что результат был округлен (т.е. цифры за пределами prec были отброшены) и что результат является не точным (т.к. отброшенные цифры не были нулевыми). Как видите информация довольно полезная, но ее нельзя снова отследить пока флаги не сброшены. А сбросить их позволяет метод clear_flags() :

Активировать отдельные ловушки можно с помощью параметра traps :

После установки флага Rounded в активное значение команда Decimal(1)/Decimal(16) выполнилась без ошибки, потому что результат операции входит в диапазон точности prec и следовательно не нуждается в округлении. А вот результат команды Decimal(1)/Decimal(17) должен быть округлен, а значит вызывать ошибку.

Таким образом мы можем перехватывать множество сигналов, что позволяет создавать очень надежные приложения.

Объект Decimal

По умолчанию value = 0 , но это может быть число типа int, float, кортеж или другой объект типа Decimal. Так же это значение может быть строкой, но ее содержание должно соответствовать синтаксису записи чисел типа Decimal. Допустимыми подстроками являются символы знака: ‘-‘ и ‘+’ ; символы цифр: ‘0’ , ‘1’ , ‘2’ , ‘3’ , ‘4’ , ‘5’ , ‘6’ , ‘7’ , ‘8’ , ‘9’ ; строки специальных значений: ‘Infinity’ , ‘Inf’ , ‘NaN’ , ‘Nan’ , ‘sNaN’ , ‘sNan’ . А сами строки могут иметь следующий вид:

Помимо прочего строками могут быть десятичные цифры в виде строк Юникода, в том числе и других алфавитов:

Числа типа float переводятся в числа типа Decimal без потерь, т.е. именно так как они хранятся в памяти компьютера:

Только если значение сигнала FloatOperation установлено в единицу то преобразование приведет к ошибке (по умолчанию сигнал отключен):

Аргумент context позволяет задать поведение для тех случаев когда строка является искаженной. По умолчанию, этот параметр установлен в значение None, что приводит любую невалидную строку в значение NaN:

В случае если параметр context перехватывает сигнал InvalidOperation, то вместо значения NaN появляется сообщение об ошибке:

Ну а значениями данного параметра могут быть только контексты вычислений:

Числа типа Decimal являются немутирующими (неизменяемыми) объектами, т.е. могут быть ключами в словарях:

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

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

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

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

Методы объекта Decimal

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

Параметр context может принимать объект любого контекста вычислений.

Параметр context может принимать объект любого контекста вычислений.

Эта операция не зависит от контекста, т.к. значения NaN включены в общий порядок сравнения. Но если второй операнд не может быть точно представлен то Python реализованный на языке C может вызвать исключение InvalidOperation.

Эта операция не зависит от контекста, т.к. значения NaN включены в общий порядок сравнения. Но если второй операнд не может быть точно представлен то Python реализованный на языке C может вызвать исключение InvalidOperation.

Параметр context может принимать объект любого контекста вычислений.

Некоторые числа типа float, не имеют точного представления в двоичной системе (являются бесконечными дробями) поэтому в памяти компьютера они всегда хранятся с некоторой погрешностью:

Параметр context может принимать объект любого контекста вычислений.

Параметр context может принимать объект любого контекста вычислений.

Параметр context может принимать объект любого контекста вычислений.

Если операнд равен \(0\), то возвращается Decimal(‘-Infinity’) и вызывается исключение DivisionByZero. Если операнд равен бесконечности, то так же возвращается бесконечность.

Параметр context может принимать объект любого контекста вычислений.

Логические операнды

Числа типа Decimal могут восприниматься как логические значения если их знак и экспонента равны \(0\), а все остальные цифры состоят только из \(0\) и \(1\). Например, число Decimal((0, (1, 1, 0, 1), 0)) или Decimal(‘1101’) можно спокойно считать логическими и передавать их логическим функциям.

Параметр context может принимать объект любого контекста вычислений.

Параметр context может принимать объект любого контекста вычислений.

Параметр context может принимать объект любого контекста вычислений.

Параметр context может принимать объект любого контекста вычислений.

Сравнения «больше/меньше»

Параметр context может принимать объект любого контекста вычислений.

Параметр context может принимать объект любого контекста вычислений.

Параметр context может принимать объект любого контекста вычислений.

Параметр context может принимать объект любого контекста вычислений.

Приращения аргументов

В отличие от других опраций округления, данный метод никогда не сигнализирует о потере точности.

Объекты контекста

Контексты – это среды в которых выполняются арифметические операции. Контексты определяют с какой точностью будут выполняться вычисления, как будет происходить округление чисел, какие сигналы рассматривать как исключения, а какие игнорировать.

Каждый поток имеет свой собственный контекст, который можно изменить или установить с помощью функций getcontext() или setcontext()

Если какое-то поле не указано, то оно по умолчанию заменяется на значение из контекста DefaultContext. Если поле флагов не указано или отсутствует, то это приводит к очистке флагов.

prec — это целое число, которое задает точность арифметических операций в контексте. Данное число может принимать значения из интервала [0, MAX_PREC] .

rounding позволяет задать режим округления.

Поля traps и flags являются списками с сигналами и статусами их отслеживания.

Поля Emin и Emax являются целыми числами, задающими пределы для показателя степени. Значения Emin лежат в диапазоне [MIN_EMIN, 0] , а значения Emax в диапазоне [0, MAX_EMAX] .

Поле capitals определяет как выводить символ степени. По умолчанию это значение установлено в \(1\), что соответствует использованию заглавной буквы E , а \(0\) приводит к использованию строчной буквы e .

Поле clamp может быть равно либо \(1\) либо \(0\) по умолчанию. Если установлено в \(1\), экспонента — e десятичного числа в текущем контексте может находиться только в интервале [Emin — prec + 1, Emax — prec + 1] . Если clamp = 0 то показатель степени просто не превосходит Emax . Когда clamp = 1 то его показатель степени будет уменьшаться а к коэффициенту добавляться соответствующее число нулей, таким образом это позволяет соответствовать ограничениям показателям степени, но приводит к потере информации о количестве значащих нулей справа:

Значение clamp = 1 обеспечивает совместимость с числами с плавающей точкой фиксированной длинны, которые указаны в IEEE 754.

Что бы временно изменить контекст можно воспользоваться оператором with и функцией localcontext() .

Методы класса Context

Так же как и класс Decimal , класс Context определяет все теже самые методы (кроме методов adjusted() и as_tuple() ). Например, если у нас имеется экземпляр контекста my_context , то выполнение экспоненциирования, как метода класса Decimal будет эквивалентно выполнению этой же операции как метода класса Context :

Методы класса Context также как и методы класса Decimal могут принимать числа типа int.

decimal — Десятичная арифметика с фиксированной и плавающей точкой¶

Модуль decimal предоставляет поддержку быстрой и корректно округляемой десятичной арифметики с плавающей точкой. Это предлагает несколько преимуществ перед типом данных float :

Десятичная «основана на модели с плавающей точкой, которая была разработана для людей и обязательно включает главный руководящий принцип — компьютеры должны обеспечивать арифметику, которая работает так же, как арифметика, которую люди учат в школе». — отрывок из десятичной арифметической спецификации.

Десятичные числа могут быть представлены точно. Напротив, такие числа, как 1.1 и 2.2 , не имеют точных представлений в двоичной плавающей точке. Конечные пользователи обычно не ожидают, что 1.1 + 2.2 будет отображаться так же 3.3000000000000003 , как и с двоичной плавающей точкой.

Точность переносится в арифметику. В десятичной плавающей точке 0.1 + 0.1 + 0.1 — 0.3 точно равен нулю. В двоичной плавающей точке результат равен 5.5511151231257827e-017 . Хотя различия близки к нулю, они препятствуют надежному тестированию на равенство и могут накапливать различия. По этой причине в приложениях учета, имеющих инварианты строгого равенства, предпочтительно использовать десятичное число.

Модуль decimal включает понятие значительных мест, так что 1.30 + 1.20 является 2.50 . Конечный ноль сохраняется для указания значимости. Это обычное представление для денежного применения. Для умножения в подходе «школьная книга» используются все цифры в множителях. Для сущность, 1.3 * 1.2 дает 1.56 , в то время как 1.30 * 1.20 дает 1.5600 .

В отличие от аппаратных двоичных модулей с плавающей точкой, десятичный модуль имеет изменяемую пользователем точность (значение по умолчанию — 28 разрядов), которая может быть настолько велика, насколько это необходимо для данной задачи:

Как двоичная, так и десятичная плавающая точка реализованы в терминах опубликованных стандартов. В то время как встроенный тип float предоставляет лишь скромную часть своих возможностей, десятичный модуль предоставляет все необходимые части стандарта. При необходимости программист полностью контролирует округление и обработку сигналов. Это включает возможность применения точной арифметики с помощью исключений для блокирования любых неточных операций.

Модуль decimal был разработан для поддержки «без предубеждений, как точной неокругляемой десятичной арифметики (иногда называемой арифметикой с фиксированной точкой), так и округляемой арифметики с плавающей точкой». — отрывок из спецификации десятичной арифметически.

Конструкция модуля сосредоточена вокруг трех понятий: десятичное число, арифметический контекст и сигналы.

Десятичное число является неизменяемым. У него есть знак, цифры коэффициента и степень. Для сохранения значимости цифры коэффициента не усекают конечные нули. Десятичные разряды также включают специальные значения, такие как Infinity , -Infinity и NaN . Стандарт также отличает -0 от +0 .

Арифметический контекст — точность определяемая средой, правила округления, пределы экспоненты, флаги, указывающие на результаты операций и инструменты реализации ловушки, которые определяют, рассматривают ли сигналы как исключения. Опции округления включают ROUND_CEILING , ROUND_DOWN , ROUND_FLOOR , ROUND_HALF_DOWN , ROUND_HALF_EVEN , ROUND_HALF_UP , ROUND_UP и ROUND_05UP .

Сигналы представляют собой группы исключительных условий, возникающих в процессе вычисления. В зависимости от потребностей приложения сигналы могут игнорироваться, рассматриваться как информационные или рассматриваться как исключения. Сигналы в decimal модуле: Clamped , InvalidOperation , DivisionByZero , Inexact , Rounded , Subnormal , Overflow , Underflow и FloatOperation .

Для каждого сигнала имеется флаг и активатор ловушки. При обнаружении сигнала его флаг устанавливается в единицу, тогда, если активатор ловушки установлен в единицу, поднимается исключение. Флаги являются липкими, поэтому пользователю необходимо сбросить их перед мониторингом вычислений.

• Спецификация общей десятичной арифметики IBM, Общая спецификация десятичной арифметики.

Учебник для быстрого старта¶

Обычное начало использования десятичных чисел начинается с импортирования модуля, рассматривая текущий контекст с getcontext() и, при необходимости, устанавливая новый значения для точности, округления или активацию ловушек:

Десятичные сущности могут быть построены из целых чисел, строк, плавающих или кортежей. Построение из целого числа или числа с плавающей точкой выполняет точное преобразование значение этого целого числа или числа с плавающей точкой. Десятичные числа включают специальные значения, такие как NaN , что означает «Не число», положительное и отрицательное Infinity и -0 :

Если сигнал FloatOperation захвачен, случайное смешение десятичных разрядов и плавающих чисел в конструкторах или сравнение порядка поднимает исключение:

Добавлено в версии 3.3.

Значимость нового десятичного знака определяется исключительно количеством введенных цифр. Точность контекста и округление вступают в действие только во время арифметических операций.

Если внутренние пределы версии C превышены, строение десятичного числа поднимет InvalidOperation :

Изменено в версии 3.3.

Децималы хорошо взаимодействуют с большей частью остального Python. Вот небольшой десятичный летающий цирк с плавающей точкой:

Некоторые математические функции также доступны для Decimal:

Метод quantize() округляет число до фиксированной степени. Этот метод полезен для монетарных приложений, которые часто округляют результаты до фиксированного количества мест:

Как показано выше, функция getcontext() осуществляет доступ к текущему контексту и позволяет изменять настройки. Этот подход отвечает потребностям большинства приложений.

Для более продвинутой работы может быть полезно создать альтернативные контексты с помощью конструктора Context(). Чтобы сделать альтернативу активной, используйте функцию setcontext() .

В соответствии со стандартом модуль decimal предоставляет два готовых к использованию стандартных контекста: BasicContext и ExtendedContext . Первое особенно полезно для отладки, так как многие ловушки включены:

Контексты также имеют сигнальные флаги для мониторинга исключительных условий, встречающихся во время вычислений. Флаги остаются установленными до явного сброса, поэтому лучше очистить флаги перед каждым набором контролируемых вычислений с помощью метода clear_flags() :

Запись flags показывает, что рациональное приближение к Pi было округлено (цифры сверх точности контекст были выброшены) и что результат неточен (некоторые отброшенные цифры были ненулевыми).

Отдельные ловушки устанавливаются с помощью словаря в поле traps контекста:

Большинство программ регулирует текущий контекст только однажды, в начале программы. И во многих приложениях данные преобразуются в Decimal с одним приведением внутри цикла. С набором контекст и созданными десятичными числами, большая часть программы управляет данными не иначе, чем с другими числовыми типами Python.

Объекты Decimal¶

Создать новый объект Decimal на основе value.

value может быть целым числом, строка, кортежем, float или другим объектом Decimal . Если не передан value, возвращается Decimal(‘0’) . Если value является строкой, она должна соответствовать десятичному числовому синтаксису строки после удаления начальных и конечных символов пробела, а также знаков подчеркивания:

Другие десятичные цифры Юникода также разрешены там, где digit отображается выше. К ним относятся десятичные цифры из различных других алфавитов (например, арабско-индские и деванагарские цифры) вместе с полноширотными цифрами ‘\uff10’ — ‘\uff19’ .

Если value является tuple , у него должны быть три компонента, знак ( 0 для положительного или 1 для отрицательного), tuple цифр и целое число. Например, Decimal((0, (1, 4, 1, 4), -3)) возвращает Decimal(‘1.414’) .

Если value является float , двоичный значение с плавающей точкой без потерь преобразуется в его точный десятичный эквивалент. Это преобразование часто требует 53 или более цифр точности. Например, Decimal(float(‘1.1’)) преобразует в Decimal(‘1.100000000000000088817841970012523233890533447265625’) .

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

Цель аргумента context — определить, что делать, если value является неправильной строкой. Если контекст ловит InvalidOperation , возникает исключение; иначе конструктор возвращает новое десятичное число с значение NaN .

После построения объекты Decimal являются неизменяемыми.

Изменено в версии 3.2: Теперь аргументу конструктора разрешено быть float сущностью.

Изменено в версии 3.3: float аргументы вызывают исключение, если задана ловушка FloatOperation . По умолчанию ловушка выключена.

Изменено в версии 3.6: Для группировки допускаются подчеркивания, как и для литералов с интегральной и плавающей точкой в коде.

Decimal объекты с плавающей точкой содержат много общих свойств с другими встроенными числовыми типами, такими как float и int . Применяются все обычные математические операции и специальные методы. Также, decimal объекты могут быть скопированы, pickled, напечатаны, используемый как ключи словаря, используемый как элементы множества, сравнение, сортировка, и принуждение к другому типу (такому как float или int ).

Существуют небольшие различия между арифметикой десятичных объектов и арифметикой целых чисел и плавающих. Когда оператор остатка % применяется к десятичным объектам, знак результата является знаком делимо, а не знаком делителя:

Оператор целочисленного деления // ведет себя аналогично, возвращая целую часть истинного частного (усечение к нулю), а не своего нижнего предела, чтобы сохранить обычное тождество x == (x // y) * y + x % y :

Операторы % и // реализуют операции remainder и divide-integer (соответственно), как описано в описании.

Decimal объекты в арифметических операциях обычно нельзя сочетать с флоатами или сущности fractions.Fraction : попытка добавить Decimal к float , например, поднимет TypeError . Однако возможно использовать операторов сравнения Python, чтобы сравнить Decimal сущность x с другим номером y . Это позволяет избежать путаницы результатов при проведении сравнений равенства между числами различных типов.

Изменено в версии 3.2: Сравнения смешанного типа между Decimal сущности и другими числовыми типами теперь полностью поддерживается.

Помимо стандартных числовых свойств, decimal объекты с плавающей точкой также имеют ряд специализированных методов:

Возвращает скорректированную степень после смещения крайних правых цифр коэффициента до тех пор, пока не останется только ведущая цифра: Decimal(‘321e+5’).adjusted() возвращает семь. Используется для определения положения наиболее значимой цифры относительно десятичной точки.

Возвращает пару (n, d) целых чисел, которые представляют данную Decimal сущность как дробь, с отрицательным числителем и с положительным знаменателем:

Преобразование является точным. Поднимет OverflowError для бесконечностей и CreateError для NaN.

Добавлено в версии 3.6.

Возвращает именованный кортеж представление числа: DecimalTuple(sign, digits, exponent) .

Возвращает каноническую кодировку аргумента. В настоящее время кодировка Decimal сущность всегда каноническая, таким образом, эта операция возвращает свой неизменный аргумент.

Сравнение значений двух десятичных сущности. compare() возвращает десятичную сущность, и если любой из операндов является NaN, то результатом будет NaN:

Эта операция идентична методу compare() , за исключением сигнала NaNs. То есть, если ни один из операндов не является сигнальным NaN, то любой тихий операнд NaN рассматривается как сигнальный NaN.

compare_total ( other, context=None ) ¶

Сравнение двух операнд, используя их абстрактное представление, а не числовые значение. Аналогично методу compare() , но результат даёт общий порядок на Decimal сущности. Два Decimal сущности с одним и тем же числовым значение, но разные представления сравниваются неравнозначно в этом порядке:

В общий порядок также включены тихие и сигнальные NaN. Результат этой функции является Decimal(‘0’) , если оба операнда имеют одинаковое представление, Decimal(‘-1’) если первый операнд ниже в общем порядке, чем второй, и Decimal(‘1’) если первый операнд выше в общем порядке, чем второй операнд. Подробные сведения об общем порядке см. в спецификации.

Эта операция не зависит от контекста и является тихой: флаги не изменяются и округление не выполняется. В качестве исключения, версия на языке C может возродить операцию CancelOperation, если второй операнд не может быть преобразован точно.

compare_total_mag ( other, context=None ) ¶

Сравнение двух операндов, используя их абстрактное представление, а не их значение, как в compare_total() , но игнорируя знак каждого операнда. x.compare_total_mag(y) эквивалентно x.copy_abs().compare_total(y.copy_abs()) .

Эта операция не зависит от контекста и является тихой: флаги не изменяются и округление не выполняется. В качестве исключения, версия на языке C может возродить операцию CancelOperation, если второй операнд не может быть преобразован точно.

Просто возвращает себя, этот метод только для соответствия десятичной спецификации.

Возвращает абсолютное значение аргумента. Эта операция не зависит от контекста и является тихой: флаги не изменяются и округление не выполняется.

Возвращает отрицание аргумента. Эта операция не зависит от контекста и является тихой: флаги не изменяются и округление не выполняется.

copy_sign ( other, context=None ) ¶

Возвращает копию первого операнда со знаком, равным знаку второго операнда. Например:

Эта операция не зависит от контекста и является тихой: флаги не изменяются и округление не выполняется. В качестве исключения, версия на языке C может возродить операцию CancelOperation, если второй операнд не может быть преобразован точно.

Возвращает значение (естественной) экспоненциальной функции e**x при заданном числе. Результат правильно округляется с использованием режима округления ROUND_HALF_EVEN .

Метод класса, преобразующий плавающую точку в десятичное число.

Примечание Decimal.from_float(0.1) не совпадает с Decimal(„0.1“) . Поскольку 0.1 не является точно представимым в двоичной плавающей точке, значение сохраняется как ближайший представимый значение, который является 0x1.999999999999ap-4 . Этот эквивалент значение в десятичном формате равен 0.1000000000000000055511151231257827021181583404541015625 .

Начиная с Python 3.2, Decimal сущность также может быть построена непосредственно из float .

Добавлено в версии 3.1.

Плавленное умножение-сложение. Возвращает self*other+third без округления промежуточного продукта self*other.

Возвращает True если аргумент является каноническим и False иначе. В настоящее время Decimal сущность всегда канонична, поэтому эта операция всегда возвращает True .

Возвращает True если аргумент является конечным числом, и False если аргумент является бесконечностью или NaN.

Возвращает True если аргумент является либо положительным, либо отрицательным бесконечностью и False иначе.

Возвращает True если аргумент является (тихим или сигнализирующим) NaN и False иначе.

Возвращает True , если аргумент — конечное обычное число. Возвращает False если аргумент равен нулю, субнормали, бесконечности или NaN.

Возвращает True если аргумент является тихим NaN, и False иначе.

Возвращает True если аргумент имеет отрицательный знак и False иначе. Обратите внимание, что нули и NaN могут нести знаки.

Возвращает True , если аргумент является сигнальным NaN и False иначе.

Возвращает True , если аргумент субнормальный и False иначе.

Возвращает True если аргумент является (положительным или отрицательным) нулем и False иначе.

Возвращает натуральный (по основанию е) логарифм операнда. Результат правильно округляется с использованием режима округления ROUND_HALF_EVEN .

Возвращает логарифм по основанию 10 операнда. Результат правильно округляется с использованием режима округления ROUND_HALF_EVEN .

Для ненулевого числа возвращает скорректированную экспоненту своего операнда как Decimal сущность. Если операнд равен нулю, то Decimal(‘-Infinity’) возвращенныйand поднимается флаг DivisionByZero . Если операнд является бесконечностью, то возвращается Decimal(‘Infinity’) .

logical_and ( other, context=None ) ¶

logical_and() — логическая операция, которая занимает два логические операнды (см. Логические операнды ). В результате получается цифра и двух операндов.

logical_invert() является логической операцией. Результатом является инверсия операнда по цифрам.

logical_or ( other, context=None ) ¶

logical_or() — логическая операция, которая берет два логических операнда (см. Логические операнды ). В результате получается цифра или два операнда.

logical_xor ( other, context=None ) ¶

logical_xor() — логическая операция, которая занимает два логических операнда (см. Логические операнды ). Результатом является исключительная цифра или два операнда.

Подобно max(self, other) за исключением того, что правило округления контекста применяется прежде, чем возвратиться и те NaN значения либо сигнализируются, либо игнорируются (в зависимости от контекста сигнализируюся или замалчиваются).

Аналогично методу max() , но сравнение выполняется с использованием абсолютной значений операндов.

Подобно min(self, other) за исключением того, что правило округления контекста применяется прежде, чем возвратиться и те NaN значения либо сигнализируются, либо игнорируются (в зависимости от контекста сигнализируюся или замалчиваются).

Аналогично методу min() , но сравнение выполняется с использованием абсолютной значения операндов.

Возвращает большое число, представляемое в данном контекст (или в текущем контексте потока, если не задан контекст), которое меньше заданного операнда.

Возвращает наименьшее число, представляемое в данном контекст (или в текущем контексте потока, если не задан контекст), которое больше заданного операнда.

next_toward ( other, context=None ) ¶

Если два операнда неравны, возвращает число, ближайшее к первому операнду в направлении второго операнда. Если оба операнда численно равны, то возвращает a копия первого операнда со знаком, установленным таким же, как знак второго операнда.

Нормализировать число путем удаления крайних правых конечных нулей и преобразования любого результата, равного Decimal(‘0’) , в Decimal(‘0e0’) . Используется для получения канонических значения для атрибуты класса эквивалентности. Например, Decimal(‘32.100’) и Decimal(‘0.321000e+2’) нормализуются до эквивалентного значение Decimal(‘32.1’) .

Возвращает строку описание class операнда. возвращенный значение — один из следующих десяти строк.

• "-Infinity" , что указывает на отрицательную бесконечность операнда.
• "-Normal" , указывающий, что операнд является отрицательным нормальным числом.
• "-Subnormal" , указывающий, что операнд является отрицательным и субнормальным.
• "-Zero" , указывающий, что операнд является отрицательным нулем.
• "+Zero" , указывающий, что операнд является положительным нулем.
• "+Subnormal" , указывающий, что операнд является положительным и субнормальным.
• "+Normal" , указывающий, что операнд является положительным нормальным числом.
• "+Infinity" , что указывает на положительную бесконечность операнда.
• "NaN" , указывающий, что операнд является тихим NaN (не число).
• "sNaN" , указывающий, что операнд является сигнальным NaN.

Возвращает значение равному первому операнду после округления и содержит степень второго операнда.

В отличие от других операций, если длина коэффициента после операции квантования будет больше, чем точность, то сигнализируется InvalidOperation . Это гарантирует, что, если не существует условия ошибки, квантованный экспонент всегда равен показателю правого операнда.

Кроме того, в отличие от других операций, квантование никогда не сигнализирует о Underflow, даже если результат является субнормальным и неточным.

Если степень второго операнда больше степени первого операнда, может потребоваться округление. В этом случае режим округления определяется аргументом rounding , если он задан, иначе заданным аргументом context ; если ни один из аргументов не задан, используется режим округления текущего контекстного потока.

Возвращается ошибка всякий раз, когда, получающаяся экспонента больше, чем Emax или меньше, чем Etiny .

Возвращает Decimal(10) , радикс (основание), в котором класс Decimal выполняет всю арифметику. Включено для совместимости со спецификацией.

remainder_near ( other, context=None ) ¶

Возвращает остаток от деления self на other. Это отличается от self % other тем, что знак остатка выбран таким образом, чтобы минимизировать его абсолютную значение. Точнее, возвращает значение есть self — n * other где n — целое число, ближайшее к точному значение self / other , и если два целых одинаково близки, то выбирается чётное.

Если результат равен нулю, то его знак будет знаком self.

Возвращает результат поворота цифр первого операнда на величину, заданную вторым операндом. Второй операнд должен быть целым числом в диапазоне — точности через точность. Абсолютная значение второго операнда даёт количество мест для поворота. Если второй операнд положительный, то вращение влево; в противном случае поворот осуществляется вправо. Коэффициент первого операнда при необходимости заполняется нулями до точности длины. Знак и экспонента первого операнда неизменны.

same_quantum ( other, context=None ) ¶

Проверка, имеет ли self и другой ту же экспоненту или являются ли оба NaN .

Эта операция не зависит от контекста и является тихой: флаги не изменяются и округление не выполняется. В качестве исключения, версия на языке C может возродить операцию CancelOperation, если второй операнд не может быть преобразован точно.

Возвращает первый операнд с экспонентой, регулируемый вторым. Эквивалентно, возвращает первый операнд, умноженный на 10**other . Второй операнд должен быть целым числом.

Возвращает результат сдвига цифр первого операнда на величину, заданную вторым операндом. Второй операнд должен быть целым числом в диапазоне — точности. Абсолютная значение второго операнда даёт количество мест для сдвига. Если второй операнд положительный, то сдвиг влево; в противном случае смещение происходит вправо. Цифры, сдвинутые в коэффициент, являются нулями. Знак и экспонента первого операнда неизменны.

Возвращает квадратный корень аргумента до полной точности.

Преобразовать в строку, используя инженерную нотацию, если требуется степень.

Инженерная нотация содержит степень, кратную 3. Это может оставить до 3 цифр слева от десятичного знака и может потребовать добавления одного или двух конечных нулей.

Например, этот метод преобразует Decimal(‘123E+1’) в Decimal(‘1.23E+3’) .

to_integral ( rounding=None, context=None ) ¶

Идентичен методу to_integral_value() . Имя to_integral сохранено для совместимости со старыми версиями.

to_integral_exact ( rounding=None, context=None ) ¶

Округление к ближайшему целому числу, сигнализируя о Inexact или Rounded как соответствующих, если округление происходит. Режим округления определяется параметром rounding и еще переданным context . Если никакой параметр не передан тогда, тогда используется режим округления текущего контекста.

to_integral_value ( rounding=None, context=None ) ¶

Округление до ближайшего целого числа без сигнализации Inexact или Rounded . Если указано, применяется rounding; в противном случае используется метод округления либо в поставляемом context, либо в текущем контексте.

Логические операнды¶

Методы logical_and() , logical_invert() , logical_or() и logical_xor() ожидают, что их аргументы будут логическими операндами. A логический операнд — это Decimal сущность, показатель и знак которого равны нулю, а все цифры равны 0 или 1 .

Объекты контекста¶

Контексты — это среды для арифметических операций. Они управляют точностью, устанавливают правила округления, определяют, какие сигналы рассматриваются как исключения и ограничивают диапазон для экспонент.

Каждый поток содержит свой собственный текущий контекст, доступ к которому или изменение которого осуществляется с помощью функций getcontext() и setcontext() :

Возвращает текущее контекст для активного потока.

decimal. setcontext ( c ) ¶

Установить текущий контекст для активного потока в c.

Вы можете также использовать with инструкция и функцию localcontext() , чтобы временно изменить активный контекст.

decimal. localcontext ( ctx=None ) ¶

Диспетчер возвращает контекст, который установит текущее контекст для активного поток в копию ctx при входе в with-инструкция и восстановит предыдущее контекст при выходе из with-инструкции. Если контекст не определен, используется копия текущего контекста.

Например, следующий код устанавливает текущую десятичную точность в 42 места, выполняет вычисление и затем автоматически восстанавливает предыдущий контекст:

Новые контексты также могут быть созданы с помощью конструктора Context , описанного ниже. Кроме того, модуль предоставляет три предварительно созданных контекста:

class decimal. BasicContext ¶

Стандартный контекст, определяемый общей десятичной арифметической спецификацией. Точность устанавливается равной девяти. Округление установлено в ROUND_HALF_UP . Все флаги очищены. Все ловушки включены (рассматриваются как исключения), кроме Inexact , Rounded и Subnormal .

Поскольку многие ловушки включены, этот контекст полезен для отладки.

class decimal. ExtendedContext ¶

Стандартный контекст, определенный общей десятичной арифметической спецификацией. Точность устанавливается равной девяти. Округление установлено в ROUND_HALF_EVEN . Все флаги очищены. Ловушки не включены (чтобы исключения не возникали во время вычислений).

Поскольку ловушки отключены, этот контекст полезен для приложений, которые предпочитают получить в результате значение NaN или Infinity вместо того, чтобы поднять исключения. Это позволяет приложению завершить запуск в присутствии условий, которые в противном случае остановят программу.

class decimal. DefaultContext ¶

Этот контекст используется конструктором Context как прототип для новых контекстов. Изменение поля (также и точности) приводит к изменению значения по умолчанию для новых контекстов, созданных конструктором Context .

Этот контекст наиболее полезен в многопоточных средах. Изменяя одно из полей, прежде чем потоки начаты, реализует эффект настройки общесистемных умолчаний. Изменение полей после того, как потоки начались, не рекомендуется, поскольку это потребовало бы, чтобы синхронизация потоков предотвратила условия гонки.

В однопоточных средах предпочтительно вообще не использовать этот контекст. Вместо этого просто создайте контексты явно, как описано ниже.

Значения по умолчанию — prec = :const: 28 , rounding = :const: ROUND_HALF_EVEN , и включить ловушки для Overflow , InvalidOperation и DivisionByZero .

В дополнение к трем предоставленным контекстам можно создавать новые контексты с помощью конструктора Context .

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

Создание нового контекста. Если поле не указано или является None , значения по умолчанию копируются из DefaultContext . Если поле flags не указано или имеет значение None , все флаги очищаются.

prec — целое число в диапазоне [ 1 , MAX_PREC ], которое задает точность для арифметических операций в контекста.

Параметр rounding является одной из констант, перечисленных в разделе Режимы округления.

В полях traps и flags перечислены любые сигналы, которые должны быть установлены. Как правило, новые контексты должны только устанавливать ловушки и оставлять флаги чистыми.

Поля Emin и Emax являются целыми числами, задающими внешние пределы, допустимые для экспонент. Emin должен быть в диапазоне [ MIN_EMIN , 0 ], Emax в диапазоне [ 0 , MAX_EMAX ].

Поле capitals должно быть 0 или 1 (по умолчанию). Если установлено значение 1 , экспоненты печатаются с помощью прописной E ; иначе строчной e — используется: Decimal(‘6.02e+23’) .

Поле clamp содержит значение 0 (по умолчанию) или 1 . Если установлено в 1 , экспонента e Decimal сущность представляется в этом контексте строго ограничен диапазоном Emin — prec + 1 <= e <= Emax — prec + 1 . Если clamp 0 , то держится более слабое условие: скорректированная экспонента Decimal сущность составляет максимум Emax . Когда clamp равно 1 , большое нормальное число, где это возможно, будет иметь уменьшенную степень и соответствующее количество нулей, добавленных к его коэффициенту, чтобы соответствовать ограничениям экспоненты; это сохраняет значение числа, но теряет информацию о значимых конечных нулях. Например:

clamp значение 1 допускает совместимость с форматами десятичного обмена фиксированной ширины, заданными в IEEE 754.

Класс Context определяет несколько методов общего назначения, а также большое количество методов для выполнения арифметики непосредственно в данном контекста. Кроме того, для каждого из описанных выше способов Decimal (за исключением методов adjusted() и as_tuple() ) существует соответствующий метод Context . Например, для Context сущности C и Decimal сущности x , C.exp(x) эквивалентно x.exp(context=C) . Каждый метод Context принимает целое число Python (сущность int ) где угодно, что принять Decimal сущность.

Сбрасывает все флаги в 0 .

Сбрасывает все ловушки в 0 .

Добавлено в версии 3.3.

Возвращает дубликат контекста.

Возвращает из копии Decimal сущности в num.

Создает новую Decimal сущность из num, но с использованием self в качестве контекста. В отличие от конструктора Decimal , к преобразованию применяются точность контекста, метод округления, флаги и ловушки.

Это полезно, поскольку константы часто задаются с большей точностью, чем требуется приложению. Другое преимущество состоит в том, что округление сразу же устраняет непреднамеренные эффекты от цифр, превышающих текущую точность. В следующем примере использование неокругленных входных данных означает, что добавление нуля к сумме может изменить результат:

Этот метод реализует в to-number операцию спецификации IBM. Если аргумент — строка, никакой лидирующий или завершающего пробела или подчеркивания не разрешены.

Создание новой Decimal сущности из плавающего f, но округление с использованием self в качестве контекста. В отличие от метода класса Decimal.from_float() , к преобразованию применяется точность контекста, метод округления, флаги и ловушки.

Добавлено в версии 3.1.

Возвращает значение, равное Emin — prec + 1 , которое является минимальной экспонентой значения для субнормальных результатов. Когда происходит переполнение экспонента устанавливается в Etiny .

Возвращает значение, равное Emax — prec + 1 .

Обычный подход к работе с десятичными разрядами заключается в создании Decimal сущности и затем применении арифметических операций, которые происходят в пределах текущего контекст для активного потока. Альтернативный подход заключается в использовании методов контекста для расчета в пределах конкретного контекста. Методы аналогичны методам класса Decimal и кратко пересчитываются здесь.

Возвращает абсолютное значение x.

Возвращает сумму x и y.

Возвращает тот же десятичный объект x.

Сравнивает x и y численно.

Сравнивает значения двух операндов численно.

Сравнивает два операнда, используя их абстрактное представление.

Сравнивает два операнда, используя их абстрактное представление, игнорируя знак.

Возвращает копию x со знаком, установленным в 0.

Возвращает копию x с инвертированным знаком.

Копирует знак с y на x.

Возвращает x делёного на y.

Возвращает x, деленого на y, усеченная до целого числа.

Делит два числа и возвращает целую часть результата.

Возвращает x, умноженное на y, плюс z.

Возвращает True , если x является каноническим; в противном случае возвращает False .

Возвращает True , если x является конечным; в противном случае возвращает False .

Возвращает True , если x бесконечно; в противном случае возвращает False .

Возвращает значение True , если x является qNaN или sNaN; в противном случае возвращает False .

Возвращает True , если x является обычным числом; в противном случае возвращает False .

Возвращает True , если x является тихим NaN; в противном случае возвращает False .

Возвращает True , если x является отрицательным; в противном случае возвращает False .

Возвращает значение True , если x является сигнальным NaN; в противном случае возвращает False .

Возвращает True , если x является субнормальной; в противном случае возвращает False .

Возвращает True , если x равен нулю; в противном случае возвращает False .

Возвращает натуральный (по основанию e) логарифм x.

Возвращает логарифм x по основанию 10.

Возвращает степень величины MSD операнда.

Применяет логическую операцию and между цифрами каждого операнда.

Инвертирует все цифры в x.

Применяет логическую операцию or между цифрами каждого операнда.

Применяет логическую операцию xor между цифрами каждого операнда.

Сравнивает два значения численно и возвращает максимум.

Сравнивает значения численно с их игнорируемым знаком.

Сравнивает два значения численно и возвращает минимум.

Сравнивает значения численно с их игнорируемым знаком.

Минус соответствует унарному префиксу минус оператор в Python.

Возвращает умножение x и y.

Возвращает наибольшее представимое число, меньшее чем x.

Возвращает наименьшее представимое число, превышающее x.

Возвращает число, наиболее близкое к x, в направлении к y.

Сводит x к простейшей форме.

Возвращает указание класса x.

Плюс соответствует унарному префиксу плюс оператор в Python. Эта операция применяет точность контекста и округления, поэтому она не является операцией идентификации.

Возвращает x в степени y , уменьшенное по модулю modulo , если передано.

С двумя аргументами вычислит x**y . Если x отрицательный, то y должен быть интегральным. Результат будет неточным, если y не является интегральным и результат является конечным и может быть выражен точно в «точности» цифр. Используется режим округления из контекста. Результаты всегда правильно округляются в Python версии.

Decimal(0) ** Decimal(0) приводит к InvalidOperation , а если InvalidOperation не захватывается, то дает Decimal(‘NaN’) .

Изменено в версии 3.3: C одуль вычисляет power() с точки зрения правильно округленных функций exp() и ln() . Результат четко определен, но только «почти всегда правильно округлен».

С тремя аргументами вычислить (x**y) % modulo . Для формы с тремя аргументами хранятся следующие ограничения для аргументов:

• все три аргумента должны быть интегральными,
• y должен быть неотрицательным,
• по крайней мере один из x или y должен быть отличным от нуля
• modulo , должно быть отличным от нуля и содержать больше цифр „точности“

Значение, следующее из Context.power(x, y, modulo) , равено значению, которое было бы получено, вычислив (x**y) % modulo с неограниченной точностью, но вычислен более эффективно. Экспонента результата равна нулю, независимо от степеней x , y и modulo . Результат всегда точный.

Возвращает значение, равный x (округленный), имеющий степень y.

Возвращает 10, так как это Decimal,:)

Возвращает остаток от целочисленного деления.

Знак результата, если он ненулевой, совпадает с знаком исходного делимого.

Возвращает x — y * n , где n — целое число, ближайшее к точному значению x / y (если результат 0, то его знаком будет знак x).

Возвращает повернутую копию x, y раз.

Возвращает значение True , если два операнда имеют одинаковую степень.

Возвращает первый операнд после добавления второго значение его exp.

Возвращает сдвинутую копию x, y раз.

Квадратный корень неотрицательного числа для точности контекста.

Возвращает разницу между x и y.

Преобразовать в строку, используя инженерную нотацию, если требуется степень.

У инженерной нотации должна быть степень, кратную 3. Это может оставить до 3 цифр слева от десятичного знака и может потребовать добавления одного или двух конечных нулей.

Округление до целого числа.

Преобразует число в строку, используя научную нотацию.

Константы¶

Константы в этом разделе относятся только к модулю C. Они также включены в чистую Python версию для совместимости.

decimal. HAVE_THREADS ¶

Значение True . Устарел, потому что Python теперь всегда реализует потоки.

Не рекомендуется, начиная с версии 3.9.

Значение по умолчанию является True . Если Python скомпилирован —without-decimal-contextvar , версия C использует поточнолокальный, а не корутинлокальный контекст, и значение является False . Это несколько быстрее в некоторых вложенных сценариях контекста.

Добавлено в версии 3.9: backported to 3.7 and 3.8

Режимы округления¶

Округление к Infinity .

Округление по направлению к нулю.

Округление к -Infinity .

Округление до ближайшего со связями, идущими к нулю.

Округление до ближайшего со связями, идущими к ближайшему четному целому.

Округление до ближайшего с завязками, уходящими от нуля.

Округление от нуля.

Округление от нуля, если последняя цифра после округления к нулю была бы равна 0 или 5; в противном случае округляется к нулю.

Сигналы¶

Сигналы представляют собой условия, возникающие во время вычислений. Каждому соответствует один флаг контекста и один активатор ловушки контекста.

Флаг контекста устанавливается при каждом обнаружении условия. После вычисления флаги могут проверяться в информационных целях (для сущность, чтобы определить, было ли вычисление точным). После проверки флагов обязательно очистите все флаги перед началом следующего вычисления.

Если активатор ловушки контекста установлен для сигнала, то это условие вызывает исключение Python. Например, если задана ловушка DivisionByZero , то при обнаружении условия возникает исключение DivisionByZero .

class decimal. Clamped ¶

Изменение степени для соответствия ограничениям представления.

Обычно зажим происходит, когда экспонента выходит за пределы Emin и Emax пределов. Если возможно, степень уменьшается до аппроксимации путем добавления нулей к коэффициенту.

class decimal. DecimalException ¶

Базовый класс для других сигналов и подкласс ArithmeticError .

class decimal. DivisionByZero ¶

Сигнализация деления не бесконечного числа на ноль.

Может происходить с делением, делением по модулю или при увеличении числа до отрицательной степени. Если этот сигнал не захвачен, возвращает Infinity или -Infinity со знаком, определенным входами в расчет.

class decimal. Inexact ¶

Указывает, что произошло округление, и результат не является точным.

Сигналы при отбрасывании ненулевых цифр при округлении. Возвращается округленный результат. Использование сигнального флага или ловушки, чтобы обнаружить, когда результаты неточны.

class decimal. InvalidOperation ¶

Выполнена недопустимая операция.

Указывает, что запрошена операция, которая не имеет смысла. Если не попал в ловушку, возвращает значение NaN . Возможные причины включают в себя:

Указывает, что степень больше чем Emax после округления. Если результат не захвачен, то он зависит от режима округления, либо от перемещения внутрь до наибольшего представляемого конечного числа, либо от округления наружу до Infinity . В любом случае Inexact и Rounded также сигнализируются.

class decimal. Rounded ¶

Округление произошло, хотя информация, возможно, не была потеряна.

Сигнализируется всякий раз, когда округление отбрасывает цифры; даже если эти цифры равны нулю (например, округление 5.00 до 5.0 ). Если не захвачен, возвращает результат без изменений. Этот сигнал используется, чтобы обнаружить потерю значимых цифр.

class decimal. Subnormal ¶

Степень была ниже, чем Emin до округления.

Возникает, когда результат операции является субнормальным (степень слишком мала). Если не захвачен, возвращает результат без изменений.

class decimal. Underflow ¶

Численный нижний поток с результатом, округленным до нуля.

Возникает при смещении субнормального результата к нулю путем округления. Inexact и Subnormal также сигнализируются.

class decimal. FloatOperation ¶

Обеспечение более строгой семантики при смешивании плавающих и десятичных разрядов.

Если сигнал не захвачен (по умолчанию), смешение плавающих и десятичных разрядов допускается в конструкторе Decimal , create_decimal() и во всех операторах сравнения. И преобразование, и сравнение точны. Любое возникновение смешанной операции фиксируется без необходимости путем установки FloatOperation в флагах контекста. Явные преобразования с помощью from_float() или create_decimal_from_float() не устанавливают флаг.

В противном случае (сигнал захвачен) молчаливы только сравнения равенства и явные преобразования. Все остальные смешанные операции поднимают FloatOperation .

В следующей таблице представлена иерархия сигналов:

Заметки о плавающей точке¶

Уменьшение погрешности округления с повышенной точностью¶

Использование десятичной плавающей точки устраняет ошибку десятичного представления (позволяя представить 0.1 точно); однако некоторые операции могут по-прежнему вызывать ошибку округления, когда ненулевые цифры превышают фиксированную точность.

Влияние ошибки округления может быть усилено сложением или вычитанием почти компенсирующих величин, приводящих к потере значимости. Кнут приводит два поучительных примера, когда округленная арифметика с плавающей точкой с недостаточной точностью вызывает распад ассоциативных и распределительных свойств сложения:

Модуль decimal позволяет восстановить идентичность, достаточно расширяя точность, чтобы избежать потери значимости:

Специальные значения¶

Система чисел для модуля decimal предоставляет специальные значения включая NaN , sNaN , -Infinity , Infinity , и два ноля, +0 и -0 .

Бесконечности можно построить непосредственно с помощью: Decimal(‘Infinity’) . Кроме того, они могут возникать при делении на ноль, когда сигнал DivisionByZero не захватывался. Аналогично, когда сигнал Overflow не захвачен, бесконечность может быть результатом округления за пределы наибольшего представляемого числа.

Бесконечности являются знаковыми (аффинными) и могут быть используемы в арифметических операциях, где они рассматриваются как очень большие, неопределённые числа. Для сущность добавление константы к бесконечности даёт ещё один бесконечный результат.

Некоторые операции являются неопределенными и возвращает NaN или, если сигнал InvalidOperation захвачен, вызывают исключение. Например, 0/0 возвращает NaN , что означает «не число». Это разнообразие NaN является тихим и, после создания, будет проходить через другие вычисления всегда приводит к другой NaN . Это поведение может быть полезно для ряда вычислений, у которых иногда есть недостающие исходные данные — это позволяет расчетам продолжаться при пометке конкретных результатов как недопустимых.

Вариант — sNaN , который сигнализирует вместо того, чтобы остаться тихим после каждой операции. Это полезное возвращаемое значение, когда недопустимый результат должен прервать расчет для специальной обработки.

Поведение операторов сравнения Python’а может быть немного странным, когда речь идет о NaN . Тест на равенство, где один из операндов — тихий или сигнальный NaN всегда, возвращает False (делая Decimal(‘NaN’)==Decimal(‘NaN’) ), в то время как тест на неравенство всегда возвращает True . Попытка сравнения двух десятичных разрядов с использованием любого из операторов < , <= , > или >= поднимет сигнал InvalidOperation , если операнд является NaN , и возвращает False , если этот сигнал не захвачен. Обратите внимание, что общая десятичная арифметическая спецификация не определяет поведение прямых сравнений; эти правила для сравнения с участием NaN были взяты из стандарта IEEE 854 (см. таблицу 3 в разделе 5.7). Чтобы обеспечить строгое соблюдение стандартов, используйте методы compare() и compare-signal() .

Нулевые значения со знаком могут быть получены в результате вычислений, которые не были выполнены. Они сохраняют знак, который был бы получен, если бы расчет был выполнен с большей точностью. Так как их величина равна нулю, как положительные, так и отрицательные нули рассматриваются как равные и их знак является информационным.

В дополнение к двум знаковым нулям, которые различны, но равны, есть различные представления нуля с различной точностью, но эквивалентны в значении. К этому нужно привыкнуть. Для глаза, привыкшего к нормализованные представления с плавающей точкой, не сразу очевидно, что следующий расчет возвращает значение, равное нулю:

Работа с потоки¶

Функция getcontext() получает доступ к другому объекту Context для каждого потока. Наличие отдельных контекстов потока означает, что потоки могут вносить изменения (например, getcontext().prec=10 ) без вмешательства в другие потоки.

Аналогично, функция setcontext() автоматически назначает свою цель текущему потоку.

Если setcontext() не был вызван до getcontext() , то getcontext() автоматически создаст новый контекст для использования в текущем потоке.

Новый контекст копируется из прототипа контекста под названием DefaultContext. Чтобы управлять дефолтами так, чтобы каждый поток использовал те же значения всюду в приложении, непосредственно измените объект DefaultContext. Это должно быть сделано перед началом любого потока так, чтобы не было условия гонки между потоками, вызвав getcontext() . Например:

Рецепты¶

Вот несколько рецептов, которые служат в качестве полезных функций и которые демонстрируют способы работы с классом Decimal :

Часто задаваемые вопросы по Decimal¶

Вопрос. Громоздко набирать decimal.Decimal(‘1234.5’) . Есть ли способ минимизировать ввод при использовании интерактивного интерпретатора?

Ответ. Некоторые пользователи сокращают конструктор только одной буквой:

Вопрос. В приложении с фиксированной точкой и двумя десятичными разрядами некоторые входные данные имеют много знаков и требуют округления. Другие не должны иметь избыточных цифр и должны быть проверены. Какие методы должны быть используемы?

Ответ. Метод quantize() округляется до фиксированного числа десятичных разрядов. Если задана ловушка Inexact , она также полезна для проверки:

Вопрос. Когда у меня есть действительные два места ввода, как мне сохранить этот инвариант во всем приложении?

Ответ. Некоторые операции, такие как сложение, вычитание и умножение на целое число, автоматически сохраняют фиксированную точку. Другие операции, такие как деление и нецелочисленное умножение, изменят количество десятичных разрядов и должны сопровождаться шагом quantize() :

При разработке приложений с фиксированной точкой удобно определять функции для обработки шага quantize() :

Вопрос. Есть много способов выразить одно и то же значение. Номера 200 , 200.000 , 2E2 и 02E+4 у всех есть тот же значение в различной точности. Есть ли способ преобразовать их к единому узнаваемому каноническому значению?

Ответ. Метод normalize() сопоставляет все эквивалентные значения одному представителю:

Вопрос. Некоторые десятичные значения всегда печатаются с экспоненциальной нотацией. Есть ли способ получить неэкспоненциальное представление?

А. Для некоторых значения экспоненциальная нотация является единственным способом выражения числа значимых мест в коэффициенте. Например, выражение 5.0E+3 as 5000 сохраняет значение постоянной, но не может показать значение оригинала в двух местах.

Если приложение не заботится об отслеживании значимости, легко удалить экспонентные и конечные нули, потеряв значимость, но сохранив значение неизменным:

Вопрос. Есть ли способ преобразовать обычный float в Decimal ?

Ответ. Да, любое двоичное число с плавающей точкой может быть точно выражено как десятичное, хотя точное преобразование может занять больше точности, чем подсказывает интуиция:

Вопрос. В рамках сложных расчетов, как я могу убедиться, что я не получил ложный результат из-за недостаточной точности или аномалий округления.

Ответ. Decimal модуль упрощает проверку результатов. Оптимальным вариантом является повторный запуск вычислений с большей точностью и с различными режимами округления. Широко различающиеся результаты указывают на недостаточную точность, проблемы режима округления, неполноценные входные данные или численно нестабильный алгоритм.

Вопрос. Я заметил, что точность контекста применяется к результатам операций, но не на входы. Есть ли что-то, на что следует обратить внимание при смешивании значений разных точностей?

Ответ. Да. Принцип заключается в том, что все значения считаются точными и поэтому арифметика этих значений. Только результаты округляются. Преимущество для входных данных — это то, что вы печатаете, то и получаете. Недостатком является то, что результаты могут выглядеть странно, если вы забудете, что входные данные не были округлены:

Решением является либо повышение точности, либо принудительное округление входных данных с помощью операции унарного плюса:

В качестве альтернативы, входные данные можно округлять при создании с помощью метода Context.create_decimal() :

Вопрос. Быстрая ли реализация CPython для больших чисел?

Ответ. Да. В реализациях CPython и PyPy3 версии C/CFFI Decimal модуля интегрируют высокоскоростную библиотеку libmpdec для произвольной точности правильного округленной десятичной арифметики с плавающей точкой. libmpdec использует Карацуба умножение для средних чисел и Теоретическое преобразование числа для очень больших чисел.