Округление в Python: round() до двух знаков, Decimal и f-строки

Чтобы округлить число в Python до двух знаков, вызовите round(x, 2).

Разбираем, почему round(2.5) даёт 2, а round(2.675, 2) даёт 2.67, как округлить по школьному правилу через Decimal, вывести 2.00 f-строкой и чем отличается округление в NumPy и pandas.

Статью написал:
Ваня Буявец, продюсер, основатель Checkroi
Ваня Буявец
Основатель Checkroi, продюсер, эксперт в выборе онлайн-курсов
Все 3308 статей автора Подписаться на Телеграм-канал
Одобрено экспертом:
Наташа Буявец, основатель Checkroi, эксперт по онлайн-курсам
Наташа Буявец
Основательница Checkroi, продюсер Youtube-каналов, эксперт по онлайн-курсам
Все 3962 экспертных мнения Подписаться на Телеграм-канал
Обложка: Округление в Python: round() до двух знаков, Decimal и f-строки

Чтобы округлить число в Python до двух знаков после запятой, вызовите round(x, 2): round(3.14159, 2) вернёт 3.14. Без второго аргумента функция вернёт целое число.

Учтите две особенности. Ничьи round() решает в пользу чётного, поэтому round(2.5) даёт 2, а не 3. Вторая особенность: дробь хранится в памяти неточно, и round(2.675, 2) выдаёт 2.67.

Если нужно школьное правило, где пятёрка уходит вверх, берите модуль decimal. Если число надо только красиво показать, подойдёт f-строка f"{x:.2f}". Чем float отличается от int, разобрано в статье про типы данных в Python.

Как округлить число до двух знаков после запятой через round()

Рой за ноутбуком округляет число до двух знаков

У функции два аргумента: само число и количество знаков после запятой (ndigits). Второй можно не передавать.

print(round(3.14159, 2))
print(round(10 / 3, 2))
print(round(7.6))
print(round(7.6, 0))
3.14
3.33
8
8.0

Обратите внимание на последние две строки. Без второго аргумента получается int, а с нулём остаётся float. Так написано и в документации Python: результат будет целым, если ndigits не передан, иначе тип совпадает с типом числа.

Второй аргумент бывает и отрицательным. Тогда Python округляет до десятков, сотен и так далее:

Вызов Результат Тип
round(3.14159, 2) 3.14 float
round(7.6) 8 int
round(7.6, 0) 8.0 float
round(1234.567, -2) 1200.0 float
round(1350, -2) 1400 int

Если нужно округлить только вверх, например посчитать число коробок или страниц, round() не подходит. Для этого есть math.ceil, о нём отдельная инструкция: округление в большую сторону в Python.

Как округлить все числа в списке

Отдельной функции для списка нет: round() работает с одним числом. Пройдитесь по списку генератором или через map():

prices = [199.999, 45.5, 3.14159, 10.0]
print([round(p, 2) for p in prices])
print(list(map(round, prices)))
[200.0, 45.5, 3.14, 10.0]
[200, 46, 3, 10]

Генератор списка нужен, когда хочется передать число знаков. map(round, …) короче, но округляет только до целых. Если чисел тысячи и они лежат в таблице, берите NumPy или pandas, о них ниже.

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

Почему round(2.5) возвращает 2: банковское округление

В школе учат, что пятёрка округляется вверх. Python поступает иначе: если число ровно посередине между двумя вариантами, он выбирает ближайшее чётное. Такое правило называют банковским округлением.

print(round(0.5), round(1.5), round(2.5), round(3.5), round(-2.5))
0 2 2 4 -2

Документация описывает это прямо: при равном расстоянии round() выбирает чётный вариант, поэтому round(0.5) и round(-0.5) дают 0, а round(1.5) даёт 2.

Зачем так сделано? На длинном ряду чисел школьное правило всё время тянет сумму вверх: каждая половинка добавляет немного. Чётное правило округляет половинки то вверх, то вниз, и ошибки взаимно гасятся.

Так было не всегда. В документации Python 2 сказано, что ничья уходит от нуля: там round(0.5) давал 1.0. Если вы переносите старый код на третью версию, результаты на половинках могут измениться.

Отсюда первое практическое правило: если заказчик ждёт round(2.5) == 3, встроенная функция не подходит. Как получить школьный вариант, показано ниже в разделе про Decimal.

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

Мерная линейка с делениями и бусина между двумя метками

