Как округлять числа в Python

Вступление: Предвзятость округления

Сейчас вы познакомились с тремя методами округления: truncate(), round_up(), и round_down(). Все эти три метода довольно грубы, когда речь идет о сохранении разумной точности для данного числа.

Существует одно важное отличие между  truncate() и round_up() и round_down(), которое подчеркивает важный аспект округления: симметрия вокруг нуля.

Вспомните, что round_up() не симметрична вокруг нуля. В математических терминах функция f(x) симметрична вокруг нуля, если для любого значения x, f(x) + f(-x) = 0. Например, round_up(1.5) возвращает 2, а round_up(-1.5) возвращает -1. Функция round_down() также не симметрична вокруг 0.

С другой стороны, функция truncate() симметрична относительно нуля. Это происходит потому, что после сдвига десятичной точки вправо функция truncate() обрезает оставшиеся цифры. Если исходное значение положительное, это равносильно округлению числа в меньшую сторону. Отрицательные числа округляются в большую сторону. Таким образом, truncate(1.5) возвращает 1, а truncate(-1.5) – -1.

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

Стратегия “округления в большую сторону” имеет смещение в сторону положительной бесконечности, поскольку значение всегда округляется в сторону положительной бесконечности. Аналогично, стратегия “округления в меньшую сторону” имеет смещение в сторону отрицательной бесконечности.

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

Давайте посмотрим, как это работает на практике. Рассмотрим следующий список плавающих чисел:

>>> data = [1.25, -2.67, 0.43, -1.79, 4.32, -8.19]

Let’s compute the mean value of the values in data using the statistics.mean() function:

Вычислим среднее значение значений в data  с помощью функции statistics.mean():

>>> import statistics

>>> statistics.mean(data)
-1.1083333333333332

Теперь примените каждую из функций round_up(), round_down() и truncate()  в списке comprehension для округления каждого числа в данных до одного десятичного знака и вычисления нового среднего значения:

>>> ru_data = [round_up(n, 1) for n in data]
>>> ru_data
[1.3, -2.6, 0.5, -1.7, 4.4, -8.1]
>>> statistics.mean(ru_data)
-1.0333333333333332

>>> rd_data = [round_down(n, 1) for n in data]
>>> statistics.mean(rd_data)
-1.1333333333333333

>>> tr_data = [truncate(n, 1) for n in data]
>>> statistics.mean(tr_data)
-1.0833333333333333

После округления каждого числа в data в большую сторону новое среднее значение составляет примерно -1.033, что больше, чем фактическое среднее значение, равное примерно 1.108. Округление в меньшую сторону сдвигает среднее значение вниз до  -1.133. Среднее значение усеченных значений составляет около -1.08 и наиболее близко к фактическому среднему значению.

Этот пример не означает, что вы всегда должны усекать, когда вам нужно округлить отдельные значения, сохранив при этом среднее значение как можно точнее. Список данных содержит равное количество положительных и отрицательных значений. Функция truncate() будет вести себя так же, как round_up() для списка всех положительных значений, и так же, как round_down() для списка всех отрицательных значений.

Этот пример иллюстрирует влияние смещения округления на значения, вычисленные на основе данных, которые были округлены. Вам необходимо помнить об этих эффектах, делая выводы на основе данных, которые были округлены.

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

Например, если кто-то попросит вас округлить числа 1.23 и 1.28 до одного десятичного знака, вы, вероятно, быстро ответите 1.2 и 1.3. Функции truncate(), round_up() и round_down() не делают ничего подобного.

А как насчет числа 1,25? Вы, вероятно, сразу же подумаете, что нужно округлить его до 1,3, но в действительности 1,25 равноудалено от 1,2 и 1,3. В некотором смысле, 1,2 и 1,3 – это оба ближайших числа к 1,25 с точностью до одного десятичного знака. Число 1,25 называется “равным” по отношению к 1,2 и 1,3. В подобных случаях необходимо назначить тайбрейкер.

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

Округление половины в большую сторону

Стратегия “округление половины в большую сторону” округляет каждое число до ближайшего числа с заданной точностью, и разрывает равенства путем округления в большую сторону. Вот несколько примеров:

Чтобы реализовать стратегию “округления половины в большую сторону” в Python, вы начинаете, как обычно, со сдвига десятичной точки вправо на нужное количество мест. Однако на этом этапе вам нужен способ определить, является ли цифра сразу после сдвинутой десятичной точки меньше или больше или равна 5.

