14. Арифметика с плавающей точкой: проблемы и ограничения¶Floating Point Arithmetic: Issues and Limitations

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

0.125

имеет значение 1/10 + 2/100 + 5/1000, и точно так же двоичная дробь

0.001

имеет значение 0/2 + 0/4 + 1/8. Эти две дроби имеют одинаковые значения, единственное различие в том, что первая записана в десятичной системе счисления, а вторая – в двоичной.

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

Проблему легче сначала понять в десятичной системе. Рассмотрим дробь 1/3. Её можно приблизить десятичной дробью:

0.3

или, лучше,

0.33

или, лучше,

0.333

и так далее. Сколько бы цифр вы ни захотели записать, результат никогда не будет точно равен 1/3, но будет всё лучшим приближением к 1/3.

Точно так же, сколько бы двоичных цифр вы ни захотели использовать, десятичное значение 0.1 не может быть точно представлено в виде двоичной дроби. В двоичной системе 1/10 – это бесконечно повторяющаяся дробь

0.0001100110011001100110011001100110011001100110011...

Остановка на любом конечном числе битов даёт приближение.

На типичной машине, работающей под Python, для чисел с плавающей запятой доступно 53 бита точности, поэтому значение, сохраняемое внутри при вводе десятичного числа 0.1, представляет собой двоичную дробь

0.00011001100110011001100110011001100110011001100110011010

которая близка к 1/10, но не равна ей точно.

Легко забыть, что сохранённое значение является приближением к исходной десятичной дроби, из-за того, как числа с плавающей запятой отображаются в приглашении интерпретатора. Python печатает лишь десятичное приближение к истинному десятичному значению двоичного приближения, хранящегося в машине. Если бы Python печатал истинное десятичное значение двоичного приближения, сохранённого для 0.1, ему пришлось бы отобразить

>>> 0.1
0.1000000000000000055511151231257827021181583404541015625

Это больше цифр, чем обычно нужно, поэтому Python сохраняет число цифр управляемым, отображая вместо этого округлённое значение

>>> 0.1
0.1

Важно понимать, что это, в некотором смысле, иллюзия: значение в машине не равно в точности 1/10, вы просто округляете отображение истинного машинного значения. Этот факт становится очевидным, как только вы попытаетесь выполнять арифметические операции с этими значениями.

>>> 0.1 + 0.2
0.30000000000000004

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

Из этого вытекают и другие неожиданности. Например, если попытаться округлить значение 2.675 до двух десятичных знаков, получится следующее

>>> round(2.675, 2)
2.67

В документации к встроенной функции round() сказано, что она округляет до ближайшего значения, округляя связи от нуля. Поскольку десятичная дробь 2.675 находится ровно посередине между 2.67 и 2.68, можно было бы ожидать, что результатом будет (двоичное приближение к) 2.68. Однако это не так, потому что при преобразовании десятичной строки 2.675 в двоичное число с плавающей запятой оно снова заменяется двоичным приближением, точное значение которого равно

2.67499999999999982236431605997495353221893310546875

Поскольку это приближение немного ближе к 2.67, чем к 2.68, оно округляется вниз.

Если вы находитесь в ситуации, когда важно, как округляются десятичные значения, находящиеся ровно посередине, стоит рассмотреть использование модуля decimal. Кстати, модуль decimal также предоставляет удобный способ «увидеть» точное значение, хранящееся в любом конкретном числе с плавающей запятой Python.

>>> from decimal import Decimal
>>> Decimal(2.675)
Decimal('2.67499999999999982236431605997495353221893310546875')

Другое следствие: поскольку 0.1 не равно в точности 1/10, суммирование десяти значений 0.1 может не дать точно 1.0:

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

Двоичная арифметика с плавающей запятой таит в себе множество подобных сюрпризов. Проблема с «0.1» подробно объясняется ниже, в разделе «Ошибка представления». См. Опасности чисел с плавающей запятой для более полного описания других распространённых сюрпризов.

Как говорится ближе к концу, «лёгких ответов нет». Тем не менее, не стоит чрезмерно опасаться чисел с плавающей запятой! Ошибки в операциях с float в Python наследуются от аппаратного обеспечения с плавающей запятой, и на большинстве машин составляют не более 1 части на 2**53 за операцию. Этого более чем достаточно для большинства задач, но необходимо помнить, что это не десятичная арифметика, и что каждая операция с float может привести к новой ошибке округления.

Хотя патологические случаи существуют, при обычном использовании арифметики с плавающей запятой вы в итоге увидите ожидаемый результат, если просто округлите отображение конечных результатов до ожидаемого числа десятичных знаков. Для точного управления отображением чисел с плавающей запятой обратитесь к спецификаторам формата метода str.format() в Синтаксисе строк форматирования.

>>> 0.1 + 0.2
0.30000000000000004

1 / 10 ~= J / (2**N)

J ~= 2**N / 10

>>> 2**52
4503599627370496
>>> 2**53
9007199254740992
>>> 2**56/10
7205759403792793

>>> q, r = divmod(2**56, 10)
>>> r
6

>>> q+1
7205759403792794

7205759403792794 / 72057594037927936

>>> .1 * 2**56
7205759403792794.0

>>> 7205759403792794 * 10**30 // 2**56
100000000000000005551115123125L