Здесь дело уже не в чётности. Число 2.675 нельзя точно записать в двоичном виде, и в памяти лежит чуть меньшее значение. Его видно, если передать float в Decimal:

from decimal import Decimal

print(round(2.675, 2))
print(Decimal(2.675))
2.67
2.67499999999999982236431605997495353221893310546875

Python округляет 2.67499… до 2.67, как и положено. В документации к round() этот пример разобран отдельно и назван не ошибкой, а следствием того, что большинство десятичных дробей нельзя представить точно.

Отсюда же классическое 0.1 + 0.2:

import math

print(0.1 + 0.2)
print(0.1 + 0.2 == 0.3)
print(round(0.1 + 0.2, 2) == 0.3)
print(math.isclose(0.1 + 0.2, 0.3))
0.30000000000000004
False
True
True

Сравнивать дроби через == рискованно. Даже предварительное округление помогает не всегда: в разделе учебника о числах с плавающей точкой есть пример, где round() не спасает сравнение. Там же советуют math.isclose(). Про операторы сравнения подробнее в статье «Не равно в Python».

Как округлить по математическим правилам: Decimal и ROUND_HALF_UP

Модуль decimal хранит число в десятичном виде и умеет округлять по разным правилам. Школьное правило называется ROUND_HALF_UP: по документации decimal, это округление до ближайшего, а ничья уходит от нуля.

  1. Импортируйте Decimal и ROUND_HALF_UP.
  2. Создайте число из строки, а не из float.
  3. Вызовите quantize() с образцом точности: Decimal('0.01') для двух знаков, Decimal('1') для целого.
from decimal import Decimal, ROUND_HALF_UP

print(Decimal('2.675').quantize(Decimal('0.01'), rounding=ROUND_HALF_UP))
print(Decimal('2.5').quantize(Decimal('1'), rounding=ROUND_HALF_UP))
print(Decimal(2.675).quantize(Decimal('0.01'), rounding=ROUND_HALF_UP))
2.68
3
2.67

Третья строка показывает ловушку. Decimal(2.675) берёт уже неточный float со всеми его 2.67499…, и правильный режим округления не помогает.

Решение: если число пришло как float, превратите его в строку через str(). Удобно завернуть всё в функцию (как их объявлять через def, разобрано в статье про функции в Python):

from decimal import Decimal, ROUND_HALF_UP

def round_half_up(x, nd=0):
    q = Decimal(1).scaleb(-nd)
    return float(Decimal(str(x)).quantize(q, rounding=ROUND_HALF_UP))

print(round_half_up(2.5), round_half_up(2.675, 2), round_half_up(-2.5))
3.0 2.68 -3.0

−2,5 округляется до −3, потому что ничья уходит от нуля. Если нужно «всегда к большему», в модуле есть и другие режимы, например ROUND_CEILING.

Деньги вообще не стоит переводить во float: храните суммы в Decimal или в копейках как int и округляйте один раз, в конце расчёта.

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

Округление для вывода: f-строки и format()

Часто число нужно не округлить для расчётов, а показать пользователю: в отчёте, чеке, таблице. Тогда нужно форматирование. Оно возвращает строку и сохраняет нули в конце, чего round() не умеет.

x = 3.14159
print(f"{x:.2f}", type(f"{x:.2f}"))
print(round(2.0, 2), f"{2.0:.2f}")
print("{:.2f}".format(x), format(x, '.2f'), "%.2f" % x)
print(f"{1234567.891:,.2f}")
print(f"{0.4567:.1%}")
3.14 <class 'str'>
2.0 2.00
3.14 3.14 3.14
1,234,567.89
45.7%

Все три записи f"{x:.2f}", "{:.2f}".format(x) и "%.2f" % x дают одно и то же. В новом коде чаще пишут f-строки. Разделители тысяч и проценты разобраны в статье про f-строки в Python.

Форматирование подчиняется тем же законам двоичной записи: f"{2.675:.2f}" тоже даст 2.67, а f"{2.5:.0f}" выведет 2.

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

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

Для этих задач есть функции модуля math и встроенная int(). Разница между ними видна на отрицательных числах:

Функция Что делает 2.7 −2.7
math.floor() вниз, к меньшему 2 −3
math.ceil() вверх, к большему 3 −2
math.trunc() отбрасывает дробную часть 2 −2
int() тоже отбрасывает дробную часть 2 −2

Чтобы округлить вниз до двух знаков, умножьте на 100, округлите и разделите обратно: math.floor(2.678 * 100) / 100 даёт 2.67. Помните, что умножение дроби тоже бывает неточным, поэтому в отчётах берите Decimal с режимом ROUND_FLOOR: он работает с десятичной записью числа.

