Арифметика с плавающей запятой: проблемы и ограничения¶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...

Если остановиться на любом конечном числе битов, получается приближение. Поэтому можно увидеть такие результаты:

>>> 0.1
0.10000000000000001

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

>>> 0.1
0.1000000000000000055511151231257827021181583404541015625

Напротив! Приглашение Python использует встроенную функцию repr() для получения строкового представления всего, что оно отображает. Для чисел с плавающей запятой repr(float) округляет истинное десятичное значение до 17 значащих цифр, выдавая

0.10000000000000001

repr(float) выдаёт 17 значащих цифр, поскольку оказывается, что этого достаточно (на большинстве машин), чтобы eval(repr(x)) == x для всех конечных чисел с плавающей запятой x, но округление до 16 цифр уже не обеспечивает этого.

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

Встроенная функция str() в Python выдаёт только 12 значащих цифр, и, возможно, вы предпочтёте использовать её. Обычно eval(str(x)) не воспроизводит x, но вывод может быть более приятным для глаз:

>>> print(str(0.1))
0.1

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

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

>>> 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

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

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

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

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

Другой вид точной арифметики поддерживается модулем fractions, который реализует арифметику на основе рациональных чисел (так что числа вроде 1/3 могут быть представлены точно).

Если вы активно используете операции с плавающей запятой, вам стоит взглянуть на пакет Numerical Python и многие другие пакеты для математических и статистических операций, предоставляемые проектом SciPy. См. <http://scipy.org>.

Python предоставляет инструменты, которые могут помочь в тех редких случаях, когда вы действительно хотите узнать точное значение числа с плавающей запятой. Метод float.as_integer_ratio() выражает значение числа с плавающей запятой в виде дроби:

>>> x = 3.14159
>>> x.as_integer_ratio()
(3537115888337719L, 1125899906842624L)

Поскольку отношение точное, его можно использовать для восстановления исходного значения без потерь:

>>> x == 3537115888337719 / 1125899906842624
True

Метод float.hex() выражает число с плавающей запятой в шестнадцатеричном формате (основание 16), снова предоставляя точное значение, хранящееся на вашем компьютере:

>>> x.hex()
'0x1.921f9f01b866ep+1'

Это точное шестнадцатеричное представление можно использовать для точного восстановления значения числа с плавающей запятой:

>>> x == float.fromhex('0x1.921f9f01b866ep+1')
True

Поскольку представление точное, оно полезно для надёжного переноса значений между разными версиями Python (независимость от платформы) и обмена данными с другими языками, поддерживающими тот же формат (например, Java и C99).

>>> 0.1
0.10000000000000001

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

J ~= 2**N / 10

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

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

>>> q+1
7205759403792794

7205759403792794 / 72057594037927936

>>> .1 * 2**56
7205759403792794.0

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