Почему языки программирования округляют в меньшую сторону до.6?
При помещении десятичного числа в формат, где должен быть округлен к ближайшему 10-му, и это: 1.55, это будет вокруг к 1,5. 1.56 будет затем вокруг к 1,6. В школе я вспоминаю изучение, что Вы окружаете, когда Вы достигаете пять, и вниз если это 4 или ниже. Почему это отличается в Python и др.
Вот пример кода для Python 2.6x (независимо от того, что последняя версия),
'{0:01.2f}'.format(5.555) # This will return '5.55'
После попытки некоторых примеров, если, я понял что-то еще более запутывающее:
'{0:01.1f}'.format(5.55) # This will return '5.5'
# But then
'{0:01.1f}'.format(1.55) # This will return '1.6'
Почему различие при использовании 1.55 по сравнению с 5,55. Оба вводятся как литералы (так плавания)
6 ответов
Во-первых, в большинстве языков не декорированная константа типа "1.55" трактуется как величина двойной точности. Однако, 1.55 не является точно представляемым значением двойной точности, так как оно не имеет конечного представления в двоичном виде. Это приводит к множеству любопытных поведений, но одним из эффектов является то, что когда вы набираете 1.55, вы на самом деле не получаете значение, которое находится точно на полпути между 1.5 и 1.6.
В двоичной системе десятичное число 1.55 равно:
1.10001100110011001100110011001100110011001100110011001100110011001100...
Когда вы набираете "1.55", это значение на самом деле округляется до ближайшего репрезентабельного значения двойной точности (на многих системах... но есть исключения, к которым я доберусь). Это значение:
1.1000110011001100110011001100110011001100110011001101
, которое немного больше , чем 1.55; в десятичном разряде оно точно:
1.5500000000000000444089209850062616169452667236328125
Итак, когда попросят округлить это значение до одной цифры после десятичного разряда, оно округлит вверх до 1.6. Вот почему большинство комментаторов сказали, что они не могут дублировать поведение, которое вы видите.
Но подождите, в вашей системе, "1.55" округляется вниз , а не вверх. Что происходит?
Это может быть несколько разных вещей, но наиболее вероятно, что вы находитесь на платформе (вероятно, Windows), которая по умолчанию делает арифметику с плавающей точкой, используя x87 инструкций, которые используют другой (80-битный) внутренний формат. В 80-битном формате 1.55 имеет значение:
1.100011001100110011001100110011001100110011001100110011001100110
, которое немного меньше , чем 1.55; в десятичном формате это число:
1.54999999999999999995663191310057982263970188796520233154296875
Потому что оно просто меньше 1. 55, оно округляется вниз, когда округляется до одной цифры после запятой, давая результат "1.5", который вы наблюдаете.
FWIW: в большинстве языков программирования, режим округления по умолчанию на самом деле "округляется до ближайшей, привязывается к четной". Просто когда вы указываете дробные значения в десятичной дроби, вы почти никогда не попадаете в точный половинный регистр, так что непрофессионалу может быть трудно наблюдать за этим. Однако, если вы посмотрите, как "1.5" округляется до нуля:
>>> "%.0f" % 0.5
'0'
>>> "%.0f" % 1.5
'2'
Обратите внимание, что оба значения округляются до even чисел; ни один из них не округляется до "1".
Редактирование: в вашем переработанном вопросе, вы, кажется, переключились на другой питоновый интерпретатор, на котором плавающая запятая выполняется в IEEE754 типа double, а не в x87 80 битном. Таким образом, "1.55", как и в моём первом примере, обходит вверх , но "5.55" преобразуется в следующее двоичное значение с плавающей точкой:
101.10001100110011001100110011001100110011001100110011
, что в точности:
5.54999999999999982236431605997495353221893310546875
в десятичной дроби; поскольку это меньше , чем 5,55, округляет вниз .
.Можете привести пример кода, потому что я вижу на Python:
>>> "%.1f" % 1.54
'1.5'
>>> "%.1f" % 1.55
'1.6'
>>> "%.1f" % 1.56
'1.6'
Существует множество способов округления чисел. Вы можете прочитать больше об округлении в Википедии. Метод округления, используемый на Python - Округление наполовину от нуля, и описываемый вами метод округления более или менее одинаков (по крайней мере, для положительных чисел).
.Это не похоже на то, что происходит. Вы используете форматировщик строк "float", верно?
>>> "%0.2f" % 1.55
'1.55'
>>> "%0.1f" % 1.55
'1.6'
>>> "%0.0f" % 1.55
'2'
Округление и усечение для каждого языка программирования различны, поэтому ваш вопрос, вероятно, напрямую связан с Python.
Однако, округление как практика зависит от вашей методологии.
Вы также должны знать, что округление десятичной дроби до целого числа во многих языках программирования дает разные результаты от фактического округления числа.
Правка: На некоторых других плакатах, кажется, что Python не проявляет описанного вами округления:
>>> "%0.2f" % 1.55
'1.55'
>>> "%0.1f" % 1.55
'1.6'
>>> "%0.0f" % 1.55
'2'
Я не вижу причин для точного поведения, которое вы описываете. Если ваши числа - всего лишь примеры, то подобный сценарий можно объяснить округлением банкиров:
1.5 rounds to 2
2.5 rounds to 2
3.5 rounds to 4
4.5 rounds to 4
т.е. значение .5 будет округлено до ближайшего четного целого числа. Причина этого заключается в том, что округление многих чисел в конечном итоге выровняется. Если банк, например, будет выплачивать интеррест миллиону клиентов, и 10% из них получат округленное значение в 0,5%, то банк выплатит на 500 долларов больше, если вместо этого округлить значения.
Другой причиной неожиданного округления является точность чисел с плавающей точкой. Большинство чисел не может быть представлено точно, поэтому они представлены наиболее близким приближением. Когда вы думаете, что у вас есть число, равное 1.55, вы можете на самом деле закончить с числом, подобным 1.54999. Округление этого числа до одного знака после запятой, конечно, приведет к 1.5, а не к 1.6.