Числа с плавающей точкой: что это и почему 0,1 + 0,2 не равно 0,3

Почему компьютер, который выполняет миллиарды операций в секунду, ошибается в сумме 0,1 + 0,2?

Разбираем простыми словами, как устроены числа с плавающей точкой, чем float отличается от double и почему NaN не равен сам себе.

Примеры на Python и JavaScript можно повторить у себя за минуту, они пригодятся тем, кто только начал программировать или сводит данные в Excel.

После статьи вы будете знать, как сравнивать дроби и хранить деньги без потерянных копеек.

Статью написал:
Ваня Буявец, продюсер, основатель Checkroi
Ваня Буявец
Основатель Checkroi, продюсер, эксперт в выборе онлайн-курсов
Все 3380 статей автора Подписаться на Телеграм-канал
Одобрено экспертом:
Наташа Буявец, основатель Checkroi, эксперт по онлайн-курсам
Наташа Буявец
Основательница Checkroi, продюсер Youtube-каналов, эксперт по онлайн-курсам
Все 4033 экспертных мнения Подписаться на Телеграм-канал
Обложка: Числа с плавающей точкой: что это и почему 0,1 + 0,2 не равно 0,3

Откройте консоль браузера или Python и сложите 0,1 и 0,2. Вместо 0,3 получится 0.30000000000000004. Язык и компьютер тут исправны. Так работают числа с плавающей точкой: формат, в котором почти любая программа хранит дроби.

Ниже разберём простыми словами, как устроено такое число, почему одни дроби в нём записываются точно, а другие нет, чем float отличается от double и как писать код, который не теряет копейки. Вывод в примерах показан ровно таким, каким его печатает Python 3.

Если вы только начинаете разбираться, какие вообще бывают типы данных, сначала загляните в обзор типов данных в программировании: там на пальцах объяснено, чем целое число отличается от дробного.

Почти всё здесь упирается в двоичную систему счисления. Освежить, как десятичное число превращается в нули и единицы, поможет статья о системах счисления в Python.

Материал пригодится и тем, кто пишет первые программы, и тем, кто считает данные в таблицах. А если хочется пройти программирование по порядку, с наставником и практикой, посмотрите курсы программирования в нашем каталоге.

Что такое число с плавающей точкой простыми словами

Рой у доски объясняет экспоненциальную запись числа

Число с плавающей точкой (его же называют числом с плавающей запятой, по-английски floating point) — способ записать дробь (в математике говорят «вещественное число») как набор значащих цифр и указание, куда поставить разделитель. Плавающей точку называют потому, что она не прибита к одному месту и сдвигается в зависимости от величины числа.

Вы уже видели такую запись на уроках физики. Расстояние до Солнца пишут как 1,5 × 108 км, а массу электрона как 9,1 × 10−31 кг. Это экспоненциальная запись (её ещё называют научной нотацией): короткое число, умноженное на десять в нужной степени.

Компьютер делает то же самое, только в двоичной системе. Вместо десятки в основании стоит двойка, а цифры бывают только 0 и 1. Отсюда и все странности, о которых пойдёт речь дальше.

Точка или запятая? В русской математике дробную часть отделяют запятой, а в языках программирования всегда пишут точку: 3.14, а не 3,14. Поэтому оба названия правильные, просто «точка» пришла из английского.

Фиксированная и плавающая точка: в чём разница

Представьте кассовый аппарат, у которого на табло восемь клеток: шесть под рубли и две под копейки. Это фиксированная точка. Разделитель всегда стоит в одном месте, поэтому с копейками такой аппарат считает точно, но больше 999 999,99 показать не может, а десятую долю копейки не покажет вовсе.

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

Цена этой гибкости: точность относительная. У большого числа «шаг сетки» между соседними значениями большой, у маленького крошечный. А ровно 0,1 в этой сетке может вообще не оказаться.

