Как округлить число до десятых, сотых и целых: правила и примеры

Чтобы округлить число до десятых, оставьте одну цифру после запятой и посмотрите на следующую за ней (первую отбрасываемую): если это 0-4, оставленная цифра не меняется, если 5-9, она увеличивается на единицу. Пример: 24,75 ≈ 24,8, а 55,31 ≈ 55,3. До сотых и целых правило то же, меняется только разряд, на котором останавливаемся.

Ниже — общий алгоритм, примеры для каждого разряда, типичные ошибки и то, почему функция round() в Python иногда дает «не тот» ответ.

Три термина, которые не стоит путать

• Разряд округления — позиция, до которой округляем: десятки, единицы (целые), десятые, сотые, тысячные.
• Первая отбрасываемая цифра — цифра сразу справа от этого разряда. Решение принимается только по ней (с одной оговоркой про ровно 5, о ней ниже).
• Ошибка округления — модуль разности между исходным и округленным числом. Для 24,75 ≈ 24,8 она равна 0,05.

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

Алгоритм округления для любого разряда

1. Найдите разряд, до которого округляете, и подчеркните цифру в нем.
2. Посмотрите на первую цифру справа от нее.
3. Если это 0, 1, 2, 3 или 4 — подчеркнутая цифра не меняется.
4. Если это 5, 6, 7, 8 или 9 — прибавьте к подчеркнутой цифре единицу. Если там была 9, она становится 0, а единица переносится в следующий разряд слева.
5. Все цифры справа отбросьте (в дробной части) или замените нулями (в целой части).

Это школьное правило, его еще называют округлением «половина вверх». Для отрицательных чисел его применяют к модулю, а знак сохраняют: -2,5 ≈ -3, -2,4 ≈ -2.

Как округлить до десятых

Оставляем одну цифру после запятой, смотрим на вторую.

Обратите внимание на 89,961: при переносе результат пишется как 90,0, а не 90. Ноль в разряде десятых показывает, что число округлено именно до десятых, а не до целых. В записи результата измерения это важно: 90,0 и 90 — разная заявленная точность.

Как округлить до сотых и тысячных

До сотых оставляем две цифры после запятой и смотрим на третью, до тысячных — три и смотрим на четвертую.

• 33,786 до сотых: отбрасываемая 6, значит 33,79.
• 5,972 до сотых: отбрасываемая 2, значит 5,97.
• 2,995 до сотых: отбрасываемая 5, 9 + 1 дает перенос, результат 3,00.
• 4,7864 до тысячных: отбрасываемая 4, значит 4,786.
• 79,99982 до тысячных: отбрасываемая 8, перенос через все девятки, результат 80,000.

Как округлить до целых

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

• 7,49 ≈ 7 (первая отбрасываемая 4, девятка после нее не важна).
• 7,5 ≈ 8.
• 0,53 ≈ 1.
• 12,98 ≈ 13.

Как округлить до десятков, сотен и тысяч

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

Частые ошибки

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

Решение по последней цифре, а не по первой отбрасываемой. В 3,149 до десятых девятка в конце ничего не решает: смотрим на 4, ответ 3,1.

Потеря нулей после переноса. 0,96 до десятых — это 1,0, а 2,995 до сотых — 3,00. Если нули нужны в отчете, их пишут явно.

Смешение с отбрасыванием. Отбрасывание (усечение) просто стирает хвост: 7,9 превращается в 7. Это другая операция, и в программировании у нее отдельные функции.

Ровно пятерка: школьное и банковское округление

Спорный случай один — когда отбрасывается ровно 5 и за ней нет ненулевых цифр (2,5; 0,125 до сотых). В школьной математике такое число округляют вверх по модулю: 2,5 ≈ 3.

Есть и другое соглашение — банковское округление (к ближайшему четному): ровно половину округляют так, чтобы последняя оставленная цифра стала четной. 2,5 ≈ 2, 3,5 ≈ 4, 0,125 ≈ 0,12. Зачем: при большом количестве положительных сумм школьное правило систематически завышает итог (половины всегда уходят вверх по модулю), а четное округление в среднем распределяет их поровну вверх и вниз. Если после пятерки есть ненулевые цифры (2,51), оба правила дают одно и то же: вверх.

Упрощенно: правила различаются только на ровной половине. Какое применять в расчете, решает методика (регламент бухгалтерии, стандарт обработки измерений, требование задачи), а не вкус.

Округление в Python: почему round(2.5) дает 2

Встроенная функция round() в Python 3 использует банковское округление. Прогон на Python 3.14:

print(round(2.5), round(3.5), round(-2.5))   # к четному
print(round(0.25, 1), round(0.35, 1))
print(round(2.675, 2))
print(round(1225, -1), round(1235, -1))      # отрицательный разряд - десятки

Вывод:

2 4 -2
0.2 0.3
2.67
1220 1240

С первой строкой все ясно: это правило четной цифры. Со второй и третьей сложнее. round(0.35, 1) дает 0.3, хотя 3 нечетная и банковское правило должно было дать 0.4. Причина — двоичная дробь: тип float хранит 0.35 не точно, а как ближайшее двоичное значение, которое чуть меньше:

from decimal import Decimal
print(Decimal(2.675))
print(Decimal(0.35))

