四舍五入到最近的 integer

Question

我一直在尝试四舍五入长浮点数，例如：

 32.268907563; 32.268907563; 31.2396694215; 33.6206896552;...

到目前为止没有成功。 我尝试math.ceil(x) ， math.floor(x) （尽管这会向上或向下舍入，这不是我想要的）和round(x)也不起作用（仍然是浮点数） .

我能做什么？

代码：

 for i in widthRange: for j in heightRange: r, g, b = rgb_im.getpixel((i, j)) h, s, v = colorsys.rgb_to_hsv(r/255.0, g/255.0, b/255.0) h = h * 360 int(round(h)) print(h)

Answer 1

TL;博士：

 round(x)

将其四舍五入并将其更改为 integer。

您没有将round(h)分配给任何变量。 当您调用round(h)时，它返回 integer 编号，但不执行任何其他操作； 您必须将该行更改为：

 h = round(h)

将新值分配给h 。

---

正如@plowman 在评论中所说，Python 的round()不能正常工作，这是因为数字作为变量存储的方式通常与您在屏幕上看到的方式不同。 有很多答案可以解释这种行为。

避免此问题的一种方法是使用此答案所述的小数。

为了让这个答案在不使用额外库的情况下正常工作，使用自定义舍入 function 会很方便。 我想出了以下解决方案，据我测试，它避免了所有存储问题。 它基于使用 string 表示，通过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))

---

测试：

 >>> 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 将消失。 此版本根据dec将b转换为正确的小数位，作为正确的进位。

Answer 2

使用round(x, y) 。 它会将您的数字四舍五入到您想要的小数位。

例如：

 >>> round(32.268907563, 3) 32.269

Answer 3

round(value,significantDigit) is the ordinary solution, however this does not operate as one would expect from a math perspective when round values ending in 5. If the 5 is in the digit just after the one you're rounded to, these values are only sometimes rounded up as expected (i.e. 8.005 rounding to two decimal digits gives 8.01). For certain values due to the quirks of floating point math, they are rounded down instead!

i.e.

>>> 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.

Assuming your intent is to do the traditional rounding for statistics in the sciences, this is a handy wrapper to get the round function working as expected needing to import extra stuff like Decimal.

>>> round(0.075,2)

0.07

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

0.08

Aha! So based on this we can make a function...

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

Basically this adds a value guaranteed to be smaller than the least given digit of the string you're trying to use round on. By adding that small quantity it preserve's round's behavior in most cases, while now ensuring if the digit inferior to the one being rounded to is 5 it rounds up, and if it is 4 it rounds down.

The approach of using 10**(-len(val)-1) was deliberate, as it the largest small number you can add to force the shift, while also ensuring that the value you add never changes the rounding even if the decimal . is missing. I could use just 10**(-len(val)) with a condiditional if (val>1) to subtract 1 more... but it's simpler to just always subtract the 1 as that won't change much the applicable range of decimal numbers this workaround can properly handle. This approach will fail if your values reaches the limits of the type, this will fail, but for nearly the entire range of valid decimal values it should work.

You can also use the decimal library to accomplish this, but the wrapper I propose is simpler and may be preferred in some cases.

---

Edit: Thanks Blckknght for pointing out that the 5 fringe case occurs only for certain values. Also an earlier version of this answer wasn't explicit enough that the odd rounding behavior occurs only when the digit immediately inferior to the digit you're rounding to has a 5.

Answer 4

对于积极的，尝试

int(x + 0.5)

为了使它也适用于底片，请尝试

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

int()像地板 function 一样工作，因此您可以利用此属性。 这绝对是最快的方法。

Answer 5

不只是 Python 按照IEEE 754的规定做半对偶吗？

小心重新定义，或使用“非标准”舍入……

（另见https://stackoverflow.com/a/33019948/109839 ）

Answer 6

您的解决方案是在不指定第二个参数（小数位数）的情况下调用 round

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

这是一个比

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

来自https://docs.python.org/3/library/functions.html#round的 Python 文档

回合（数字[，ndigits]）

返回小数点后四舍五入到 ndigits 精度的数字。 如果 ndigits 被省略或为 None，它会将最近的 integer 返回到其输入。

笔记

浮点数的 round() 行为可能令人惊讶：例如，round(2.675, 2) 给出 2.67 而不是预期的 2.68。 这不是错误：这是因为大多数小数部分不能完全表示为浮点数。 有关详细信息，请参阅浮点算术：问题和限制。

Answer 7

您也可以使用 numpy 假设您使用的是 python3.x 这是一个示例

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

Answer 8

如果您需要（例如）A 的两位数近似值，则int(A*100+0.5)/100.0将满足您的需求。

如果您需要三位数的近似值，则乘以 1000，依此类推。