Параметр Фиксированная точка Плавающая точка
Где разделитель всегда в одном месте сдвигается под величину числа
Диапазон узкий огромный: от 10−308 до 10308 у double
Точность одинаковая по всей шкале около 15 значащих цифр у double
Где применяют деньги, микроконтроллеры, аудио наука, графика, игры, машинное обучение
Пример типа Decimal, numeric, копейки в int float, double
Канал основателя Checkroi Вани Буявца3 800 человек читают мой Телеграм-канал про нейросетиСобрал промпты для Claude Code и ChatGPT, разборы ИИ-инструментов и лайфхаки по продвижению бизнеса в одном местеПрисоединиться

Как число хранится в памяти: знак, порядок и мантисса

Правила записи закреплены в международном стандарте IEEE 754. По нему работают процессоры, Python, JavaScript, Java, C, базы данных и Excel, поэтому 0,1 + 0,2 выглядит одинаково почти везде.

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

  • знаковый бит: 0 для плюса, 1 для минуса;
  • порядок (экспонента): на какую степень двойки умножить число, то есть куда сдвинуть точку;
  • мантисса: сами значащие цифры числа.

Мантисса простыми словами: это «тело» числа без нулей в начале и без степени. У 0,000123 мантисса 1,23, а порядок −4. В двоичной записи мантисса всегда начинается с единицы перед точкой (такое число называют нормализованным), поэтому эту единицу даже не хранят, она подразумевается и экономит один бит.

Порядок хранят со смещением, чтобы не тратить отдельный бит на его знак. У 32-битного числа к настоящему порядку прибавляют 127: порядок −4 записывается как 123.

Пример: как выглядит 0,1 в памяти

Вот 0,1 в формате одинарной точности (32 бита), разбитое на три части. Это вывод Python из модуля struct:

import struct
bits = format(struct.unpack('>I', struct.pack('>f', 0.1))[0], '032b')
print(bits)
# 00111101110011001100110011001101

Первый бит 0: число положительное. Следующие восемь бит 01111011 дают 123, минус смещение 127, получаем порядок −4. Оставшиеся 23 бита 10011001100110011001101 вместе со скрытой единицей дают мантиссу примерно 1,6. Проверяем: 1,6 × 2−4 = 0,1.

Обратите внимание на хвост мантиссы: «1001» повторяется, и последний бит округлён вверх. Это и есть корень всей истории.

Почему 0,1 + 0,2 не равно 0,3

Числовая линейка с делениями, отметка 0,3 стоит между двумя соседними делениями

Дробь 1/3 нельзя точно записать в десятичной системе: 0,333… тянется бесконечно, и где бы вы ни остановились, получится приближение. В двоичной системе то же самое происходит с 1/10. Документация Python в разделе о плавающей точке показывает её запись: 0,0001100110011001100110011… и так без конца.

Хранить бесконечную дробь негде, поэтому компьютер обрезает её на 53-м значащем бите (столько точности у формата двойной точности) и хранит ближайшее значение. Его можно увидеть целиком:

from decimal import Decimal
print(Decimal(0.1))
# 0.1000000000000000055511151231257827021181583404541015625

Значит, в переменной лежит не 0,1, а число чуть больше. С 0,2 та же история. Складываем два чуть-чуть неточных числа, результат тоже округляется, и итог расходится с 0,3 в семнадцатом знаке:

print(0.1 + 0.2)
# 0.30000000000000004
print(0.1 + 0.2 == 0.3)
# False

Главная мысль. Арифметика здесь ни при чём: 0,1 и 0,2 просто не помещаются в двоичный формат точно. Дроби вида 0,5, 0,25 или 0,375 (это суммы степеней двойки) хранятся без погрешности, и с ними 0,25 + 0,5 == 0,75 даёт True.