Один из способов сделать это – добавить 0,5 к сдвинутому значению, а затем округлить в меньшую сторону с помощью math.floor(). Это работает, потому что:

• Если цифра в первом десятичном знаке сдвинутого значения меньше пяти, то добавление 0,5 не изменит целочисленную часть сдвинутого значения, поэтому нижняя часть равна целочисленной части.
• Если первая цифра после десятичного знака больше или равна 5, то добавление 0,5 увеличит целую часть сдвинутого значения на 1, так что полученное значение будет равно этому большему целому числу.

Вот как это выглядит в Python:

def round_half_up(n, decimals=0):
    multiplier = 10 ** decimals
    return math.floor(n*multiplier + 0.5) / multiplier

Обратите внимание, что round_half_up() очень похожа на round_down(). Это может быть несколько неинтуитивно, но внутри round_half_up() округляет только в меньшую сторону. Хитрость заключается в добавлении 0,5 после сдвига десятичной точки, чтобы результат округления в меньшую сторону соответствовал ожидаемому значению.

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

>>> round_half_up(1.23, 1)
1.2

>>> round_half_up(1.28, 1)
1.3

>>> round_half_up(1.25, 1)
1.3

Отлично! Теперь вы наконец-то можете получить тот результат, в котором вам отказала встроенная функция round():

>>> round_half_up(2.5)
3.0

Однако прежде чем вы обрадуетесь, давайте посмотрим, что произойдет, если вы попытаетесь округлить -1,225 до 2 знаков после запятой:

>>> round_half_up(-1.225, 2)
-1.23

Подождите. Мы только что обсуждали, как округляются значения в большую из двух возможных величин. -1.225 находится посередине между -1.22 и -1.23. Поскольку -1.22 больше из этих двух, round_half_up(-1.225, 2) должен вернуть -1.22. Но вместо этого мы получили -1,23.

Возможно, в функции round_half_up() есть ошибка?

Когда round_half_up() округляет -1,225 до двух знаков после запятой, первое, что она делает, это умножает -1,225 на 100. Давайте убедимся, что это работает так, как ожидается:

>>> -1.225 * 100
-122.50000000000001

Ну… это неправильно! Но это объясняет, почему round_half_up(-1.225, 2) возвращает -1.23. Давайте продолжим алгоритм round_half_up() шаг за шагом, используя _ в REPL, чтобы вспомнить последнее значение, выведенное на каждом шаге:

>>> _ + 0.5
-122.00000000000001

>>> math.floor(_)
-123

>>> _ / 100
-1.23

Даже если -122.00000000000001 действительно близко к -122, ближайшее целое число, которое меньше или равно ему, -123. Когда десятичная точка сдвигается назад влево, окончательное значение равно -1,23.

Ну, теперь вы знаете, как round_half_up(-1.225, 2) возвращает -1.23, хотя логической ошибки нет, но почему Python говорит, что -1.225 * 100 – это -122.50000000000001? Есть ли в Python ошибка?

Тот факт, что Python говорит, что -1.225 * 100 это -122.50000000000001, является следствием ошибки представления с плавающей точкой. Вы можете спросить себя: “Хорошо, но есть ли способ исправить это?”. Лучше задать себе вопрос: “Нужно ли мне это исправлять?”.

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

Если вы решили, что стандартного класса float в Python достаточно для вашего приложения, некоторые случайные ошибки в round_half_up() из-за ошибки представления с плавающей точкой не должны вызывать беспокойства.

Теперь, когда вы получили представление о том, как машины округляют числа в памяти, давайте продолжим обсуждение стратегий округления, рассмотрев еще один способ определения ничьей.

Округление половины в меньшую сторону

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

Вы можете реализовать стратегию “округления наполовину в меньшую сторону” в Python, заменив math.floor() в функции round_half_up() на math.ceil() и вычитая 0,5 вместо сложения:

def round_half_down(n, decimals=0):
    multiplier = 10 ** decimals
    return math.ceil(n*multiplier - 0.5) / multiplier

Давайте проверим round_half_down() на нескольких тестовых примерах:

>>> round_half_down(1.5)
1.0

>>> round_half_down(-1.5)
-2.0

>>> round_half_down(2.25, 1)
2.2

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

>>> data = [-2.15, 1.45, 4.35, -12.75]