Answer 9

像这样的东西也应该起作用

import numpy as np def proper_round(a): ''' given any real number 'a' returns an integer closest to 'a' ''' a_ceil = np.ceil(a) a_floor = np.floor(a) if np.abs(a_ceil - a) < np.abs(a_floor - a): return int(a_ceil) else: return int(a_floor)

Answer 10

将 x500... 舍入到“x”位中的偶数的基本原理是正确的方法，与值的二进制表示无关。 这是使用的“正确”算法。 高级科学课程和统计课程教授这一点。 但为什么会这样呢？

最小化累积错误

当您对一个值进行四舍五入时，您会在该术语上引入一个错误值。 如果您将大量值加在一起，并且总是将 x500... 值向上舍入 [即 x+1]，那么您将对错误累积产生固有偏差。

在一组 N 个数字上，其中 M 个数字的形式为 x500...，向上舍入方法将引入一个 +ve 误差项，其大小为 M * 0.5 您要四舍五入的数字。

但是，如果您总是四舍五入，那么您会期望这些 M 错误项中有一半是 +ve，一半是 -ve。 因此，您预计他们将取消这些 M 项的净零误差。 0 的误差不是比 M * 0.5 的误差好很多吗？

但是，那个净 0 错误只是一个期望。 当你考虑掷一枚“公平”硬币（一个类似的问题）使得“正面”= +1 和“反面” = -1，M 次，并将所有翻转的总和相加，有一个 0 的统计期望结果，但是从 0（可能是 +ve 或 -ve）开始的“漂移”幅度通常受 sqrt(M) 的约束——或者它是 log(M)？ 很久没有打开一本统计书了。 实际答案（sqrt 或 log）与这个问题无关，因为对于所有 M>1]，sqrt(M) 和 log(M) 都小于 M。

因此，由于它与我们的数字求和方案有关，M 值的形式为 x500...，由于 M 是有限的，我们期望这些 M 值的误差项为零，但我们也有一个偶数更强烈的期望是误差项的大小应该受您四舍五入的数字的 sqrt(M) * 0.5 的约束。

0 很棒，但预期的 sqrt(M) * 0.5 仍然比保证的 M * 0.5 好很多。

是的，您可能会遇到一个病态的情况，最终得到 M * 0.5，但这种情况应该是异常值而不是常态——而且这种罕见的异常值并不比“始终向上”方法更糟糕。

Answer 11

我使用并可能会建议以下解决方案（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 ===========

Answer 12

老实说，这很棘手。 尽管如此，仍有许多简单的方法可以做到这一点。 使用math.ceil() 、 round()和math.floor() ，您可以获得integer ，例如：

 n = int(round(n))

如果在我们使用此 function n = 5.23之前，我们将返回5 。 如果你想四舍五入到不同的位置值，你可以使用这个 function：

 def Round(n,k): point = '%0.' + str(k) + 'f' if k == 0: return int(point % n) else: return float(point % n)

如果我们再次使用n ( 5.23 )，将其四舍五入到最接近的十分之一，并将答案打印到控制台，我们的代码将是：

 Round(5.23,1)

这将返回5.2 。 最后，如果您想将某个值四舍五入到最接近的值，例如 1.2，您可以使用以下代码：

 def Round(n,k): return k * round(n/k)

如果我们希望n舍入为1.2 ，我们的代码将是：

 print(Round(n,1.2))

我们的结果：

 4.8

谢谢，如果您有任何问题。 请添加评论：）（节日快乐）

Answer 13

点击链接查看说明。 我帖子中链接的文章讨论了所有代码以及如何使用它。

https://kodify.net/python/math/truncate-decimals/

 import math def truncate(number, decimals=0): """ Returns a value truncated to a specific number of decimal places. """ if not isinstance(decimals, int): raise TypeError("decimal places must be an integer.") elif decimals < 0: raise ValueError("decimal places has to be 0 or more.") elif decimals == 0: return math.trunc(number) factor = 10.0 ** decimals return math.trunc(number * factor) / factor

Answer 14

如果我使用 79.5，则在此提到的正确答案中不起作用。 它给出的答案是 710，而不是 80。

 def proper_round(num, dec=0): num= int(num*pow(10,dec+1)) lastDigit = (str(num))[-1] num = int(num/10) if lastDigit >='5': num+=1 return float(num/pow(10,dec))

上面提到的代码给出了更好的结果

Answer 15

要将数字四舍五入到最接近的 int 数，请使用 numpy：

 p=np.array([ 430.15, 57.868, 70.697, 198.13]) p=np.round(p)

和 p：

 array([ 430, 58, 71, 198])

Answer 16

为此，我建议只做以下事情 -

 int(round(x))

这将为您提供最近的 integer。

希望这可以帮助