Такая погрешность float крошечная: у одной операции она порядка одной части на 253, то есть около 10−16 от величины числа. Для расчёта траектории мяча в игре это ничто. Проблемы начинаются, когда результат сравнивают через «равно» или когда ошибки копятся.

Float и double: чем отличаются

В стандарте несколько размеров числа, на практике встречаются два. Одинарная точность (float) занимает 32 бита, двойная (double) занимает 64. Разница между float и double в том, сколько бит отдано под мантиссу и порядок, а значит, сколько цифр число хранит точно и насколько большим может быть.

Параметр float (одинарная) double (двойная)
Размер 32 бита 64 бита
Знак / порядок / мантисса 1 / 8 / 23 бита 1 / 11 / 52 бита
Точных десятичных цифр около 6–7 около 15–16
Максимальное значение около 3,4 × 1038 около 1,8 × 10308
Как хранится 0,1 0.100000001490116… 0.100000000000000005…
Где по умолчанию видеокарты, нейросети, игры Python, JavaScript, Excel, научные расчёты

Названия типов в языках путают новичков, тем более что языки по-разному обращаются с типами вообще (об этом статья про типизацию в программировании). В C, C++, Java и C# есть оба: float и double. А в Python тип называется float, но внутри это double, 64 бита. В JavaScript есть только один числовой тип Number, и это тоже double.

Что выбрать: если не уверены, берите double (в Python и JavaScript он и так единственный). Float нужен там, где чисел миллионы и важна память: в графике и нейросетях. Подробнее про числовые типы в одном языке рассказано в таблице типов данных Python.

CheckroiCheckroiПодборка курсов по JavaScript185 курсов • 30 школСравните цены, школы, программу и найдите выгодные предложения по обучениюСравнить→

Особые значения: бесконечность, NaN и два нуля

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

Бесконечность (inf) появляется при переполнении, когда результат больше максимума формата. 1e308 * 10 в Python даёт inf, а не ошибку. В JavaScript то же самое получится при делении на ноль: 1 / 0 вернёт Infinity. Python в этом случае выбрасывает исключение ZeroDivisionError.

NaN (Not a Number, «не число») возникает, когда у операции нет осмысленного ответа: бесконечность минус бесконечность, ноль на ноль. Главная ловушка NaN: он не равен даже самому себе.

n = float('nan')
print(n == n)
# False
print(float('inf') - float('inf'))
# nan

Поэтому проверять NaN надо специальной функцией: math.isnan() в Python, Number.isNaN() в JavaScript.

Ещё в формате есть отрицательный ноль: знаковый бит 1, всё остальное нули. При сравнении 0.0 == -0.0 даёт True, так что в обычном коде он почти не мешает. Ну и денормализованные числа: очень маленькие значения около нуля, у которых скрытая единица в мантиссе не подразумевается. Они позволяют плавно подойти к нулю, но на многих процессорах вычисления с ними идут медленнее.

CheckroiCheckroiПодборка курсов по Python587 курсов • 55 школСравните цены, школы, программу и найдите выгодные предложения по обучениюСравнить→ Ваня БуявецКанал основателя Checkroi Вани БуявцаЗабирайте промпты и обучение по нейросетям в моём Телеграм-каналеБольше 3 800 человек уже применяют Claude Code, ChatGPT и другие нейросети в работе, учёбе, бизнесе и жизниПерейти в канал

Где ошибки накапливаются и к чему это приводит

Одна погрешность в 10−16 незаметна. Неприятности начинаются в трёх ситуациях.

Сложение в цикле

Допустим, вы делаете свою первую игру, считаете в ней время и каждый кадр прибавляете 0,1 секунды. После десяти шагов ждёте ровно 1:

s = 0.0
for _ in range(10):
    s += 0.1
print(s, s == 1.0)
# 0.9999999999999999 False

Условие if s == 1.0 не сработает никогда. Решение: хранить счётчик шагов целым числом и умножать в конце, или сравнивать с допуском (об этом ниже).