Вычислим среднее значение этих чисел:

>>> statistics.mean(data)
-2.275

Затем вычислите среднее значение данных после округления до одного десятичного знака с помощью функций round_half_up() и round_half_down():

>>> rhu_data = [round_half_up(n, 1) for n in data]
>>> statistics.mean(rhu_data)
-2.2249999999999996

>>> rhd_data = [round_half_down(n, 1) for n in data]
>>> statistics.mean(rhd_data)
-2.325

Каждое число в данных является ничьей при округлении до одного десятичного знака. Функция round_half_up() вносит смещение в сторону положительной бесконечности, а round_half_down() вносит смещение в сторону отрицательной бесконечности.

Все остальные стратегии округления, которые мы обсудим, пытаются смягчить эти смещения различными способами.

Округление в половину от нуля

Если вы внимательно изучите функции round_half_up() и round_half_down(), то заметите, что ни одна из них не является симметричной относительно нуля:

>>> round_half_up(1.5)
2.0

>>> round_half_up(-1.5)
-1.0

>>> round_half_down(1.5)
1.0

>>> round_half_down(-1.5)
-2.0

Один из способов ввести симметрию – всегда округлять от нуля. В следующей таблице показано, как это работает:

Чтобы применить стратегию “округления половины от нуля” к числу n, начните, как обычно, со сдвига десятичной точки вправо на заданное количество мест. Затем вы смотрите на цифру d, расположенную непосредственно справа от десятичного знака в этом новом числе. На этом этапе можно рассмотреть четыре случая:

1. Если n положительно и d >= 5, округлите в большую сторону
2. Если n положительно и d < 5, округлите в меньшую сторону
3. Если n отрицательно и d >= 5, округлите в меньшую сторону
4. Если n отрицательно и d < 5, округлите в большую сторону

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

Учитывая число n и значение десятичных дробей, вы можете реализовать это в Python с помощью функций round_half_up() и round_half_down():

if n >= 0:
    rounded = round_half_up(n, decimals)
else:
    rounded = round_half_down(n, decimals)

Это достаточно просто, но на самом деле есть более простой способ!

Если вы сначала возьмете абсолютное значение n с помощью встроенной в Python функции abs(), вы можете просто использовать round_half_up() для округления числа. Затем нужно только придать округленному числу тот же знак, что и n. Один из способов сделать это – использовать функцию math.copysign().

math.copysign() берет два числа a и b и возвращает a со знаком b:

>>> math.copysign(1, -2)
-1.0

Обратите внимание, что функция math.copysign() возвращает число float, хотя оба ее аргумента были целыми числами.

Используя abs(), round_half_up() и math.copysign(), вы можете реализовать стратегию “округления половины от нуля” всего в двух строках Python:

def round_half_away_from_zero(n, decimals=0):
    rounded_abs = round_half_up(abs(n), decimals)
    return math.copysign(rounded_abs, n)

В функции round_half_away_from_zero() абсолютное значение n округляется до десятичных знаков после запятой с помощью функции round_half_up(), и этот результат присваивается переменной rounded_abs. Затем исходный знак n применяется к rounded_abs с помощью math.copysign(), и это конечное значение с правильным знаком возвращается функцией.

Проверка функции round_half_away_from_zero() на нескольких различных значениях показывает, что функция ведет себя так, как ожидалось:

>>> round_half_away_from_zero(1.5)
2.0

>>> round_half_away_from_zero(-1.5)
-2.0

>>> round_half_away_from_zero(-12.75, 1)
-12.8

Функция round_half_away_from_zero() округляет числа так, как большинство людей округляют числа в повседневной жизни. Помимо того, что функция round_half_away_from_zero() является самой знакомой функцией округления, которую вы видели до сих пор, она также хорошо устраняет смещение округления в наборах данных с равным количеством положительных и отрицательных связей.

Давайте проверим, насколько хорошо round_half_away_from_zero() устраняет смещение округления на примере из предыдущего раздела:

>>> data = [-2.15, 1.45, 4.35, -12.75] 
>>> statistics.mean(data)
-2.275

>>> rhaz_data = [round_half_away_from_zero(n, 1) for n in data]
>>> statistics.mean(rhaz_data)
-2.2750000000000004

Среднее значение чисел в данных сохраняется почти точно при округлении каждого числа в данных до одного десятичного знака с помощью функции round_half_away_from_zero()!

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

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