2.67499999999999982236431605997495353221893310546875
0.34999999999999997779553950749686919152736663818359375

То есть round() честно округляет то, что лежит в памяти, а там уже не половина. 0.25 же представим в двоичном виде точно, поэтому для него сработало правило четной цифры (0.2). Форматирование f"{x:.2f}" ведет себя так же, это не обходной путь.

Школьное округление в Python через Decimal

Если нужен ответ «как в учебнике» (или по регламенту «половина вверх»), берите модуль decimal и создавайте числа из строк. Минимальный рабочий пример:

from decimal import Decimal, ROUND_HALF_UP

def round_school(x: str, places: int = 0) -> Decimal:
    """Школьное округление: цифра 5 и больше - вверх (по модулю)."""
    step = Decimal(1).scaleb(-places)  # 1 -> 0.1, 2 -> 0.01, -1 -> десятки
    result = Decimal(x).quantize(step, rounding=ROUND_HALF_UP)
    return result if places >= 0 else Decimal(int(result))

print(round_school("24.75", 1))     # до десятых
print(round_school("89.961", 1))    # до десятых с переносом
print(round_school("33.786", 2))    # до сотых
print(round_school("79.99982", 3))  # до тысячных
print(round_school("0.5"))          # до целых
print(round_school("-2.5"))         # отрицательное
print(round_school("787", -1))      # до десятков
print(round_school("9855", -2))     # до сотен

24.8
90.0
33.79
80.000
1
-3
790
9900

Результаты совпадают с ручными примерами выше, включая нули после переноса (90.0, 80.000). Разбор по строкам:

• Decimal(1).scaleb(-places) строит шаг округления: 0.1 для десятых, 0.01 для сотых, 1E+1 для десятков.
• quantize(step, rounding=ROUND_HALF_UP) округляет до этого шага по школьному правилу.
• Для десятков и сотен quantize возвращает запись вида 7.9E+2, поэтому результат приводим к целому, чтобы печаталось 790.

Главное условие — строка на входе. Сравните:

from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN

cent = Decimal("0.01")
for s in ["0.125", "0.135"]:
    x = Decimal(s)
    print(s, x.quantize(cent, rounding=ROUND_HALF_UP),
          x.quantize(cent, rounding=ROUND_HALF_EVEN))

print(Decimal(2.675).quantize(cent, rounding=ROUND_HALF_UP))       # из float
print(Decimal(str(2.675)).quantize(cent, rounding=ROUND_HALF_UP))  # из строки

0.125 0.13 0.12
0.135 0.14 0.14
2.67
2.68

Decimal(2.675) из float уже содержит 2.67499…, и никакой режим округления это не исправит. Decimal(str(2.675)) берет короткую запись ‘2.675’ и дает ожидаемые 2.68. Надежнее всего получать числа сразу строкой (из файла, формы, базы), не пропуская их через float.

Округление, отбрасывание и округление вверх

Для округления до целого в Python есть три функции помимо round(), и на отрицательных числах разница видна сразу:

import math
print(math.floor(-2.7), math.ceil(-2.7), math.trunc(-2.7), round(-2.7))

-3 -2 -2 -3

ceil нужен, когда недобор недопустим: сколько автобусов на 130 человек по 50 мест — math.ceil(130 / 50) дает 3.

В других языках правило для половины свое. Например, в JavaScript (проверено в Node.js 24) Math.round(2.5) дает 3, а Math.round(-2.5) дает -2: половина округляется в сторону плюс бесконечности, а не по модулю. Перед переносом расчета между языками проверяйте именно случай ровной половины и отрицательных чисел. Как это устроено в C#, разобрано в статье про округление чисел в C#.

Выводы

• Округление до любого разряда решается по одной цифре — первой отбрасываемой: 0-4 оставляем, 5-9 увеличиваем на единицу с переносом.
• В дробной части лишние цифры отбрасывают, в целой заменяют нулями; нули после переноса (90,0; 3,00) показывают точность и их пишут явно.
• Округлять нужно один раз от исходного числа: цепочка 2,449 -> 2,45 -> 2,5 дает неверный ответ вместо 2,4.
• Школьное и банковское округление расходятся только на ровной половине; round() в Python использует банковское.
• Для школьного правила в Python берут Decimal из строки и ROUND_HALF_UP, потому что float хранит 2.675 как 2.67499…

Где применяется / связь с практикой

FAQ

Как округлить отрицательное число?
По школьному правилу — как положительное по модулю, затем вернуть знак: -3,46 до десятых = -3,5. В программировании поведение зависит от функции: в Python round(-2.5) дает -2, в JavaScript Math.round(-2.5) тоже -2, но по другой причине.

Как округлить до значащих цифр, а не до разряда?
Отсчитайте нужное количество цифр слева, начиная с первой ненулевой, и примените то же правило к следующей цифре: 0,004582 с тремя значащими цифрами = 0,00458, а 45632 с двумя = 46000.

Нужно ли округлять промежуточные результаты расчета?
Обычно нет: считают с полной точностью и округляют только итог. Исключение — когда методика прямо требует округлять каждую операцию (например, каждую строку счета до копеек), тогда итог считают уже по округленным строкам.