Модуль decimal в Python, десятичная арифметика
Модуль decimal обеспечивает поддержку быстрой правильно округленной десятичной арифметики с плавающей запятой. Он предлагает несколько преимуществ по сравнению с типом данных float :
- Десятичное число основано на модели с плавающей точкой, которая была разработана с учетом потребностей людей и обязательно имеет первостепенный руководящий принцип — компьютеры должны обеспечивать арифметику, которая работает так же, как арифметика, которую люди изучают в школе.
- Десятичные числа могут быть представлены точно. Напротив, числа типа float 1.1 и 2.2 не имеют точных представлений в двоичной формате. Конечные пользователи обычно не ожидают, что 1.1 + 2.2 будет отображаться как 3.3000000000000003.
- Точность переносится в арифметику. В десятичном формате с плавающей запятой 0,1 + 0,1 + 0,1 — 0,3 точно равно нулю. В двоичной формате результат равен 5.5511151231257827e-017. Хотя значения близки к нулю, различия мешают надежному тестированию на равенство и различия могут накапливаться. По этой причине десятичная дробь предпочтительнее в бухгалтерских приложениях, которые имеют строгие инварианты равенства.
- Десятичный модуль включает в себя понятие значимых мест, так что 1,30 + 1,20 составляет 2,50. Конечный ноль сохраняется для обозначения значимости. Это обычное представление для денежных приложений. Например 1,3 * 1,2 дает 1,56, а 1,30 * 1,20 дает 1,5600.
- В отличие от аппаратной двоичной плавающей запятой, модуль decimal имеет изменяемую пользователем точность, по умолчанию до 28 разрядов, которая может быть настолько большой, насколько это необходимо для вычислений:
from decimal import * getcontext().prec = 6 Decimal(1) / Decimal(7) # Decimal('0.142857') getcontext().prec = 28 Decimal(1) / Decimal(7) # Decimal('0.1428571428571428571428571429')
Дизайн модуля основан на трех понятиях: десятичное число, контекст для арифметики и сигналы.
Десятичное число является неизменным. У него есть знак, цифры коэффициента и показатель степени. Для сохранения значимости цифры коэффициента не усекают конечные нули. Десятичные числа также включают специальные значения, такие как Infinity , -Infinity и NaN . Стандарт также отличает -0 от +0.
Контекст для арифметики — это среда, определяющая точность, правила округления, ограничения на экспоненты, флаги, указывающие результаты операций, и средства активации, которые определяют, будут ли сигналы рассматриваться как исключения.
Сигналы — это группы исключительных условий, возникающих в процессе вычислений. В зависимости от потребностей приложения сигналы могут игнорироваться, рассматриваться как информационные или рассматриваться как исключения. Смотрите раздел «Сигналы в модуле decimal «.
Для каждого сигнала есть флаг и активатор ловушек. Когда сигнал встречается, его флаг устанавливается в единицу, затем, если активатор прерывания установлен в единицу, возникает исключение. Флаги являются липкими, поэтому пользователь должен сбросить их перед мониторингом расчетов.
- КРАТКИЙ ОБЗОР МАТЕРИАЛА.
- Краткое руководство по модулю decimal
- Ошибки округления с повышенной точностью
- Способы работы с классом Decimal
- Класс Decimal() модуля decimal
- Методы объекта Decimal()
- Контексты модуля decimal
- Класс Context() модуля decimal
- Режимы округления модуля decimal
- Сигнальные флаги модуля decimal
Как установить decimal python
При работе с числами с плавающей точкой (то есть float) мы сталкиваемся с тем, что в результате вычислений мы получаем не совсем верный результат:
number = 0.1 + 0.1 + 0.1 print(number) # 0.30000000000000004
Проблему может решить использование функции round() , которая округлит число. Однако есть и другой способ, который заключается в использовании встроенного модуля decimal .
Ключевым компонентом для работы с числами в этом модуле является класс Decimal . Для его применения нам надо создать его объект с помощью конструктора. В конструктор передается строковое значение, которое представляет число:
from decimal import Decimal number = Decimal("0.1")
После этого объект Decimal можно использовать в арифметических операциях:
from decimal import Decimal number = Decimal("0.1") number = number + number + number print(number) # 0.3
В операциях с Decimal можно использовать целые числа:
number = Decimal("0.1") number = number + 2
Однако нельзя смешивать в операциях дробные числа float и Decimal:
number = Decimal("0.1") number = number + 0.1 # здесь возникнет ошибка
С помощью дополнительных знаков мы можем определить, сколько будет символов в дробной части числа:
number = Decimal("0.10") number = 3 * number print(number) # 0.30
Строка «0.10» определяет два знака в дробной части, даже если последние символы будут представлять ноль. Соответственно «0.100» представляет три знака в дробной части.
Округление чисел
Объекты Decimal имеют метод quantize() , который позволяет округлять числа. В этот метод в качестве первого аргумента передается также объект Decimal, который указывает формат округления числа:
from decimal import Decimal number = Decimal("0.444") number = number.quantize(Decimal("1.00")) print(number) # 0.44 number = Decimal("0.555678") print(number.quantize(Decimal("1.00"))) # 0.56 number = Decimal("0.999") print(number.quantize(Decimal("1.00"))) # 1.00
Используемая строка «1.00» указывает, что округление будет идти до двух знаков в дробной части.
По умолчанию округление описывается константой ROUND_HALF_EVEN , при котором округление происходит до ближайшего четного числа, если округляемая часть равна 5. Например:
from decimal import Decimal, ROUND_HALF_EVEN number = Decimal("10.025") # 2 - ближайшее четное число print(number.quantize(Decimal("1.00"), ROUND_HALF_EVEN)) # 10.02 number = Decimal("10.035") # 4 - ближайшее четное число print(number.quantize(Decimal("1.00"), ROUND_HALF_EVEN)) # 10.04
Стратегия округления передается в качестве второго параметра в quantize.
Строка «1.00» означает, что округление будет идти до двух чисел в дробной части. Но в первом случае «10.025» — вторым знаком идет 2 — четное число, поэтому, несмотря на то, что следующее число 5, двойка не округляется до тройки.
Во втором случае «10.035» — вторым знаком идет 3 — нечетное число, ближайшим четным числом будет 4, поэтому 35 округляется до 40.
Данное поведение при округлении, возможно, не всем покажется желательным, и в этом случае его можно переопределить, использовав одну из следующих констант:
- ROUND_HALF_UP : округляет число в сторону повышения, если после него идет число 5 или выше
- ROUND_HALF_DOWN : округляет число в сторону повышения, если после него идет число больше 5
number = Decimal("10.026") print(number.quantize(Decimal("1.00"), ROUND_HALF_DOWN)) # 10.03 number = Decimal("10.025") print(number.quantize(Decimal("1.00"), ROUND_HALF_DOWN)) # 10.02
number = Decimal("10.005") print(number.quantize(Decimal("1.00"), ROUND_05UP)) # 10.01 number = Decimal("10.025") print(number.quantize(Decimal("1.00"), ROUND_05UP)) # 10.02
number = Decimal("10.021") print(number.quantize(Decimal("1.00"), ROUND_CEILING)) # 10.03 number = Decimal("10.025") print(number.quantize(Decimal("1.00"), ROUND_CEILING)) # 10.03
number = Decimal("10.021") print(number.quantize(Decimal("1.00"), ROUND_FLOOR)) # 10.02 number = Decimal("10.025") print(number.quantize(Decimal("1.00"), ROUND_FLOOR)) # 10.02
Использование модуля decimal в Python
В данном руководстве мы рассмотрим использование модуля для работы с десятичными числами, который включен в стандартную библиотеку Python.
Введение
В Python есть числовые типы данных, такие как int, float и комплексные числа, но из-за машинной зависимости чисел с плавающей точкой нам нужен более точный тип данных для вычислений, требующих высокой точности. В этой статье мы рассмотрим модуль decimal в Python, который реализует десятичные числа с точностью до 28 цифр.
Использование
Python реализует десятичные числа как числа двойной точности с плавающей точкой, которые зависят от машины. Для вычислений, где точность критична для бизнеса, числа с плавающей точкой могут вызывать ошибки при выполнении на другой машине. Поэтому для таких приложений нам нужен независимый от машины тип данных для реализации десятичных чисел, который был реализован с помощью модуля decimal в Python. Кроме того, модуль decimal реализует десятичное число с точностью до 28 десятичных цифр, в то время как числа с плавающей запятой имеют точность до 18 цифр.
Это можно наблюдать в следующем примере
import decimal float_num = 100 / 3 print(float_num) decimal_num = decimal.Decimal(100) / decimal.Decimal(3) print(decimal_num)
33.333333333333336 33.33333333333333333333333333
Вторая причина использования десятичных чисел вместо чисел с плавающей точкой заключается в том, что в Python числа не могут быть представлены с использованием их точного значения, а используется только приближение, что может быть опасно для критически важных программ.
Из-за аппроксимации значения с плавающей точкой дают разные результаты для разных вычислений. Например, если мы сложим 1,2 и 2,2, используя значения с плавающей точкой, ответ должен быть равен 3,4. Но когда мы сравним добавленное число и 3,4, они не будут равны. Эта ошибка возникает из-за приближений в числах с плавающей запятой, из-за которых сумма 1,2 и 2,2 не равна 3,4.
Поэтому в случаях, когда необходимо сравнить десятичные значения, следует использовать десятичный модуль, а не числа с плавающей точкой.
Это может быть более понятно из следующего примера.
a = 1.2 b = 2.2 c = 3.4 d = a + b print("a:", a) print("b:", b) print("c:", c) print("a+b:", d) print("a+b==c?:", d == c)
a: 1.2 b: 2.2 c: 3.4 a+b: 3.4000000000000004 a+b==c?: False
Настройка контекста
Чтобы использовать модуль decimal в Python, достаточно его импортировать следующим образом.
import decimal
Импортированный модуль имеет предопределенный контекст, который содержит значения по умолчанию для точности, округления, флагов, минимально и максимально допустимых чисел. Мы можем посмотреть значения контекста с помощью метода getcontext() следующим образом.
import decimal print(decimal.getcontext())
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[InvalidOperation, DivisionByZero, Overflow])
Мы также можем установить точность и другие параметры контекста. Чтобы изменить точность на 2 цифры вместо 28, мы можем использовать следующую программу.
import decimal decimal.getcontext().prec = 2 print(decimal.getcontext())
Context(prec=2, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[InvalidOperation, DivisionByZero, Overflow])
По умолчанию, при округлении десятичных чисел с помощью модуля decimal, числа округляются равномерно. Мы можем изменить это поведение, изменив значение «rounding» в контексте следующим образом.
import decimal decimal.getcontext().rounding = "ROUND_HALF_DOWN" print(decimal.getcontext())
Context(prec=28, rounding=ROUND_HALF_DOWN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[InvalidOperation, DivisionByZero, Overflow])
Все арифметические операции над десятичными числами, определяемые модулем decimal, аналогичны операциям над числами с плавающей запятой. Разница заключается в точности значений из-за различий в реализации.
Округление значений
Мы можем округлять числа до определенных цифр с помощью функции round(). Функция round принимает десятичное число, которое нужно округлить, в качестве первого аргумента и количество цифр, до которых его нужно округлить, в качестве второго аргумента и возвращает округленное десятичное значение следующим образом.
import decimal num1 = decimal.Decimal(100) num2 = decimal.Decimal(3) print("Первое число:", num1) print("Второе число:", num2) num3 = num1 / num2 print("Первое число разделенное на второе число:", num3) num4 = round(num3, 2) print("Округленное число:", num4)
Первое число: 100 Второе число: 3 Первое число разделенное на второе число: 33.33333333333333333333333333 Округленное число: 33.33
Сравнение десятичных чисел
Как было показано в одном из разделов выше, сравнение чисел с плавающей запятой может привести к неправильным результатам, но десятичные числа являются точными, и их сравнение всегда даст желаемый результат. Это можно увидеть следующим образом.
import decimal a = decimal.Decimal("1.2") b = decimal.Decimal("2.2") c = decimal.Decimal("3.4") d = a + b print("a:", a) print("b:", b) print("c:", c) print("a+b:", d) print("a+b==c?:", c == d)
a: 1.2 b: 2.2 c: 3.4 a+b: 3.4 a+b==c?: True
В приведенном выше коде видно, что мы преобразовали строки в десятичные числа вместо того, чтобы преобразовывать числа с плавающей точкой в десятичные. Это сделано потому, что если мы преобразуем число с плавающей точкой в десятичное, то ошибка аппроксимации распространится на десятичное число, и мы не получим желаемого результата.
Заключение
В этой статье мы изучили недостатки выполнения арифметических операций с числами с плавающей точкой и использовали модуль decimal для реализации тех же операций без ошибок в Python. Мы также можем написать программы, использованные в этой статье, с обработкой исключений, используя python try except, чтобы сделать программы более надежными и систематически обрабатывать ошибки.
Оставайтесь с нами для получения новых информативных статей.
Как использовать модуль Decimal в Python 1 мин для чтения
В этой статье будет рассмотрена статья по использованию модуля Decimal в Python. Его можно использовать для выполнения различных математических операций с числами с плавающей запятой или числами, содержащими десятичные точки. Все примеры кода в этой статье протестированы с Python 3.9.5 в Ubuntu 21.04.
О десятичном модуле
Десятичный модуль, как следует из названия, может использоваться для обработки чисел с десятичной запятой или чисел с плавающей запятой. Методы, включенные в этот модуль, помогают округлять десятичные числа, преобразовывать числа и выполнять арифметические вычисления. Он также уделяет большое внимание точности и точности, и каждое число после десятичной точки считается значимым. Десятичный модуль рассматривает такое число, как 1,40, как 1,40, а не как 1,4. Использование десятичного модуля можно лучше понять на примерах. Некоторые из них описаны ниже.
Выполнение основных математических вычислений с использованием десятичного модуля
Вы можете вызвать модуль Decimal для преобразования числа в десятичный тип в Python. В приведенном ниже примере кода показана разница между основным математическим делением чисел целочисленного типа и числами десятичного типа.
from decimal import Decimal a = 10 b = 11 c = a / b d = Decimal(a) / Decimal(b) print (c, type(c)) print (d, type(d))
Первый оператор импортирует класс Decimal из модуля decimal. Затем создаются две переменные «a» и «b» с некоторыми значениями. Переменная «c» хранит значение, полученное путем деления переменной a на b. Затем тот же процесс повторяется путем преобразования чисел в объекты десятичного типа. После выполнения приведенного выше примера кода вы должны получить следующий результат:
0.9090909090909091 0.9090909090909090909090909091
Как вы можете видеть в выходных данных выше, объект типа float показывает числа с меньшей точностью, чем объект типа decimal, поскольку он использует гораздо более агрессивный метод аппроксимации, чем объект типа decimal. По умолчанию число десятичного типа в Python показывает до 28 чисел. Вы можете изменить это значение в соответствии с вашими потребностями, вызвав метод getcontext, доступный в модуле decimal.
from decimal import Decimal from decimal import getcontext getcontext().prec = 50 a = 10 b = 11 c = a / b d = Decimal(a) / Decimal(b) print (c, type(c)) print (d, type(d))
В приведенном выше примере кода функция getcontext была импортирована, а точное положение было установлено до 50 позиций. Метод getcontext можно использовать для просмотра текущего контекста в потоке и изменения некоторых параметров конфигурации по умолчанию для десятичного модуля. После выполнения приведенного выше примера кода вы должны получить следующий результат:
0.9090909090909091 0.90909090909090909090909090909090909090909090909091
Вы можете выполнять любой тип арифметических вычислений с объектами десятичного типа, которые вы можете выполнять с объектами типа float в Python. Большое количество конечных десятичных чисел в объектах десятичного типа может дать очень точные числа, которые особенно полезны в финансовых, бухгалтерских, критически важных научных приложениях и т. д.
Читать Отредактируйте «bashrc» в Linux для Color Prompt
Обратите внимание, что вы можете создавать числа десятичного типа из чисел с плавающей запятой, целых чисел и строк, содержащих числа, вызывая основной конструктор Decimal.
Округление чисел с помощью десятичного модуля
Модуль decimal поставляется с некоторыми предопределенными режимами округления, которые можно использовать для округления чисел с десятичными точками. Эти режимы называются ROUND_FLOOR, ROUND_CEILING, ROUND_HALF_DOWN, ROUND_HALF_UP, ROUND_UP, ROUND_DOWN, ROUND_HALF_EVEN и ROUND_05UP. Согласно официальной документации Python, вот что делает каждый из этих режимов:
- ROUND_FLOOR: число округляется до отрицательной бесконечности.
- ROUND_CEILING: число округляется до бесконечности или положительной бесконечности.
- ROUND_HALF_DOWN: числа округляются до ближайшего числа. Если есть ничья, число округляется до нуля. Связи — это равноотстоящие числа, которые можно округлять как в большую, так и в меньшую сторону. Например, такое число, как 4,25, можно округлить как в сторону 4,2, так и 4,3.
- ROUND_HALF_UP: числа округляются до ближайшего числа. Если есть ничья, число округляется от нуля.
- ROUND_UP: число округляется от нуля.
- ROUND_DOWN: число округляется до нуля.
- ROUND_HALF_EVEN: числа округляются до ближайшего числа. Любые связи округляются до ближайшего четного целого числа.
- ROUND_05UP: числа округляются от нуля, если последнее число равно 0 или 5. Если нет, то числа округляются до нуля.
В приведенном ниже примере кода показано поведение этих режимов.
import decimal from decimal import Decimal from decimal import getcontext getcontext().prec = 2 getcontext().rounding = decimal.ROUND_FLOOR print (Decimal(3.961) + Decimal(0)) getcontext().rounding = decimal.ROUND_CEILING print (Decimal(3.961) + Decimal(0)) getcontext().rounding = decimal.ROUND_HALF_DOWN print (Decimal(3.705) + Decimal(0)) getcontext().rounding = decimal.ROUND_HALF_UP print (Decimal(3.775) + Decimal(0)) getcontext().rounding = decimal.ROUND_UP print (Decimal(3.775) + Decimal(0)) getcontext().rounding = decimal.ROUND_DOWN print (Decimal(3.609) + Decimal(0)) getcontext().rounding = decimal.ROUND_HALF_EVEN print (Decimal(3.665) + Decimal(0)) getcontext().rounding = decimal.ROUND_05UP print (Decimal(3.675) + Decimal(0))
Пример кода довольно прост. Для округления чисел установлена точность 2 цифры. Метод округления изменяется путем установки значения объекта «округление» (часть основного контекста). После выполнения приведенного выше примера кода вы должны получить следующий результат, в котором каждая строка соответствует соответствующему режиму округления:
3.9 4.0 3.7 3.8 3.8 3.6 3.7 3.6
Округление с использованием метода квантования
Вы также можете использовать метод «квантования», доступный в десятичном модуле, для округления чисел. Процесс идентичен описанному выше методу. Однако вместо того, чтобы устанавливать числа точности отдельно, вы можете указать показатель степени в качестве аргумента метода квантования, чтобы округлить число до определенной позиции. Ниже приведен пример кода.
import decimal from decimal import Decimal rounded = Decimal(3.961).quantize(Decimal('1.0'), rounding=decimal.ROUND_FLOOR) print (rounded)
Методу квантования был предоставлен показатель степени «1.0», а в качестве дополнительного аргумента был предоставлен метод округления. Он вернет число в формате XX. После выполнения приведенного выше примера кода вы должны получить следующий результат:
Сравнение двух десятичных чисел
Вы можете сравнить любые два объекта десятичного типа, используя метод «сравнения», доступный в десятичном модуле. Примеры ниже показывают его использование.
from decimal import Decimal print (Decimal(1.2).compare(Decimal(1.1))) print (Decimal(1.0).compare(Decimal(1.1))) print (Decimal(1.0).compare(Decimal(1.0)))
Вы можете вызвать метод сравнения для объекта десятичного типа и указать другое число в качестве аргумента. Будет возвращено значение 0, 1 или -1 в зависимости от сравниваемых чисел. Значение 0 указывает, что оба числа равны, значение 1 указывает, что первое число больше второго числа, а значение -1 указывает, что первое число меньше второго. После выполнения приведенного выше примера кода вы должны получить следующий результат:
1 - 1 0
Заключение
Хотя модуль decimal чаще всего используется для управления точностью десятичного разделителя и округления чисел после десятичной точки, он поставляется с некоторыми другими полезными методами, которые в дальнейшем можно использовать для управления десятичными числами для получения точных результатов арифметических вычислений. Базовое использование модуля decimal было рассмотрено в этой статье, и этого должно хватить для большинства ситуаций. Но вы всегда можете узнать больше о расширенных методах из официальной документации Python.