Округление половины до целого

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

Стратегия “округления половины до четного” – это стратегия, используемая встроенной в Python функцией round() и являющаяся правилом округления по умолчанию в стандарте IEEE-754. Эта стратегия работает в предположении, что вероятности того, что ничья в наборе данных будет округлена вниз или вверх, равны. На практике это обычно так и есть.

Теперь вы знаете, почему round(2.5) возвращает 2. Это не ошибка. Это осознанное проектное решение, основанное на надежных рекомендациях.

Чтобы убедиться в том, что round() действительно округляет до четного значения, попробуйте использовать ее для нескольких разных значений:

>>> round(4.5)
4

>>> round(3.5)
4

>>> round(1.75, 1)
1.8

>>> round(1.65, 1)
1.6

Функция round() почти свободна от смещения, но она не идеальна. Например, погрешность округления может возникнуть, если большинство связей в вашем наборе данных округляются до четного значения вместо того, чтобы округляться в меньшую сторону. Стратегии, смягчающие погрешность даже лучше, чем “округление половины до четного”, существуют, но они несколько неясны и нужны только в экстремальных обстоятельствах.

Наконец, round() страдает от тех же проблем, которые вы видели в round_half_up(), из-за ошибки представления с плавающей точкой:

>>> # Expected value: 2.68
>>> round(2.675, 2)
2.67

Вас не должны беспокоить эти случайные ошибки, если точность с плавающей запятой достаточна для вашего приложения.

Если точность имеет первостепенное значение, следует использовать класс Decimal в Python.

The Decimal Class

Десятичный модуль Python – это одна из тех возможностей языка, о которых вы можете не знать, если вы новичок в Python. Руководство по работе с десятичным модулем можно найти в документации:

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

Преимущества десятичного модуля включают:

• Точное десятичное представление: 0.1 на самом деле 0.1, а 0.1 + 0.1 + 0.1 – 0.3 возвращает 0, как и следовало ожидать.
• Сохранение значащих цифр: При сложении 1,20 и 2,50 в результате получается 3,70 с сохранением нуля в конце для обозначения значимости.
• Изменяемая пользователем точность: По умолчанию точность десятичного модуля составляет двадцать восемь цифр, но пользователь может изменять это значение в зависимости от конкретной задачи.

Давайте изучим, как работает округление в модуле decimal. Начните с ввода следующего текста в Python REPL:

>>> import decimal
>>> decimal.getcontext()
Context(
    prec=28,
    rounding=ROUND_HALF_EVEN,
    Emin=-999999,
    Emax=999999,
    capitals=1,
    clamp=0,
    flags=[],
    traps=[
        InvalidOperation,
        DivisionByZero,
        Overflow
    ]
)

decimal.getcontext() возвращает объект Context, представляющий контекст по умолчанию модуля decimal. Контекст включает точность по умолчанию и стратегию округления по умолчанию, среди прочего.

Как видно из примера выше, стратегия округления по умолчанию для десятичного модуля – ROUND_HALF_EVEN. Это соответствует встроенной функции round() и должно быть предпочтительной стратегией округления для большинства целей.

Давайте объявим число с помощью класса Decimal модуля Decimal. Для этого создайте новый экземпляр Decimal, передав ему строку с желаемым значением:

>>> from decimal import Decimal
>>> Decimal("0.1")
Decimal('0.1')

Просто для развлечения, давайте проверим утверждение, что Decimal поддерживает точное десятичное представление:

>>> Decimal('0.1') + Decimal('0.1') + Decimal('0.1')
Decimal('0.3')

А-а-а. Приятно, не правда ли?

Округление десятичной дроби выполняется с помощью метода .quantize():

>>> Decimal("1.65").quantize(Decimal("1.0"))
Decimal('1.6')

Хорошо, это, вероятно, выглядит немного странно, поэтому давайте разберем это. Аргумент Decimal(“1.0”) в .quantize() определяет количество десятичных знаков для округления числа. Поскольку 1.0 имеет один десятичный знак, число 1.65 округляется до одного десятичного знака. Стратегия округления по умолчанию – “округление половины до четного”, поэтому результат равен 1,6.

Вспомните, что функция round(), которая также использует стратегию “округления половины до четного”, не смогла правильно округлить 2,675 до двух знаков после запятой. Вместо 2,68, round(2.675, 2) возвращает 2,67. Благодаря модулям точного десятичного представления у вас не возникнет такой проблемы с классом Decimal:

