Ограничение числа с плавающей запятой до двух десятичных знаков - PullRequest
1384 голосов
/ 18 января 2009

Я хочу, чтобы a было округлено до 13,95 .

>>> a
13.949999999999999
>>> round(a, 2)
13.949999999999999

Функция round работает не так, как я ожидал.

Ответы [ 24 ]

27 голосов
/ 16 марта 2018

В Python 2.7:

a = 13.949999999999999
output = float("%0.2f"%a)
print output
25 голосов
/ 12 декабря 2017

Никто здесь, кажется, еще не упомянул об этом, поэтому позвольте мне привести пример в формате f-string / template-string в Python 3.6, который, я думаю, прекрасно выглядит:

>>> f'{a:.2f}'

Это хорошо работает и с более длинными примерами, с операторами и без необходимости в паренсе:

>>> print(f'Completed in {time.time() - start:.2f}s')
20 голосов
/ 19 января 2009

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

>>> 0.1
0.10000000000000001

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

>>> round(0.1, 1)
0.10000000000000001

Проблема в том, что двоичный значение с плавающей запятой, сохраненное для “0.1” был уже наилучшим двоичным приближение к 1/10, поэтому пытается вокруг это снова не может сделать это лучше: это было уже так хорошо, как это получается.

Еще одним следствием является то, что с 0.1 не совсем 1/10, суммируя десять значения 0.1 могут не дать точно 1.0, либо:

>>> sum = 0.0
>>> for i in range(10):
...     sum += 0.1
...
>>> sum
0.99999999999999989

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

18 голосов
/ 06 февраля 2019

Вы можете использовать оператор format для округления значения до 2 десятичных знаков в python:

print(format(14.4499923, '.2f')) // output is 14.45
12 голосов
/ 18 января 2009

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

11 голосов
/ 01 февраля 2018

Как указал @Matt, Python 3.6 предоставляет f-строки , и они также могут использовать вложенные параметры :

value = 2.34558
precision = 2
width = 4

print(f'result: {value:{width}.{precision}f}')

, который будет отображать result: 2.35

7 голосов
/ 03 апреля 2014

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

# For example:
a = 70000
b = 0.14
c = a * b

print c # Prints 980.0000000002
# Try to fix
c = int(c * 10000)/100000
print c # Prints 980

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

from decimal import *
getcontext().prec = 6
Decimal(1) / Decimal(7)
# Results in 6 precision -> Decimal('0.142857')

getcontext().prec = 28
Decimal(1) / Decimal(7)
# Results in 28 precision -> Decimal('0.1428571428571428571428571429')
6 голосов
/ 21 декабря 2018
from decimal import Decimal


def round_float(v, ndigits=2, rt_str=False):
    d = Decimal(v)
    v_str = ("{0:.%sf}" % ndigits).format(round(d, ndigits))
    if rt_str:
        return v_str
    return Decimal(v_str)

Результаты:

Python 3.6.1 (default, Dec 11 2018, 17:41:10)
>>> round_float(3.1415926)
Decimal('3.14')
>>> round_float(3.1445926)
Decimal('3.14')
>>> round_float(3.1455926)
Decimal('3.15')
>>> round_float(3.1455926, rt_str=True)
'3.15'
>>> str(round_float(3.1455926))
'3.15'
6 голосов
/ 04 сентября 2017
orig_float = 232569 / 16000.0

14,5355625

short_float = float("{:.2f}".format(orig_float)) 

14,54

3 голосов
/ 29 января 2019

Это просто как 1,2,3:

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

    d = Десятичный (+10000000,0000009)

для достижения округления:

   d.quantize(Decimal('0.01'))

приведет к результату Decimal('10000000.00')

  1. сделать выше СУХОГО:
    def round_decimal(number, exponent='0.01'):
        decimal_value = Decimal(number)
        return decimal_value.quantize(Decimal(exponent))

OR

    def round_decimal(number, decimal_places=2):
        decimal_value = Decimal(number)
        return decimal_value.quantize(Decimal(10) ** -decimal_places)
  1. проголосуй за ответ:)

PS: критика других: форматирование не округляется.

...