Округлить число до ближайшего целого

Ответ 1

int(round(x))

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

EDIT:

Вы не присваиваете int (round (h)) какой-либо переменной. Когда вы вызываете int (round (h)), он возвращает целое число, но больше ничего не делает; Вы должны изменить эту строку для:

h = int(round(h))

Чтобы присвоить новое значение h

ОБНОВЛЕНИЕ 2:

Как сказал @plowman в комментариях, Python round() не работает так, как обычно ожидают, и потому, что способ хранения числа в виде переменной обычно не тот, который вы видите на экране. Есть много ответов, объясняющих это поведение:

round() в Python, похоже, не округляется должным образом

Один из способов избежать этой проблемы - использовать десятичное число, как указано в этом ответе: fooobar.com/questions/4085/...

Для правильной работы этого ответа без использования дополнительных библиотек было бы удобно использовать пользовательскую функцию округления. После многих исправлений я пришел к следующему решению, которое, насколько я тестировал, позволило избежать всех проблем с хранением. Он основан на использовании строкового представления, полученного с помощью repr() (НЕ str()!). Это выглядит неприлично, но это был единственный способ решить все дела. Он работает как с Python2, так и с Python3.

def proper_round(num, dec=0):
    num = str(num)[:str(num).index('.')+dec+2]
    if num[-1]>='5':
        return float(num[:-2-(not dec)]+str(int(num[-2-(not dec)])+1))
    return float(num[:-1])

Тесты:

>>> print(proper_round(1.0005,3))
1.001
>>> print(proper_round(2.0005,3))
2.001
>>> print(proper_round(3.0005,3))
3.001
>>> print(proper_round(4.0005,3))
4.001
>>> print(proper_round(5.0005,3))
5.001
>>> print(proper_round(1.005,2))
1.01
>>> print(proper_round(2.005,2))
2.01
>>> print(proper_round(3.005,2))
3.01
>>> print(proper_round(4.005,2))
4.01
>>> print(proper_round(5.005,2))
5.01
>>> print(proper_round(1.05,1))
1.1
>>> print(proper_round(2.05,1))
2.1
>>> print(proper_round(3.05,1))
3.1
>>> print(proper_round(4.05,1))
4.1
>>> print(proper_round(5.05,1))
5.1
>>> print(proper_round(1.5))
2.0
>>> print(proper_round(2.5))
3.0
>>> print(proper_round(3.5))
4.0
>>> print(proper_round(4.5))
5.0
>>> print(proper_round(5.5))
6.0
>>> 
>>> print(proper_round(1.000499999999,3))
1.0
>>> print(proper_round(2.000499999999,3))
2.0
>>> print(proper_round(3.000499999999,3))
3.0
>>> print(proper_round(4.000499999999,3))
4.0
>>> print(proper_round(5.000499999999,3))
5.0
>>> print(proper_round(1.00499999999,2))
1.0
>>> print(proper_round(2.00499999999,2))
2.0
>>> print(proper_round(3.00499999999,2))
3.0
>>> print(proper_round(4.00499999999,2))
4.0
>>> print(proper_round(5.00499999999,2))
5.0
>>> print(proper_round(1.0499999999,1))
1.0
>>> print(proper_round(2.0499999999,1))
2.0
>>> print(proper_round(3.0499999999,1))
3.0
>>> print(proper_round(4.0499999999,1))
4.0
>>> print(proper_round(5.0499999999,1))
5.0
>>> print(proper_round(1.499999999))
1.0
>>> print(proper_round(2.499999999))
2.0
>>> print(proper_round(3.499999999))
3.0
>>> print(proper_round(4.499999999))
4.0
>>> print(proper_round(5.499999999))
5.0

Наконец, исправленный ответ будет следующим:

# Having proper_round defined as previously stated
h = int(proper_round(h))

ОБНОВЛЕНИЕ 3:

Тесты:

>>> proper_round(6.39764125, 2)
6.31 # should be 6.4
>>> proper_round(6.9764125, 1)
6.1  # should be 7

Здесь уловка заключается в том, что десятичное число dec -th может быть 9, а если цифра dec+1 -th> = 5, то 9 станет 0, а 1 следует перенести в dec-1 -th цифра.

Если мы примем это во внимание, мы получим:

def proper_round(num, dec=0):
    num = str(num)[:str(num).index('.')+dec+2]
    if num[-1]>='5':
      a = num[:-2-(not dec)]       # integer part
      b = int(num[-2-(not dec)])+1 # decimal part
      return float(a)+b**(-dec+1) if a and b == 10 else float(a+str(b))
    return float(num[:-1])

В ситуации, описанной выше, b = 10 и предыдущая версия просто объединят a и b, что приведет к объединению 10, где завершающий 0 исчезнет. Эта версия преобразует b в правильное десятичное место на основе dec, как правильный перенос.

Ответ 2

Используйте round(x, y). Он округляет ваш номер до нужного десятичного знака.

Например:

>>> round(32.268907563, 3)
32.269

Ответ 3