>>> Decimal("2.675").quantize(Decimal("1.00"))
Decimal('2.68')

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

>>> decimal.getcontext().prec = 2
>>> Decimal("1.23") + Decimal("2.32")
Decimal('3.6')

Чтобы изменить точность, нужно вызвать функцию decimal.getcontext() и установить атрибут .prec. Если установка атрибута при вызове функции кажется вам странной, вы можете сделать это, потому что .getcontext() возвращает специальный объект Context, который представляет текущий внутренний контекст, содержащий параметры по умолчанию, используемые модулем decimal.

Точное значение 1,23 плюс 2,32 равно 3,55. Поскольку точность теперь двухзначная, а стратегия округления установлена по умолчанию “округление половины до четного”, значение 3,55 автоматически округляется до 3,6.

Чтобы изменить стратегию округления по умолчанию, вы можете установить свойство decimal.getcontect().rounding в любой из нескольких флагов. В следующей таблице приведены эти флаги и стратегии округления, которые они реализуют:

Первое, что следует заметить, это то, что схема именования, используемая модулем decimal, отличается от той, о которой мы договорились ранее в статье. Например, decimal.ROUND_UP реализует стратегию “округления от нуля”, которая на самом деле округляет отрицательные числа в меньшую сторону.

Во-вторых, некоторые стратегии округления, упомянутые в таблице, могут показаться незнакомыми, поскольку мы их не обсуждали. Вы уже видели, как работает decimal.ROUND_HALF_EVEN, поэтому давайте рассмотрим каждую из них в действии.

Стратегия decimal.ROUND_CEILING работает так же, как функция round_up(), которую мы определили ранее:

>>> decimal.getcontext().rounding = decimal.ROUND_CEILING

>>> Decimal("1.32").quantize(Decimal("1.0"))
Decimal('1.4')

>>> Decimal("-1.32").quantize(Decimal("1.0"))
Decimal('-1.3')

Обратите внимание, что результаты decimal.ROUND_CEILING не симметричны вокруг нуля.

Стратегия decimal.ROUND_FLOOR работает так же, как и наша функция round_down():

>>> decimal.getcontext().rounding = decimal.ROUND_FLOOR

>>> Decimal("1.32").quantize(Decimal("1.0"))
Decimal('1.3')

>>> Decimal("-1.32").quantize(Decimal("1.0"))
Decimal('-1.4')

Как и decimal.ROUND_CEILING, стратегия decimal.ROUND_FLOOR не является симметричной относительно нуля.

Стратегии decimal.ROUND_DOWN и decimal.ROUND_UP имеют несколько обманчивые названия. И ROUND_DOWN, и ROUND_UP симметричны вокруг нуля:

>>> decimal.getcontext().rounding = decimal.ROUND_DOWN

>>> Decimal("1.32").quantize(Decimal("1.0"))
Decimal('1.3')

>>> Decimal("-1.32").quantize(Decimal("1.0"))
Decimal('-1.3')

>>> decimal.getcontext().rounding = decimal.ROUND_UP

>>> Decimal("1.32").quantize(Decimal("1.0"))
Decimal('1.4')

>>> Decimal("-1.32").quantize(Decimal("1.0"))
Decimal('-1.4')

Стратегия decimal.ROUND_DOWN округляет числа в сторону нуля, как и функция truncate(). С другой стороны, decimal.ROUND_UP округляет все в сторону от нуля. Это явный отход от терминологии, о которой мы договорились ранее в этой статье, поэтому имейте это в виду, когда будете работать с модулем decimal.

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

>>> decimal.getcontext().rounding = decimal.ROUND_HALF_UP

>>> Decimal("1.35").quantize(Decimal("1.0"))
Decimal('1.4')

>>> Decimal("-1.35").quantize(Decimal("1.0"))
Decimal('-1.4')

Обратите внимание, что decimal.ROUND_HALF_UP работает так же, как наша round_half_away_from_zero(), а не как round_half_up().

Существует также стратегия decimal.ROUND_HALF_DOWN, которая разрушает равенство путем округления в сторону нуля:

>>> decimal.getcontext().rounding = decimal.ROUND_HALF_DOWN

>>> Decimal("1.35").quantize(Decimal("1.0"))
Decimal('1.3')

>>> Decimal("-1.35").quantize(Decimal("1.0"))
Decimal('-1.3')

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

