Python ограничить количество знаков после запятой

Python ограничить количество знаков после запятой

Небольшая заметка об округлении чисел в Python 3.

Округлением чисел в Python занимается встроенная функция round.

round(number[, ndigits]) — округляет число number до ndigits знаков после запятой (по умолчанию, до нуля знаков, то есть, до ближайшего целого)

Тут есть одна особенность, о которой нужно знать, и о которой часто забывают.

Со школы многие привыкли, что, когда (N + 1) знак = 5, а последующие знаки равны нулю, округление производится всегда в большую по модулю сторону.

Однако, как видно из примеров, в Python это не так. Здесь используется так называемое "Банковское округление", то есть округление к ближайшему чётному.

На практике это оказывается не так уж и важно, например:

Что-то не так, правда? На самом деле, всё именно так, как и задумывалось. Просто из-за проблем с точностью чисел с плавающей точкой это число чуть больше, чем 2.85, а потому округляется до 2.9.

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

Должен округлять до 0,03

Должен округлять до 0,12

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

8 ответов

Python включает в себя функцию round() которая позволяет вам указать желаемое количество цифр. Из документации:

Вернуть значение с плавающей запятой x, округленное до n цифр после десятичной точки. Если n опущено, по умолчанию используется ноль. Результатом является число с плавающей запятой. Значения округляются до ближайшего кратного 10 к степени минус n; если два мультипликатора одинаково близки, округление выполняется вдали от 0 (так, например, раунд (0,5) равен 1,0, а раунд (-0,5) равен -1,0).

Таким образом, вы хотите использовать round(x, 2) чтобы сделать нормальное округление. Чтобы число всегда округлялось , вам нужно использовать функцию ceil(x) . Аналогично, для округления используйте floor(x) .

Увидеть:
math.ceil документация
round документация — вы, возможно, захотите проверить это в любом случае для дальнейшего использования

Читайте также:  Для чего нужен беспроводной сетевой usb адаптер

Экстраполируя из ответа Эдвина:

Это зависит от поведения, которое вы хотите при рассмотрении положительных и отрицательных чисел, но если вы хотите, чтобы что-то всегда округлялось до большего значения (например, 2.0449 -> 2.05, -2.0449 -> -2.04), тогда вы можете сделать:

или немного любитель:

Это также, кажется, работает следующим образом:

Обратите внимание, что трюк ceil(num * 100) / 100 потерпит крах на некоторых вырожденных входах, таких как 1e308. Это может случаться не часто, но я могу сказать, что это стоило мне пару дней. Чтобы избежать этого, было бы неплохо, если бы ceil() и floor() принимали аргумент с десятичными знаками, как делает round() . Между тем, кто-нибудь знает чистую альтернативу, которая не будет аварийно завершать работу на таких входах? У меня были некоторые надежды на decimal упаковку, но она, похоже, тоже умерла:

Конечно, можно сказать, что сбой является единственным нормальным поведением для таких входных данных, но я бы сказал, что проблема заключается не в округлении, а в умножении (именно поэтому, например, 1e306 не происходит сбой), и в более чистой реализации округление вверх-n-е место fn позволит избежать взлома умножения.

Указанная круглая функция не работает для определенных целых чисел, таких как:

а = 8
круглая (а, 3)
8,0
а = 8.00
круглая (а, 3)
8,0
а = +8,000000000000000000000000
круглая (а, 3)
8,0

но работает для:

Более того, десятичные дроби, такие как 2,675, округляются до 2,67, а не 2,68.
Лучше использовать другой метод, представленный выше.

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

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

Способы округления чисел

Для округления чисел придумано много способов, они не лишены недостатков, однако часто используются для решения задач. Разберёмся в тонкостях каждого из них.

Читайте также:  Как активировать вай фай на телефоне

Если используется стандартная библиотека math, то в начале кода её необходимо подключить. Сделать это можно, например, с помощью инструкции: import math .

math.ceil() – округление чисел в большую сторону

Функция получила своё имя от термина «ceiling», который используется в математике для описания числа, которое больше или равно заданному.

Любая дробь находится в целочисленном интервале, например, 1.2 лежит между 1 и 2. Функция ceil() определяет, какая из границ интервала наибольшая и записывает её в результат округления.

math.floor() – округление чисел в меньшую сторону

Функция округляет дробное число до ближайшего целого, которое меньше или равно исходному. Работает аналогично функции ceil() , но с округлением в противоположную сторону.

math.trunc() – отбрасывание дробной части

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

Избавиться от дробной части можно с помощью обычного преобразования числа к типу int. Такой способ полностью эквивалентен использованию truns() .

Нормальное округление

Python позволяет реализовать нормальное арифметическое округление, использовав функцию преобразования к типу int.

И хотя int() работает по другому алгоритму, результат её использования для положительных чисел полностью аналогичен выводу функции floor(), которая округляет числа «вниз». Для отрицательных аналогичен функции ceil()/

Чтобы с помощью функции int() округлить число по математическим правилам, необходимо добавить к нему 0.5, если оно положительное, и -0.5, если оно отрицательное.

Тогда операция принимает такой вид: int(num + (0.5 if num > 0 else -0.5)). Чтобы каждый раз не писать условие, удобно сделать отдельную функцию:

Функция работает также, как стандартная функция округление во второй версии Python (арифметическое округление).

round() – округление чисел

round() – стандартная функция округления в языке Python. Она не всегда работает так, как ожидается, а её алгоритм различается в разных версиях Python.

Читайте также:  Что перебивает запах алкоголя

В Python 2

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

Увеличение погрешности вызвано неравным количеством цифр, определяющих, в какую сторону округлять. Всего 4 цифры на конце приводят к округлению «вниз», и 5 цифр к округлению «вверх».

Помимо этого, могут быть неточности, например, если округлить число 2.675 до второго знака, получится число 2.67 вместо 2.68. Это происходит из-за невозможности точно представить десятичные числа типа «float» в двоичном коде.

В Python 3

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

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

Но если вам по каким то причинам нужно округление как в Python 2, то можно воспользоваться функцией написанной нами выше на основе приведения к целому числу.

Округление до сотых

У функции raund() есть ещё один аргумент. Он показывает до какого количества знаков после запятой следует округлять. Таким образом, если нам надо в Python округлить до сотых, этому параметру следует задать значение 2.

Пример округления до нужного знака:

Ошибки округления и модуль decimal

При округлении функцией round(), можно получить следующее:

Почему в одном случае округляется вниз, а в другом вверх? При переводе 2.85 в двоичную систему получается число, которое немного больше. Поэтому функция видит не «5», а «>5» и округляет вверх.

Проблему неточного представления чисел отлично иллюстрирует пример:

Из-за подобных ошибок числа типа «float» нельзя использовать там, где изменения значения на одну тысячную может привести к неверному результату. Решить данную проблему поможет модуль decimal.

Ссылка на основную публикацию
Adblock detector