Порядок действий меняет ответ

В школе нас учили, что от перестановки слагаемых сумма не меняется. Для плавающей точки это неверно, потому что округление происходит после каждой операции:

print((0.1 + 0.2) + 0.3)
# 0.6000000000000001
print(0.1 + (0.2 + 0.3))
# 0.6

Большие и маленькие числа вместе

У double около 15–16 точных цифр. Если сложить 1016 и 1, единица просто не поместится в мантиссу и исчезнет: 1e16 + 1 - 1e16 вернёт 0.0.

По той же причине целые числа больше 253 (это 9 007 199 254 740 992) нельзя хранить в double без потерь. В JavaScript эта граница записана в константу Number.MAX_SAFE_INTEGER, по справочнику MDN она равна 253 − 1. Отсюда частая причина, по которой большие ID из базы данных приходят в браузер искажёнными.

Как правильно сравнивать дробные числа

Рой сравнивает два почти одинаковых груза на точных весах

Правило простое: дробные числа не сравнивают через ==. Вместо «равны ли» спрашивают «достаточно ли близки».

В Python для этого есть готовая функция math.isclose(). По умолчанию она считает числа равными, если они совпадают примерно в девяти знаках:

import math
print(math.isclose(0.1 + 0.2, 0.3))
# True

В JavaScript готовой функции нет, и обычно сравнивают разницу с маленьким порогом. Подойдёт Number.EPSILON: это машинный эпсилон, разница между единицей и следующим представимым числом, около 2,2 × 10−16 (подробнее в справочнике MDN).

console.log(Math.abs(0.1 + 0.2 - 0.3) < Number.EPSILON);
// true

Нюанс для тех, кто пойдёт дальше: эпсилон хорош для чисел около единицы. Для больших значений допуск нужен относительный (доля от величины числа), именно так устроен math.isclose. В C++ и C подход тот же, только функцию сравнения пишут сами; про операторы и их подводные камни есть разбор операторов в C.

Деньги: почему не float и что использовать вместо него

Для денег погрешность в семнадцатом знаке недопустима: тысячи операций в день, отчёты, сверка с банком. Если хранить цену 19,99 ₽ во float, рано или поздно в отчёте появится копейка, которой нет. Есть три проверенных способа.

Способ 1: целые копейки. Храните сумму в самых мелких единицах: 19,99 ₽ превращается в 1999 копеек. Целые числа складываются точно, а рубли с копейками собирают только при выводе на экран. Это самый простой вариант, и ошибиться в нём сложнее всего.

Способ 2: десятичный тип. В Python это модуль decimal, в Java BigDecimal, в C# тип decimal. Он хранит число в десятичной системе и считает так, как мы на бумаге. Важная деталь: создавать Decimal надо из строки, иначе в него попадёт уже испорченное float-значение.

from decimal import Decimal
print(Decimal("0.1") + Decimal("0.2"))
# 0.3
print(Decimal(0.1) + Decimal(0.2))
# 0.3000000000000000166533453694

Способ 3: правильный тип в базе данных. Документация PostgreSQL прямо пишет, что типы real и double precision неточные, а для денежных сумм рекомендует numeric (раздел о числовых типах). Сравнение типов по разным СУБД есть в статье про типы данных в SQL.

CheckroiCheckroiПодборка курсов по PostgreSQL167 курсов • 28 школСравните цены, школы, программу и найдите выгодные предложения по обучениюСравнить→

Ловушка с округлением

Округление тоже работает с неточным числом. Документация Python к функции round() приводит пример: round(2.675, 2) даёт 2.67, а не 2.68, потому что 2,675 хранится как число чуть меньше. В JavaScript похожий эффект у (1.005).toFixed(2): результат "1.00".

Ещё одна неожиданность Python: round() округляет половинки до ближайшего чётного, поэтому round(0.5) даёт 0, а round(2.5) даёт 2. Это так называемое банковское округление. Все способы округлить число по нужному правилу собраны в материале про округление в Python, а для округления вверх есть отдельный разбор math.ceil и деления.

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

