Python точность после запятой

Числа с фиксированной точностью. Класс Decimal

Числа с фиксированной точностью – это числа типа Decimal , которые при вычислениях используют фиксированное количество знаков после запятой. Тип Decimal – это специально разработанный класс (начиная с версии Python 2.4).

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

Например, нужно сохранять числа строго с числом 6 знаков после запятой.

Класс Decimal реализован в модуле decimal . Чтобы использовать возможности класса Decimal нужно выполнить команду

from decimal import Decimal

2. Как с помощью класса Decimal задать нужную фиксированную точность? Примеры

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

Decimal('0.002') # фиксированная точность 3 знака после запятой Decimal('0.23') # фиксированная точность 2 знака после запятой Decimal('0.00001') # фиксированная точность 5 знаков после запятой

3. Пример необходимости применения класса Decimal в программах на Python

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

# Числа с фиксированной точностью. Класс Decimal - преимущества применения # подключить класс Decimal из модуля decimal from decimal import Decimal # обычное вычисление, существует погрешность a = 0.2+0.2+0.2-0.4 # a = 0.20000000000000007 - погрешность (. ) print('a = ', a) # вычисление с помощью класса Decimal b = Decimal('0.2')+Decimal('0.2')+Decimal('0.2')-Decimal('0.4') print('b = ', b) # b = 0.2 - точный результат

Результат работы программы

a = 0.20000000000000007 b = 0.2

Сначала создается объект (переменная) с именем a , в которую записывается сумма

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

На следующем шаге создается объект с именем b , в который записывается сумма с использованием класса Decimal

b = Decimal('0.2')+Decimal('0.2')+Decimal('0.2')-Decimal('0.4')

После вывода значения b на экран, видно что значение переменной b представлено точно без погрешности.

4. Пример использования класса Decimal и функции str()

В предыдущем примере конструктор класса Decimal получал строку с числом

в котором определялась точность (1 знак после запятой) и значение числа 0.2.

Возможна ситуация, когда нужно передать непосредственно число а не строку. В этом случае удобно использовать функцию str() , как показано ниже

# вычисление с помощью класса Decimal b = Decimal(str(0.2))+Decimal(str(0.2))+Decimal(str(0.2))-Decimal(str(0.4)) print('b = ', b) # b = 0.2

Функция str() получает число и переводит его в строку

5. Использование фиксированной точности для чисел с разной точностью представлений. Пример

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

Например. При сложении трех чисел

c = Decimal('0.1')+Decimal('0.001')+Decimal(str(0.01)) # c = 0.111

автоматически устанавливается точность 3 знака после запятой, поскольку конструктор

определяет число 0.001 с наибольшей точностью представления.

6. Создание объектов класса Decimal из вещественных чисел. Пример

Для случаев, когда есть в наличии вещественное число, можно создать объект класса Decimal . В этом случае используется метод from_float() класса Decimal .

# Создание объекта типа Decimal, не всегда работает # Случай 1. Искаженная точность # x1 = 2.479999999999999982236431605997495353221893310546875 x1 = Decimal.from_float(2.48) print('x1 =',x1) # Случай 2. Фиксированная точность x2 = Decimal.from_float(2.5) # x2 = 2.5 - правильная точность print('x2 =', x2)

Результат выполнения вышеприведенного кода

x1 = 2.479999999999999982236431605997495353221893310546875 x2 = 2.5

Как видно из результата, не всегда удается получить фиксированную точность при использовании метода from_float() .

7. Глобальная настройка точности. Пример

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

# Глобальное задание точности # подключить класс Decimal from decimal import Decimal a = Decimal(5)/Decimal(13) # точность не задана print('a = ', a) # a = 0.3846153846153846153846153846 # задание точности 6 знаков после запятой import decimal decimal.getcontext().prec=6 b = Decimal(5)/Decimal(13) print('b = ', b) # b = 0.384615 c = Decimal(6)/Decimal(13) print('c = ', c) # c = 0.461538

Результат выполнения программы

a = 0.3846153846153846153846153846 b = 0.384615 c = 0.461538

В вышеприведенном примере глобальная точность для класса Decimal задается с помощью функции getcontext() , которая возвращает объект контекста в этом модуле. Точность задается в текущем потоке управления.

Связанные темы

Источник

Форматирование чисел в Python

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

Форматирование чисел с округлением

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

Чтобы указать уровень точности округления, нам нужно использовать двоеточие (:), за которым следует десятичная точка, а также некоторое целое число, представляющее степень точности (количество знаков после запятой). При использовании f-строки мы помещаем всё это после значения, которое хотим отформатировать (в фигурных скобках) . Вместо этого также можно использовать метод format.

x = 4863.4343091 # пример числа с плавающей запятой print(f"") # использование f-строки print("".format(x)) # использование метода format

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

Как видите, наше довольно длинное число сократилось до шести цифр. Также следует отметить, что данная операция форматирования может производить еще и округление. Если, например, первоначальное число будет иметь значение 4863.435, то выведем в консоль мы 4863.44. Здесь используется округление до ближайшего четного числа (в английском языке banker’s rounding — «округление банкира»).

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

x = 4863.4343091 print(f"") # 4.86e+03

4.86e+03 означает 4,86 ​​x 10³, или 4,86 ​​x 1000, что равно 4860. Глядя на этот результат, мы видим, что получили три значащих цифры, как и хотели.

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

x = 4863.4343091 print(f"") # 4863.434

f в данном случае указывает, что наше число типа float должно отображаться как «число с фиксированной точкой». То есть нам нужно определенное количество десятичных знаков. Мы также можем использовать f без числа, что по умолчанию означает точность 6 цифр после точки:

x = 4863.4343091 print(f"") # 4863.434309

Вывод числа с разбивкой на разряды

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

x = 1000000 print(f"") # 1,000,000 print(f"") # 1_000_000

При форматировании чисел с плавающей запятой и форматировании с округлением это тоже работает:

x = 4863.4343091 print(f"") # 4,863.434 print(f"") # 4_863.434

Вывод числа в процентах

Мы можем вывести число в качестве процентного значения, просто добавив символ % в конце параметров форматирования вместо f :

questions = 30 correct_answers = 23 print(f"You got correct!") # You got 76.67% correct!

При форматировании числа в процентах точность округления всегда относится к количеству цифр после точки.

Заключение

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

1 комментарий к “Форматирование чисел в Python”

Источник

6 методов для обработки и установки точности в Python

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

Различные методы обеспечения точности

Следующие методы поставляются с математическим модулем.

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

Давайте разберемся в следующем примере.

import math num = 25.74356801 # using trunc() function print("The value is:",math.trunc(num)) # using ceil() function print("The ceiling value is:",math.ceil(num)) # using floor() function print("The floor value is:", math.floor(num))

The value is: 25 The ceiling value is: 26 The floor value is: 25

Управление десятичной частью

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

• Оператор% – он работает как printf в C и используется для установки точности и формата. Мы можем настроить пределы точности, которые будут включены в результирующее число.
• format() – это встроенный метод Python, который используется для форматирования строки и установки точности.
• round(n, d) – используется для округления числа n до d десятичных знаков. Мы можем выбрать количество цифр, которое может отображаться после десятичных знаков.

num = 25.73796211 # using "%" operator print('The value is: %.3f'%num) # using format() function print("The value is: ".format(num)) # using round() function print("The value is:",round(num,5))

The value is: 25.738 The value is: 25.738 The value is: 25.73796

Заключение

Мы обсудили шесть методов обработки точности в Python. Все методы просты в использовании и дают точный результат.

Источник