如何在Python中四舍五入一个数字？

这个问题使我丧命。如何在Python中向上舍入一个数字？

我尝试了舍入（数字），但它四舍五入数字。例：

round(2.3) = 2.0 and not 3, what I would like

我尝试了int（number + .5），但是它再次将数字取整！例：

int(2.3 + .5) = 2

然后我尝试了round（number + .5），但在边缘情况下不起作用。例：

WAIT! THIS WORKED!

请指教。

该小区（上限）功能：

import math
print(math.ceil(4.2))

我知道这个答案是一个很久以前的问题，但是如果您不想导入数学并且只想四舍五入，那么这对我有用。

>>> int(21 / 5)
4
>>> int(21 / 5) + (21 % 5 > 0)
5

如果有余数，则第一部分将变为4，第二部分将得出“ True”，另外，True = 1; False =0。因此，如果没有余数，则它将保持相同的整数，但是如果有余数，则将其加1。

请记住有趣的Python 2.x问题：

>>> import math
>>> math.ceil(4500/1000)
4.0
>>> math.ceil(4500/1000.0)
5.0

问题是在python中将两个int相除会产生另一个int，并且在上限调用之前被截断了。您必须使一个值成为浮点数（或强制转换）才能获得正确的结果。

在javascript中，完全相同的代码会产生不同的结果：

console.log(Math.ceil(4500/1000));
5

如果使用整数，则四舍五入的一种方法是利用四舍五入的事实//：只需对负数进行除法，然后取反即可。无需导入，浮点或有条件的。

rounded_up = -(-numerator // denominator)

例如：

>>> print(-(-101 // 5))
21

您可能还喜欢numpy：

>>> import numpy as np
>>> np.ceil(2.3)
3.0

我并不是说它比数学更好，但是如果您已经将numpy用于其他目的，则可以使代码保持一致。

无论如何，我遇到的只是一个细节。我经常使用numpy，但感到惊讶的是它没有被提及，但是当然可以接受。

使用math.ceil围捕：

>>> import math
>>> math.ceil(5.4)
6.0

注意：输入应为浮点型。

如果需要整数，请调用int将其转换：

>>> int(math.ceil(5.4))
6

BTW，使用math.floor到轮下，并round以轮最接近的整数。

>>> math.floor(4.4), math.floor(4.5), math.floor(5.4), math.floor(5.5)
(4.0, 4.0, 5.0, 5.0)
>>> round(4.4), round(4.5), round(5.4), round(5.5)
(4.0, 5.0, 5.0, 6.0)
>>> math.ceil(4.4), math.ceil(4.5), math.ceil(5.4), math.ceil(5.5)
(5.0, 5.0, 6.0, 6.0)

语法可能不像pythonic那样，但是它是一个功能强大的库。

https://docs.python.org/2/library/decimal.html

from decimal import *
print(int(Decimal(2.3).quantize(Decimal('1.'), rounding=ROUND_UP)))

我很惊讶没有人建议

(numerator + denominator - 1) // denominator

用于四舍五入的整数除法。曾经是C / C ++ / CUDA的常用方法（参见divup）

请确保四舍五入的值应为浮点型

a = 8 
b = 21
print math.ceil(a / b)
>>> 0

但

print math.ceil(float(a) / b)
>>> 1.0

尝试这个：

a = 211.0
print(int(a) + ((int(a) - a) != 0))

>>> def roundup(number):
...     return round(number+.5)
>>> roundup(2.3)
3
>>> roundup(19.00000000001)
20

此功能不需要任何模块。

上面的答案是正确的，但是，math对于这个功能而言，导入模块通常对我来说有点过头了。幸运的是，还有另一种方法可以做到：

g = 7/5
g = int(g) + (not g.is_integer())

True并且在python中涉及数字的语句中False被解释为1和0。g.is_interger()基本上翻译为g.has_no_decimal()或g == int(g)。因此，最后的英文陈述为round g down and add one if g has decimal。

无需导入数学//使用基本环境：

a）方法/类方法

def ceil(fl): 
  return int(fl) + (1 if fl-int(fl) else 0)

def ceil(self, fl): 
  return int(fl) + (1 if fl-int(fl) else 0)

b）lambda：

ceil = lambda fl:int(fl)+(1 if fl-int(fl) else 0)

对于那些想要四舍五入a / b并获得整数的人：

使用整数除法的另一个变体是

def int_ceil(a, b):
    return (a - 1) // b + 1

>>> int_ceil(19, 5)
4
>>> int_ceil(20, 5)
4
>>> int_ceil(21, 5)
5

如果有人希望将其舍入到小数点后一位：

import math
def round_up(n, decimals=0):
    multiplier = 10 ** decimals
    return math.ceil(n * multiplier) / multiplier

令我惊讶的是我还没有看到这个答案round(x + 0.4999)，所以我要把它放下来。请注意，这适用于任何Python版本。对Python舍入方案的更改使事情变得困难。看到这篇文章。

不导入，我使用：

def roundUp(num):
    return round(num + 0.49)

testCases = list(x*0.1 for x in range(0, 50))

print(testCases)
for test in testCases:
    print("{:5.2f}  -> {:5.2f}".format(test, roundUp(test)))

为什么这样

来自文档

对于支持round（）的内置类型，将值四舍五入为乘幂n的最接近10的倍数；如果两个倍数相等接近，则四舍五入取整为偶数选择

因此，将2.5舍入为2，将3.5舍入为4。如果不是这种情况，则可以通过加0.5来舍入，但是我们要避免到达中间点。因此，如果添加0.4999，您将接近，但有足够的余量可以四舍五入到通常的期望值。当然，如果x + 0.4999等于，这将失败[n].5000，但这不太可能。

要做到这一点而无需任何导入：

>>> round_up = lambda num: int(num + 1) if int(num) != num else int(num)
>>> round_up(2.0)
2
>>> round_up(2.1)
3

我知道这已经有一段时间了，但是我找到了一个非常有趣的答案，所以可以这样：

-round(-x-0.5)

这可以修复边缘情况，并且适用于正数和负数，并且不需要任何函数导入

干杯

当您在python中操作4500/1000时，结果将为4，因为默认情况下python假定结果为整数，逻辑上：4500/1000 = 4.5-> int（4.5）= 4且ceil显然为4

使用4500 / 40.0的结果将是4.5且ceil为4.5-> 5

使用javascript，您将收到4.5的4500/1000结果，因为javascript仅将结果视为“数值类型”，并将结果直接返回为float

祝好运！！

如果您不想导入任何内容，则可以始终将自己的简单函数编写为：

def RoundUP(num): if num== int(num): return num return int(num + 1)

您可以使用楼层划分并将其添加1。2.3 // 2 + 1

我认为您会混淆int()和之间的工作机制round()。

int()如果给出浮点数，则总是截断十进制数；相反round()，如果2.5where 2和3are都在等距离内2.5，则Python返回距离0点更远的那个。

round(2.5) = 3
int(2.5) = 2

我的份额

我已经测试 print(-(-101 // 5)) = 21了上面给出的示例。

现在进行四舍五入：

101 * 19% = 19.19

我不能使用，**所以我将乘法扩展到除法：

(-(-101 //(1/0.19))) = 20

我基本上是Python的初学者，但是如果您只是想舍入而不是舍弃，那为什么不做：

round(integer) + 1