Плавающая точка в Excel

Excel тоже работает по IEEE 754, поэтому сталкиваются с плавающей точкой не только программисты. Microsoft в статье о неточных результатах вычислений поясняет: Excel хранит числа с точностью до 15 знаков, и всё, что дальше, отбрасывается. Там же разобрано, что десятичная дробь 0,1 в двоичной записи повторяется бесконечно и при хранении даёт ошибку около −2,8E-17.

На практике это выглядит так: формула сравнения двух вроде бы одинаковых сумм возвращает ЛОЖЬ, или в ячейке вместо нуля появляется крошечное число вроде −2,8E-17. В той же статье Microsoft первым способом исправить ошибку названа функция ROUND, в русском Excel она называется ОКРУГЛ: результат округляют перед сравнением. Как ей пользоваться и чем она отличается от соседних функций, рассказано в инструкции по округлению в Excel.

Вторая особенность: номер карты, ИНН или длинный артикул из 16 и больше цифр Excel превращает в число и обрезает после 15-й цифры. Такие значения храните как текст.

Шпаргалка: числа с плавающей точкой в разных языках

В любом языке с типом double сумма 0,1 + 0,2 выглядит одинаково, различаются только инструменты, которыми обходят погрешность.

Язык Тип дроби по умолчанию Как сравнивать Чем считать деньги
Python float (64 бита) math.isclose() decimal.Decimal из строки, int в копейках
JavaScript Number (64 бита) разница < Number.EPSILON целые копейки, BigInt
Java double Math.abs(a — b) < eps BigDecimal
C# double Math.Abs(a — b) < eps decimal
C и C++ double fabs(a — b) < eps целые копейки
SQL (PostgreSQL) double precision сравнение с допуском numeric
Excel число (64 бита) ОКРУГЛ перед сравнением ОКРУГЛ до копеек в каждой формуле

Если хотите копнуть математику глубже, классический текст на эту тему написал Дэвид Голдберг: «Что каждый программист должен знать об арифметике с плавающей точкой». Он на английском и требует знания математики, зато отвечает почти на любой вопрос.

Где научиться программированию

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

Python для этого удобен: в нём легко проверить всё, о чём шла речь, прямо в консоли. Ниже подборка курсов по Python с ценами и рейтингом школ.

КурсШколаСтоимость со скидкойВ рассрочкуДлитель­ностьОбзор курса от Checkroi
Профессия «Python-разработчик»
Перейти на сайт курса
SkillboxSkillbox157 335 ₽5987 ₽/мес.10 месяцевОбзор курса
Fullstack-разработчик на Python
Перейти на сайт курса
НетологияНетология137 000 ₽7125 ₽/мес.21 месяцОбзор курса
ДО Профессия Python-разработчик
Перейти на сайт курса
GeekBrainsGeekBrains149 001 ₽3167 ₽/мес.10 месяцевОбзор курса
Автоматизированное тестирование на Python
Перейти на сайт курса
SkillboxSkillbox118 754 ₽4108 ₽/мес.9 месяцевОбзор курса
Профессия Python-разработчик
Перейти на сайт курса
SkillFactorySkillFactory140 040 ₽3890 ₽/мес.10 месяцевОбзор курса
Разработчик на Python
Перейти на сайт курса
НетологияНетология175 000 ₽5500 ₽/мес.6 месяцевОбзор курса
Профессия «Python-разработчик с нуля до трудоустройства»
Перейти на сайт курса
НетологияНетология81 800 ₽5500 ₽/мес.6 месяцевОбзор курса
Профессия Fullstack-разработчик на Python
Перейти на сайт курса
SkillFactorySkillFactory158 040 ₽4390 ₽/мес.16 месяцевОбзор курса
Python-разработчик + ИИ
Перейти на сайт курса
Академия СинергияАкадемия Синергия77 900 ₽3246 ₽/мес.6 месяцевОбзор курса
Python-фреймворк Django
Перейти на сайт курса
SkillboxSkillbox58 396 ₽5128 ₽/мес.3 месяцаОбзор курса