Целочисленное деление // работает как math.floor для частного. Про операторы / и // подробно рассказано в статье о делении в питоне, а про int() рассказано в разборе целых чисел в Python.

Округление в NumPy и pandas: результат бывает другим

В NumPy и pandas округление тоже банковское, но алгоритм другой. np.round умножает число на степень десяти, округляет и делит обратно. Это экономит время на больших массивах, но на тех же дробях результат иногда расходится с round():

import numpy as np
import pandas as pd

print(np.round(2.5), np.round(2.675, 2), round(2.675, 2))

df = pd.DataFrame({'цена': [199.995, 2.675], 'скидка': [0.125, 0.375]})
print(df.round(2))
print(df.round({'цена': 1}))
2.0 2.68 2.67
     цена  скидка
0  200.00    0.12
1    2.68    0.38
    цена  скидка
0  200.0   0.125
1    2.7   0.375

Одно и то же 2.675 в чистом Python становится 2.67, а в NumPy и pandas становится 2.68. В документации NumPy этот алгоритм назван быстрым, но иногда неточным, и приведён свой пример: np.round(16.055, 2) даёт 16.06, а встроенный round даёт 16.05.

Метод df.round() принимает число знаков для всей таблицы или словарь по колонкам, как во втором примере. Как устроены таблицы DataFrame, разобрано в обзоре библиотеки pandas.

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

Какой способ выбрать

Задача Способ Пример
Округлить для дальнейших расчётов round(x, n) round(3.14159, 2) → 3.14
Школьное правило, деньги, отчёты Decimal + ROUND_HALF_UP Decimal('2.675') → 2.68
Показать число с двумя знаками f-строка f"{2.0:.2f}" → ‘2.00’
Только вверх или только вниз math.ceil / math.floor math.ceil(2.1) → 3
Отбросить дробную часть int() или math.trunc() int(-2.7) → −2
Столбец таблицы или массив df.round(), np.round() df.round(2)

Частые ошибки при округлении в Python

Рой доволен: нашёл ошибку в расчёте

Число пришло строкой. Данные из input(), CSV или формы приходят как str, и round() падает:

round("3.14", 1)
# TypeError: type str doesn't define __round__ method

Решение: сначала float("3.14"), потом round(). Как безопасно получить число от пользователя, разобрано в статье про ввод числа в Python.

  • Дробное число знаков. round(3.7, 1.0) падает с TypeError: 'float' object cannot be interpreted as an integer. Второй аргумент должен быть целым.
  • Ожидание 2.00. round(2.0, 2) вернёт 2.0: у числа нет понятия «нули в конце». Нужны два знака на экране? Форматируйте строку.
  • Округление на каждом шаге. Если округлять промежуточные результаты, ошибки копятся. Считайте в полной точности и округляйте один раз перед выводом или записью.
  • Сравнение через ==. 0.1 + 0.2 == 0.3 даёт False. Для дробей используйте math.isclose().

Где освоить 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

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

Как округлить число до двух знаков после запятой в Python?

Вызовите round(x, 2): round(3.14159, 2) вернёт 3.14. Если число нужно только показать на экране с двумя знаками, используйте f-строку f"{x:.2f}", она вернёт строку и сохранит нули в конце.

Почему round(2.5) в питоне возвращает 2?

Встроенная round() решает ничью в пользу ближайшего чётного числа, поэтому round(2.5) даёт 2, а round(3.5) даёт 4. Школьное округление, где пятёрка уходит вверх, даёт Decimal с режимом ROUND_HALF_UP.

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

Число 2.675 хранится в памяти как 2.67499…, потому что в двоичном виде это число не записывается точно, как и большинство десятичных дробей. Чтобы получить 2.68, создайте Decimal из строки '2.675' и округлите через quantize с ROUND_HALF_UP.

Чем round() отличается от int() в Python?

round() округляет до ближайшего целого, а int() просто отбрасывает дробную часть: round(2.7) даёт 3, int(2.7) даёт 2. Для отрицательных int(-2.7) вернёт -2.

Как округлить число вверх или вниз в Python?

Вверх округляет math.ceil(), вниз math.floor(): math.ceil(2.1) даёт 3, math.floor(2.7) даёт 2. Обе функции из модуля math, его нужно импортировать. Подробно про округление вверх рассказано в статье «Округление в большую сторону в Python».

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

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

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