Round: примеры (PYTHON)

Простые примеры использования

Округление до целого числа:

print(round(10.4))  # 10
print(round(10.6))  # 11

10
11

Округление с указанием количества знаков:

print(round(3.14159, 2))  # Округление до двух знаков
print(round(2.675, 2))    # Демонстрация особенностей двоичной арифметики

3.14
2.67

Использование отрицательного значения ndigits (округление до десятков, сотен и т.д.):

print(round(1234, -1))  # До десятков
print(round(1234, -2))  # До сотен
print(round(1234, -3))  # До тысяч

1230
1200
1000

Похожие функции в Python

Для округления чисел в Python также используются:

• math.floor(x) – округление вниз до ближайшего целого числа. Всегда возвращает int.
• math.ceil(x) – округление вверх до ближайшего целого числа. Всегда возвращает int.
• int(x) – отбрасывание дробной части (округление к нулю). Работает как для положительных, так и для отрицательных чисел.
• format() или f-строки – округление для форматированного вывода без изменения самого числа.

Функцию round применяют для математического округления с произвольной точностью. math.floor и math.ceil нужны для гарантированного направления округления. Преобразование int() подходит для получения целой части. Форматирование используют исключительно для представления строк.

Округление в других языках программирования

Поведение функций округления может отличаться.

JavaScript: Метод Math.round() округляет до ближайшего целого, используя правило "половина от большего" (round half up). Для указания количества знаков часто применяют Number.toFixed(), который возвращает строку.

console.log(Math.round(2.5)); // 3
console.log((2.675).toFixed(2)); // "2.68"

3
"2.68"

PHP: Функция round() имеет третий параметр mode для выбора стратегии округления (например, PHP_ROUND_HALF_UP).

echo round(2.5, 0, PHP_ROUND_HALF_UP); // 3
echo round(2.5, 0, PHP_ROUND_HALF_EVEN); // 2

3
2

Java: Класс Math содержит метод round(), который всегда округляет до long или int по принципу half up. Для округления до определенного знака используют BigDecimal.

System.out.println(Math.round(2.5)); // 3

3

C#: Метод Math.Round() по умолчанию использует округление банкира, но имеет перегрузку с параметром MidpointRounding для выбора стратегии.

Console.WriteLine(Math.Round(2.5)); // 2
Console.WriteLine(Math.Round(2.5, MidpointRounding.AwayFromZero)); // 3

2
3

SQL: Функция ROUND() обычно работает по принципу half away from zero.

-- В PostgreSQL, MySQL
SELECT ROUND(2.5); -- 3

3

Распространенные ошибки

1. Ожидание десятичной точности для чисел в двоичном представлении. Числа вроде 0.1 или 0.2 не имеют точного двоичного эквивалента, что может привести к неожиданным результатам.

print(round(2.675, 2))  # Ожидается 2.68

2.67

Причина в том, что 2.675 на самом деле хранится как 2.674999999999999822..., что ближе к 2.67.

2. Путаница с округлением банкира (half to even).

print(round(2.5))  # 2
print(round(3.5))  # 4

2
4

Числа 2.5 и 3.5 округляются до ближайших четных чисел (2 и 4 соответственно).

3. Использование round для форматирования вывода без учета возвращаемого типа.

result = round(1.000, 2)
print(result)  # 1.0, а не 1.00

1.0

Функция возвращает число, а не строку. Для форматирования лучше применять f-строки: f'{1.000:.2f}'.

Изменения в последних версиях Python

Основное изменение произошло в переходе с Python 2 на Python 3.

В Python 2 функция round() использовала стратегию округления "half away from zero" (половина от большего). В Python 3 стратегия была изменена на "bankers' rounding" (half to even). Это изменение уменьшает смещение при округлении большого количества средних значений.

Также в Python 3 функция всегда возвращает int, если ndigits не указан, в то время как в Python 2 она возвращала float.

# Поведение в Python 2 (гипотетически):
# round(2.5) -> 3.0 (float)
# Поведение в Python 3:
# round(2.5) -> 2 (int)

Расширенные примеры

Округление с пользовательской логикой, имитирующей разные стратегии:

def round_half_up(n, ndigits=0):
    from math import copysign, floor
    multiplier = 10 ** ndigits
    n_scaled = n * multiplier
    result = floor(n_scaled + 0.5)
    if n < 0:
        result = floor(n_scaled - 0.5)
    return copysign(result, n) / multiplier

print(round_half_up(2.5))      # 3.0
print(round_half_up(-2.5))     # -3.0

3.0
-3.0

Округление элементов коллекций:

data = [3.14159, 2.71828, 1.61803]
rounded_data = [round(x, 2) for x in data]
print(rounded_data)

[3.14, 2.72, 1.62]

Округление с динамическим определением точности:

def round_to_significant(x, digits=2):
    from math import log10, floor
    if x == 0:
        return 0
    scale = 10 ** (digits - floor(log10(abs(x))) - 1)
    return round(x * scale) / scale

print(round_to_significant(123456, 3))  # 123000
print(round_to_significant(0.00123456, 3))  # 0.00123

123000
0.00123

Округление временных интервалов:

seconds = 123.456
rounded_minutes = round(seconds / 60, 1)
print(f'Приблизительно {rounded_minutes} минут')

Приблизительно 2.1 минут

Работа с Decimal для точного округления:

from decimal import Decimal, ROUND_HALF_UP

value = Decimal('2.675')
result = value.quantize(Decimal('0.01'), rounding=ROUND_HALF_UP)
print(result)  # 2.68

2.68