Больше программ — в полном каталоге курсов по Python

Если вы выбираете первый язык, начните с плана из статьи «Программирование с нуля». А для фронтенда пригодится каталог курсов по JavaScript: на этом языке с плавающей точкой сталкиваются в первую же неделю, когда считают корзину интернет-магазина.

Часто задаваемые вопросы

Что такое число с плавающей точкой простыми словами?

Это способ хранить дробь в памяти компьютера как набор значащих цифр (мантиссу) и степень двойки (порядок), которая показывает, куда сдвинуть точку. Так в одном формате помещаются и очень большие, и очень маленькие числа, но точность у них ограничена примерно 15–16 цифрами.

Как правильно: с плавающей точкой или с плавающей запятой?

Оба названия верные и обозначают одно и то же. «Точка» пришла из английского floating point и из языков программирования, где дробную часть всегда отделяют точкой, «запятая» ближе к русской математической традиции.

Почему 0,1 + 0,2 не равно 0,3 в Python и JavaScript?

Число 0,1 в двоичной системе превращается в бесконечную дробь, и компьютер хранит ближайшее приближение, чуть большее 0,1. То же с 0,2. При сложении неточности складываются, и результат печатается как 0.30000000000000004. Это свойство стандарта IEEE 754, а не ошибка конкретного языка.

Чем float отличается от double?

Float занимает 32 бита и хранит около 6–7 точных цифр, double занимает 64 бита и хранит около 15–16 цифр, а его диапазон доходит примерно до 1,8 × 10308. В Python тип float внутри устроен как double, а в JavaScript единственный числовой тип Number тоже double.

Как сравнивать числа с плавающей точкой?

Не через ==, а с допуском. В Python есть функция math.isclose(), в JavaScript сравнивают модуль разницы с Number.EPSILON или с порогом, подобранным под величину чисел. Подробнее об этом в разделе статьи о сравнении дробных чисел.

Можно ли хранить деньги во float?

Лучше не надо: ошибки округления рано или поздно дадут лишнюю или потерянную копейку. Суммы хранят в целых копейках или в десятичном типе: Decimal в Python, BigDecimal в Java, numeric в PostgreSQL. Подробности о типах в базах данных есть в статье про типы данных в SQL.

Что такое мантисса и порядок?

Мантисса содержит значащие цифры числа, порядок показывает, на какую степень двойки их умножить. Например, у 0,1 в 32-битном формате порядок равен −4, а мантисса около 1,6: 1,6 × 2−4 = 0,1. Третья часть числа, знаковый бит, отвечает за плюс или минус.

Почему round(2.675, 2) в Python даёт 2.67?

Число 2,675 хранится в памяти как значение чуть меньше 2,675, поэтому округление уходит вниз. Документация Python приводит именно этот пример. Если нужно точное округление по правилам бухгалтерии, используйте Decimal, способы описаны в статье про округление в Python.

Как посмотреть, как число хранится в формате IEEE 754?

В Python это делает модуль struct: struct.pack('>f', 0.1) упаковывает число в 32 бита, а format(..., '032b') печатает их нулями и единицами. Для быстрой проверки есть и онлайн-калькуляторы IEEE 754, но собственный код из статьи показывает то же самое без сторонних сайтов.

Читайте Checkroi первым в Google
Добавьте Checkroi в избранные источники — и наши разборы курсов и обзоры школ будут показываться выше в вашей выдаче Google.
Оставить комментарий
0 комментариев
Форма комментария

Оставьте комментарий

Напишите, что думаете. Нам важно ваше мнение!