round(value,significantDigit) - обычное решение, однако оно не работает так, как можно было бы ожидать с математической точки зрения, когда значения округления заканчиваются на 5. Если 5 находится в цифре сразу после того, к 8.005 вы округлили, эти значения только иногда округляются, как и ожидалось (т.е. округление до 8.005 до двух десятичных цифр дает 8.01). Для определенных значений из-за причуд математики с плавающей запятой они округляются вместо этого!

т.е.

>>> round(1.0005,3)
1.0
>>> round(2.0005,3)
2.001
>>> round(3.0005,3)
3.001
>>> round(4.0005,3)
4.0
>>> round(1.005,2)
1.0
>>> round(5.005,2)
5.0
>>> round(6.005,2)
6.0
>>> round(7.005,2)
7.0
>>> round(3.005,2)
3.0
>>> round(8.005,2)
8.01

Weird.

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

>>> round(0.075,2)

0.07

>>> round(0.075+10**(-2*5),2)

0.08

Ага! На основании этого мы можем сделать функцию...

def roundTraditional(val,digits):
   return round(val+10**(-len(str(val))-1), digits)

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

Подход с использованием 10**(-len(val)-1) был преднамеренным, так как это наибольшее небольшое число, которое вы можете добавить для форсирования сдвига, при этом гарантируя, что добавляемое вами значение никогда не изменит округления, даже если десятичное . пропал, отсутствует. Я мог бы использовать только 10**(-len(val)) с условным if (val>1) чтобы вычесть еще 1... но проще всегда всегда вычитать 1 поскольку это не сильно изменит применимый диапазон из десятичных чисел этот обходной путь может правильно обрабатывать. Этот подход потерпит неудачу, если ваши значения достигнут пределов типа, это не удастся, но почти для всего диапазона допустимых десятичных значений это должно работать.

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

Редактировать: Спасибо Blckknght за указание, что 5 крайний случай происходит только для определенных значений. Также более ранняя версия этого ответа не была достаточно явной, так что странное поведение округления происходит только тогда, когда цифра, непосредственно уступающая цифре, к которой вы округляете, имеет 5.

Ответ 4

Для положительных результатов попробуйте

int(x + 0.5)

Чтобы он работал на негативы, попробуйте

int(x + (0.5 if x > 0 else -0.5))

int() работает как функция пола, и поэтому вы можете использовать это свойство. Это, безусловно, самый быстрый способ.

Ответ 5

Разве Python не выполняет полукруглый раунд, как это предписано IEEE 754?

Будьте осторожны, переопределяя или используя "нестандартные" округления...

(См. Также fooobar.com/questions/73830/...)

Ответ 6

Вы также можете использовать numpy, если используете python3.x, вот пример

import numpy as np
x = 2.3
print(np.rint(x))
>>> 2.0

Ответ 7

Ваше решение обзванивает без указания второго аргумента (количество десятичных знаков)

>>> round(0.44)
0
>>> round(0.64)
1

что гораздо лучший результат, чем

>>> int(round(0.44, 2))
0
>>> int(round(0.64, 2))
0

Из документации Python по адресу https://docs.python.org/3/library/functions.html#round

раунд (число [, ndigits])

Возвращаемое число, округленное до точности ndigits после десятичной точки. Если ndigits опущен или равен None, он возвращает ближайшее целое число на свой вход.

Заметка

Поведение round() для чисел с плавающей точкой может быть удивительным: например, round (2.675, 2) дает 2,67 вместо ожидаемых 2,68. Это не ошибка: это результат того факта, что большинство десятичных дробей не могут быть представлены именно как число с плавающей точкой. Посмотрите Арифметику с плавающей запятой: Проблемы и Ограничения для получения дополнительной информации.

Ответ 8

Если вам нужно (например) двузначное приближение для A, то int(A*100+0.5)/100.0 сделает то, что вы ищете.

Если вам нужно трехзначное приближение умножить и разделить на 1000 и т.д.

Ответ 9

Для этого я бы предложил сделать следующее:

int(round(x))

Это даст вам ближайшее целое число.

Надеюсь это поможет!!

Ответ 10

Я использую и могу посоветовать следующее решение (python3.6):

y = int(x + (x % (1 if x >= 0 else -1)))

Он отлично работает для половинных чисел (положительных и отрицательных) и работает даже быстрее, чем int (round (x)):

round_methods = [lambda x: int(round(x)), 
                 lambda x: int(x + (x % (1 if x >= 0 else -1))),
                 lambda x: np.rint(x).astype(int),
                 lambda x: int(proper_round(x))]

for rm in round_methods:
    %timeit rm(112.5)
Out:
201 ns ± 3.96 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
159 ns ± 0.646 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
925 ns ± 7.66 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
1.18 µs ± 8.66 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

for rm in round_methods:
    print(rm(112.4), rm(112.5), rm(112.6))
    print(rm(-12.4), rm(-12.5), rm(-12.6))
    print('=' * 11)

Out:
112 112 113
-12 -12 -13
===========
112 113 113
-12 -13 -13
===========
112 112 113
-12 -12 -13
===========
112 113 113
-12 -13 -13
===========