Как работает функция round в Python: синтаксис и примеры
Основы функции round
Функция round() предназначена для округления чисел с плавающей запятой до указанного количества знаков после запятой или до ближайшего целого. Это встроенная функция, не требующая импорта дополнительных модулей.
round(number, ndigits=None)Python locals self (locals и self в python)
Аргумент number – число, которое необходимо округлить. ndigits – необязательный параметр, указывающий число знаков после запятой. Если ndigits не задан, округление выполняется до ближайшего целого. Если ndigits отрицателен, округление производится до ближайшего десятка, сотни и т.д.
print(round(3.14159)) # 3
print(round(3.14159, 2)) # 3.14
print(round(3.14159, 4)) # 3.1416Python round (функция round в python)
3 3.14 3.1416
Как округлить число до целого?
Для округления до ближайшего целого достаточно вызвать round() с одним аргументом. Числа с дробной частью 0.5 и выше округляются в большую сторону, но с учетом банковского правила (см. далее).
print(round(4.6)) # 5
print(round(4.3)) # 4
print(round(4.5)) # 4 (банковское округление)
print(round(5.5)) # 65 4 4 6
Как округлить до заданного числа знаков после запятой?
Укажите второй аргумент – количество знаков. Положительное значение ndigits определяет точность справа от десятичной запятой.
print(round(123.4567, 1)) # 123.5
print(round(123.4567, 0)) # 123.0 (округляет до целого, но сохраняет тип float)
print(round(123.4567, 3)) # 123.457123.5 123.0 123.457
Как округлить до десятков, сотен или тысяч?
Отрицательное значение ndigits позволяет округлять целые части числа. Например, -1 округляет до ближайшего десятка, -2 – до сотни и т.д.
print(round(1275, -1)) # 1280
print(round(1275, -2)) # 1300
print(round(1275, -3)) # 1000
print(round(149, -2)) # 100 (банковское правило: 149 -> 100, хотя 150 -> 200)1280 1300 1000 100
Такое округление удобно для финансовых отчетов или при приблизительных вычислениях, где точность до десятков не критична.
Что такое банковское округление и почему оно может вызывать вопросы?
Python использует так называемое «банковское округление» или «округление до ближайшего четного» (round half to even). Когда дробная часть равна ровно 0.5, результат округляется к ближайшему четному целому. Это уменьшает накопление ошибок при большом количестве вычислений.
print(round(2.5)) # 2 (2 – четное)
print(round(3.5)) # 4 (4 – четное)
print(round(4.5)) # 4 (4 – четное)
print(round(5.5)) # 6 (6 – четное)2 4 4 6
Такое поведение может быть неожиданным для тех, кто привык к арифметическому округлению (всегда вверх). Если требуется округление «от нуля» (например, 2.5 -> 3), необходимо использовать кастомные функции или модуль decimal.
Почему round(2.675, 2) дает 2.67 вместо 2.68?
Это классическая проблема представления чисел с плавающей запятой. Число 2.675 в двоичном виде не может быть сохранено точно, поэтому внутреннее значение слегка меньше 2.675, что приводит к округлению в меньшую сторону.
print(round(2.675, 2)) # 2.672.67
Для точного финансового округления рекомендуется использовать модуль decimal:
from decimal import Decimal, ROUND_HALF_UP
value = Decimal('2.675')
rounded = value.quantize(Decimal('0.00'), rounding=ROUND_HALF_UP)
print(rounded) # 2.682.68
В чем отличие round от форматирования строк (f-строки, format)?
Форматирование строк (например, f"{value:.2f}") возвращает строку, которая может быть напечатана с нужным количеством знаков, но не меняет числовое значение. round() возвращает число (float или int). Разница проявляется, когда результат используется в дальнейших вычислениях.
x = 3.14159
formatted = f"{x:.2f}" # строка '3.14'
rounded = round(x, 2) # число 3.14
print(type(formatted)) #
print(type(rounded)) #
# Дальнейшие операции:
print(formatted + " hello") # строка
print(rounded + 1) # 4.14 3.14 hello 4.14
Если нужно только отображение, используйте форматирование. Для числовых расчетов – round().
Расширенные примеры использования round
Пример 1: Округление с Decimal для финансовых расчетов
Модуль decimal позволяет задать желаемый режим округления. Помимо ROUND_HALF_UP доступны ROUND_DOWN, ROUND_UP и другие.
from decimal import Decimal, ROUND_HALF_UP, ROUND_DOWN
price = Decimal('19.995')
print(price.quantize(Decimal('0.01'), rounding=ROUND_HALF_UP)) # 20.00
print(price.quantize(Decimal('0.01'), rounding=ROUND_DOWN)) # 19.99
# Сравнение с обычным round
print(round(19.995, 2)) # 20.0 (тоже, но из-за float может отличаться)20.00 19.99 20.0
Рекомендация: для денежных расчетов используйте Decimal с явным указанием точности и режима округления.
Пример 2: Округление с большими числами и отрицательной точностью
Округление до миллионов или миллиардов может быть полезно в макроэкономике или при приблизительных оценках.
population = 144_000_000
print(round(population, -6)) # 144000000 (до миллионов не меняется)
print(round(population, -7)) # 140000000 (до десятков миллионов)
print(round(149_000_000, -7)) # 150000000 (банковское округление: 149 -> 150, т.к. 5? нет, 149 -> 150? проверим)144000000 140000000 150000000
Обратите внимание: 149000000 при округлении до -7 даёт 150000000 – последняя значащая цифра 9, дробная часть 0.5 не возникает.
Пример 3: Сравнение round с math.floor, math.ceil, math.trunc
Эти функции округляют всегда в одну сторону, игнорируя дробную часть.
import math
x = 3.7
y = -3.7
print(round(x)) # 4
print(math.floor(x)) # 3 (вниз)
print(math.ceil(x)) # 4 (вверх)
print(math.trunc(x)) # 3 (отбрасывает дробную часть)
print(round(y)) # -4 (банковское: -3.5 -> -4? нет, -3.7 -> -4)
print(math.floor(y)) # -4 (вниз от -3.7 -> -4)
print(math.ceil(y)) # -3 (вверх к -3)
print(math.trunc(y)) # -34 3 4 3 -4 -4 -3 -3
Для чисел с равной удаленностью (0.5) round ведет себя иначе: round(-3.5) вернет -4 (ближайшее четное -4).
Пример 4: Собственное округление «вверх от 0.5» (полу-вверх)
Если требуется арифметическое округление (0.5 -> 1), можно реализовать простую функцию.
def round_up(x):
import math
return math.floor(x + 0.5)
print(round_up(2.5)) # 3
print(round_up(3.5)) # 4
print(round_up(-2.5)) # -2 (так как floor(-2.0) = -2, но ожидается -2? арифметически -2.5 -> -2? обычно округление вверх от нуля даёт -2)
# Проверим round:
print(round(2.5)) # 2
print(round(3.5)) # 4
print(round(-2.5)) # -23 4 -2 2 4 -2
Функция round_up имитирует округление «от нуля» для положительных чисел. Для отрицательных чисел поведение может отличаться – можно доработать под нужные правила.
Пример 5: Округление с плавающей запятой и форматирование для научных расчетов
В научных работах часто требуется округлить до определенного количества значащих цифр. round не поддерживает значащие цифры напрямую, но можно комбинировать с логарифмами.
import math
def round_significant(value, digits):
if value == 0:
return 0.0
magnitude = int(math.floor(math.log10(abs(value))))
factor = 10 ** (digits - magnitude - 1)
return round(value * factor) / factor
print(round_significant(1234567, 3)) # 1230000.0
print(round_significant(0.00123456, 3)) # 0.00123
print(round_significant(2.71828, 4)) # 2.7181230000.0 0.00123 2.718
Этот метод полезен для представления результатов с заданной точностью.
Пример 6: Влияние точности float на round при вычислениях
При многократных вычислениях ошибки накапливаются. Покажем, как round может скрыть проблему или, наоборот, выявить её.
a = 0.1 + 0.2
print(a) # 0.30000000000000004
print(round(a, 1)) # 0.3
print(round(a, 2)) # 0.3
print(round(a, 15)) # 0.30000000000000004 (видим исходную ошибку)
# Сравнение с Decimal
from decimal import Decimal
print(Decimal('0.1') + Decimal('0.2')) # 0.30.30000000000000004 0.3 0.3 0.30000000000000004 0.3
Для критически важных расчетов лучше использовать Decimal или рациональную арифметику (fractions).