>>> decimal.getcontext().rounding = decimal.ROUND_05UP

>>> Decimal("1.38").quantize(Decimal("1.0"))
Decimal('1.3')

>>> Decimal("1.35").quantize(Decimal("1.0"))
Decimal('1.3')

>>> Decimal("-1.35").quantize(Decimal("1.0"))
Decimal('-1.3')

В приведенных выше примерах кажется, что decimal.ROUND_05UP округляет все в сторону нуля. На самом деле, именно так и работает decimal.ROUND_05UP, если только результат округления не заканчивается на 0 или 5. В этом случае число округляется в сторону от нуля:

>>> Decimal("1.49").quantize(Decimal("1.0"))
Decimal('1.4')

>>> Decimal("1.51").quantize(Decimal("1.0"))
Decimal('1.6')

В первом примере число 1,49 сначала округляется до нуля во втором десятичном разряде, в результате чего получается 1,4. Поскольку 1,4 не оканчивается ни на 0, ни на 5, его оставляют как есть. С другой стороны, 1,51 округляется до нуля во втором десятичном разряде, в результате чего получается число 1,5. Оно оканчивается на 5, поэтому первый десятичный знак округляется от нуля до 1,6.

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

Более подробную информацию о Decimal можно найти в кратком учебнике в документации Python.

Далее давайте обратим внимание на два основных компонента Python в стеках научных вычислений и науки о данных: NumPy и Pandas.

Округление массивов NumPy

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

Давайте сгенерируем некоторые данные, создав массив NumPy 3×4 из псевдослучайных чисел:

>>> import numpy as np
>>> np.random.seed(444)

>>> data = np.random.randn(3, 4)
>>> data
array([[ 0.35743992,  0.3775384 ,  1.38233789,  1.17554883],
       [-0.9392757 , -1.14315015, -0.54243951, -0.54870808],
       [ 0.20851975,  0.21268956,  1.26802054, -0.80730293]])

Сначала мы создаем модуль np.random, чтобы вы могли легко воспроизвести результат. Затем с помощью np.random.randn() создается массив NumPy 3×4 чисел с плавающей точкой.

Чтобы округлить все значения в массиве данных, можно передать данные в качестве аргумента функции np.around(). Желаемое количество знаков после запятой задается с помощью аргумента decimals ключевого слова. Используется стратегия округления от половины до четного, как и встроенная в Python функция round().

Например, в следующем примере все значения в данных округляются до трех знаков после запятой:

>>> np.around(data, decimals=3)
array([[ 0.357,  0.378,  1.382,  1.176],
       [-0.939, -1.143, -0.542, -0.549],
       [ 0.209,  0.213,  1.268, -0.807]])

np.around() находится во власти ошибки представления с плавающей точкой, так же как и round().

Например, значение в третьей строке первого столбца массива данных равно 0,20851975. Когда вы округляете его до трех знаков после запятой, используя стратегию “округления половины до четного”, вы ожидаете, что значение будет равно 0,208. Но в выводе np.around() видно, что значение округляется до 0,209. Однако значение 0,3775384 в первой строке второго столбца правильно округляется до 0,378.

Если вам нужно округлить данные в массиве до целых чисел, NumPy предлагает несколько вариантов:

• numpy.ceil()
• numpy.floor()
• numpy.trunc()
• numpy.rint()

Функция np.ceil() округляет каждое значение в массиве до ближайшего целого числа, большего или равного исходному значению:

>>> np.ceil(data)
array([[ 1.,  1.,  2.,  2.],
       [-0., -1., -0., -0.],
       [ 1.,  1.,  2., -0.]])

Эй, мы открыли новое число! Отрицательный ноль!

На самом деле, стандарт IEEE-754 требует реализации как положительного, так и отрицательного нуля. Как можно использовать нечто подобное? Википедия знает ответ:

Неформально можно использовать обозначение “-0” для отрицательного значения, которое было округлено до нуля. Это обозначение может быть полезно, когда отрицательный знак имеет значение; например, при табулировании температур по Цельсию, где отрицательный знак означает ниже нуля. (Источник)

Чтобы округлить каждое значение до ближайшего целого числа, используйте np.floor():

>>> np.floor(data)
array([[ 0.,  0.,  1.,  1.],
       [-1., -2., -1., -1.],
       [ 0.,  0.,  1., -1.]])

Вы также можете усечь каждое значение до его целочисленной составляющей с помощью np.trunc():

>>> np.trunc(data)
array([[ 0.,  0.,  1.,  1.],
       [-0., -1., -0., -0.],
       [ 0.,  0.,  1., -0.]])

Наконец, чтобы округлить до ближайшего целого числа, используя стратегию “округления половины до четного”, используйте np.rint():

>>> np.rint(data)
array([[ 0.,  0.,  1.,  1.],
       [-1., -1., -1., -1.],
       [ 0.,  0.,  1., -1.]])

Вы могли заметить, что многие стратегии округления, которые мы обсуждали ранее, здесь отсутствуют. Для подавляющего большинства ситуаций функция around() – это все, что вам нужно. Если вам нужно реализовать другую стратегию, например, round_half_up(), вы можете сделать это с помощью простой модификации:

def round_half_up(n, decimals=0):
    multiplier = 10 ** decimals
    # Replace math.floor with np.floor
    return np.floor(n*multiplier + 0.5) / multiplier

Благодаря векторным операциям NumPy это работает именно так, как вы ожидаете:

>>> round_half_up(data, decimals=2)
array([[ 0.36,  0.38,  1.38,  1.18],
       [-0.94, -1.14, -0.54, -0.55],
       [ 0.21,  0.21,  1.27, -0.81]])

Теперь, когда вы стали мастером округления в NumPy, давайте посмотрим на другой тяжеловес Python для науки о данных – библиотеку Pandas.

Округление в Pandas и DataFrame

Библиотека Pandas стала основным инструментом для специалистов по обработке данных и аналитиков данных, работающих на Python. По словам Джо Уиндхэма из Real Python:

Pandas – это геймчейнджер для науки о данных и аналитики, особенно если вы пришли к Python, потому что искали что-то более мощное, чем Excel и VBA.

Две основные структуры данных Pandas – это DataFrame, который в очень свободном смысле похож на таблицу Excel, и Series, который можно представить как столбец в электронной таблице. Объекты Series и DataFrame можно также эффективно округлять с помощью методов Series.round() и DataFrame.round():

>>> import pandas as pd

>>> # Re-seed np.random if you closed your REPL since the last example
>>> np.random.seed(444)

>>> series = pd.Series(np.random.randn(4))
>>> series
0    0.357440
1    0.377538
2    1.382338
3    1.175549
dtype: float64

>>> series.round(2)
0    0.36
1    0.38
2    1.38
3    1.18
dtype: float64

>>> df = pd.DataFrame(np.random.randn(3, 3), columns=["A", "B", "C"])
>>> df
          A         B         C
0 -0.939276 -1.143150 -0.542440
1 -0.548708  0.208520  0.212690
2  1.268021 -0.807303 -3.303072

>>> df.round(3)
       A      B      C
0 -0.939 -1.143 -0.542
1 -0.549  0.209  0.213
2  1.268 -0.807 -3.303

Метод DataFrame.round() может также принимать словарь или серию, чтобы указать различную точность для каждого столбца. Например, в следующих примерах показано, как округлить первый столбец df до одного десятичного знака, второй – до двух, а третий – до трех десятичных знаков:

>>> # Specify column-by-column precision with a dictionary
>>> df.round({"A": 1, "B": 2, "C": 3})
     A     B      C
0 -0.9 -1.14 -0.542
1 -0.5  0.21  0.213
2  1.3 -0.81 -3.303

>>> # Specify column-by-column precision with a Series
>>> decimals = pd.Series([1, 2, 3], index=["A", "B", "C"])
>>> df.round(decimals)
     A     B      C
0 -0.9 -1.14 -0.542
1 -0.5  0.21  0.213
2  1.3 -0.81 -3.303

Если вам нужна большая гибкость в округлении, вы можете применить функции NumPy floor(), ceil() и rint() к объектам Pandas Series и DataFrame:

>>> np.floor(df)
     A    B    C
0 -1.0 -2.0 -1.0
1 -1.0  0.0  0.0
2  1.0 -1.0 -4.0

>>> np.ceil(df)
     A    B    C
0 -0.0 -1.0 -0.0
1 -0.0  1.0  1.0
2  2.0 -0.0 -3.0

>>> np.rint(df)
     A    B    C
0 -1.0 -1.0 -1.0
1 -1.0  0.0  0.0
2  1.0 -1.0 -3.0

Здесь также будет работать модифицированная функция round_half_up() из предыдущего раздела:

>>> round_half_up(df, decimals=2)
      A     B     C
0 -0.94 -1.14 -0.54
1 -0.55  0.21  0.21
2  1.27 -0.81 -3.30

Поздравляем, вы на пути к мастерству округления! Теперь вы знаете, что существует большое количество способов округлить число. (Вы можете реализовать множество стратегий округления в чистом Python, и вы отточили свои навыки округления массивов NumPy и объектов Pandas Series и DataFrame.

Остался еще один шаг: знать, когда применить нужную стратегию.

Применение и лучшие практики

Последний этап на пути к виртуозности округления – это понимание того, когда следует применять полученные знания. В этом разделе вы узнаете о некоторых лучших практиках, которые помогут вам правильно округлять числа.

Хранить больше и округлять позже

Когда вы работаете с большими наборами данных, хранение может стать проблемой. В большинстве реляционных баз данных каждый столбец таблицы предназначен для хранения определенного типа данных, а числовым типам данных часто присваивается точность для экономии памяти.

Например, датчик температуры может сообщать температуру в промышленной печи, работающей в течение длительного времени, каждые десять секунд с точностью до восьми знаков после запятой. Показания датчика используются для обнаружения аномальных колебаний температуры, которые могут указывать на выход из строя нагревательного элемента или какого-либо другого компонента. Таким образом, может быть запущен сценарий Python, который сравнивает каждое входящее показание с предыдущим, чтобы проверить, нет ли больших колебаний.

Показания этого датчика также сохраняются в базе данных SQL, чтобы каждый день в полночь можно было вычислить среднесуточную температуру внутри духовки. Производитель нагревательного элемента внутри духовки рекомендует заменять этот элемент каждый раз, когда среднесуточная температура опускается на 0,05 градуса ниже нормы.

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

Если у вас есть свободное место, вы должны хранить данные с полной точностью. Если хранение данных является проблемой, хорошим эмпирическим правилом является хранение по крайней мере на два или три десятичных знака точности больше, чем требуется для расчета.

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

Соблюдайте местные валютные правила

Когда вы заказываете в кофейне чашку кофе за 2,40 доллара, продавец обычно добавляет обязательный налог. Размер этого налога во многом зависит от того, где вы находитесь географически, но для примера предположим, что он составляет 6%. Налог, который необходимо добавить, составляет $0,144. Следует ли округлять эту сумму в большую сторону до $0,15 или в меньшую до $0,14? Ответ, вероятно, зависит от правил, установленных местными властями!

Подобные ситуации могут возникать и при конвертации одной валюты в другую. В 1999 году Европейская комиссия по экономическим и финансовым вопросам кодифицировала использование стратегии “округления половины от нуля” при конвертации валют в евро, однако в других валютах могут быть приняты иные правила.

Другой сценарий, “шведское округление“, возникает, когда минимальная единица валюты на уровне бухгалтерского учета в стране меньше, чем самая низкая единица физической валюты. Например, если чашка кофе стоит 2,54 доллара после уплаты налогов, но в обращении нет монет достоинством 1 цент, что делать? У покупателя не будет точной суммы, а торговец не сможет сделать точную сдачу.

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

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

Если есть сомнения, округляйте до четного значения

Когда вы округляете числа в больших наборах данных, которые используются в сложных вычислениях, главной задачей является ограничение роста ошибки из-за округления.

Из всех методов, которые мы обсуждали в этой статье, стратегия “округление половины до четного” лучше всего минимизирует погрешность округления. К счастью, Python, NumPy и Pandas по умолчанию используют эту стратегию, поэтому, используя встроенные функции округления, вы уже хорошо защищены!

Итоги

Какое это было путешествие!

В этой статье вы узнали, что:

• Существуют различные стратегии округления, которые вы теперь знаете, как реализовать на чистом Python.
• Каждая стратегия округления по своей природе вносит погрешность в округление, и стратегия “округление половины до четного” хорошо смягчает эту погрешность в большинстве случаев.
• Способ, которым компьютеры хранят в памяти числа с плавающей точкой, естественно, вносит тонкую ошибку округления, но вы узнали, как ее обойти с помощью модуля decimal в стандартной библиотеке Python.
• Вы можете округлять массивы NumPy и объекты Pandas Series и DataFrame.
• Существуют лучшие практики округления при работе с реальными данными.