你如何四舍五入一个数字？

math.ceil（天花板）函数返回大于或等于的最小整数。x

对于 Python 3：

import math
print(math.ceil(4.2))

对于 Python 2：

import math
print(int(math.ceil(4.2)))

使用 math.ceil 向上舍入：

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

注意：输入应为浮点数。

如果需要整数，请调用进行转换：int

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

顺便说一句，用于向下舍入和舍入到最接近的整数。math.floorround

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

要记住的有趣的 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

您可能也喜欢numpy：

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

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

无论如何，只是我遇到的一个细节。我经常使用 numpy，很惊讶它没有被提及，但当然公认的答案效果很好。

我知道这个答案是针对不久前的一个问题，但如果你不想导入数学，而只是想四舍五入，这对我有用。

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

第一部分变为 4，如果有余数，则第二部分的计算结果为“True”，此外 True = 1;False = 0。因此，如果没有余数，则保持相同的整数，但如果有余数，则加 1。

要在没有任何导入的情况下执行此操作，请执行以下操作：

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

be shure 舍入值应为 float

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

但

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

我知道这是很久以前的事了，但我找到了一个非常有趣的答案，所以这里是：

-round(-x-0.5)

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

干杯

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

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

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

如果使用整数，四舍五入的一种方法是利用四舍五入的事实：只需对负数进行除法，然后否定答案。无需导入、浮点或条件。//

rounded_up = -(-numerator // denominator)

例如：

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

我基本上是 Python 的初学者，但如果你只是想向上而不是向下舍入，为什么不这样做：

round(integer) + 1

您可以使用地板设计并向其添加 1。 2.3 // 2 + 1

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

在不导入的情况下，我使用：

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（） 的内置类型，值四舍五入到最接近 10 的幂减去 n 的倍数;如果两个倍数相等接近，则向偶数选择进行舍入

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

如果你不想导入任何东西，你可以随时编写自己的简单函数，如下所示：

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

我很惊讶没有人建议

(numerator + denominator - 1) // denominator

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

当您在 Python 中操作 4500/1000 时，结果将为 4，因为对于默认的 Python 来说，从逻辑上讲，结果假定为整数： 4500/1000 = 4.5 --> 整数（4.5） = 4 而 4 的 ceil 显然是 4

使用 4500/1000.0，结果为 4.5，CEIL 为 4.5 --> 5

使用 javascript，您将收到 4.5 作为 4500/1000 的结果，因为 javascript 仅将结果假定为“数值类型”，并直接以浮点数形式返回结果

祝你好运！！

上面的答案是正确的，但是，仅为这一个函数导入模块对我来说通常感觉有点矫枉过正。幸运的是，还有另一种方法可以做到这一点：math

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

True并在 Python 中解释为涉及数字的语句中的 和。 基本上翻译为 或 .所以英文的最后一句话是.False10g.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 = 211.0
print(int(a) + ((int(a) - a) != 0))

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

int()如果给出浮点数，则始终截断十进制数;而 ，如果 where 和 都在相等的距离内，Python 返回离 0 点较远的那个。round()2.5232.5

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

对于那些想要四舍五入并得到整数的人：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

注意：a 和 b 必须是非负整数

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

此功能不需要任何模块。

我的份额

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

现在四舍五入：

101 * 19% = 19.19

我不能使用，所以我将乘法传播到除法：**

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

如果有人希望四舍五入到特定的小数位：

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

你可以像这样使用 round：

cost_per_person = round(150 / 2, 2)

  

对于那些不想使用导入的人。

对于给定列表或任何数字：

x = [2, 2.1, 2.5, 3, 3.1, 3.5, 2.499,2.4999999999, 3.4999999,3.99999999999]

您必须首先评估该数字是否等于其整数，该整数始终向下舍入。如果结果为 True，则返回数字，如果不是，则返回 integer（number） + 1。

w = lambda x: x if x == int(x) else int(x)+1
[w(i) for i in z]
>>> [2, 3, 3, 3, 4, 4, 3, 3, 4, 4]

数学逻辑：

• 如果数字有小数部分：round_up - round_down == 1，则始终。
• 如果数字没有小数部分：round_up - round_down == 0。

所以：

• round_up == x + round_down

跟：

• x == 1 if number ！= round_down
• x == 0 如果数字 == round_down

您将数字切成两部分，整数和小数。如果 decimal 不是 0，则加 1。

PS：我详细解释了这一点，因为上面的一些评论要求这样做，而我在这里仍然是菜鸟，所以我不能发表评论。

x * -1 // 1 * -1

令人困惑，但它有效：对于，你得到.对于 ，你得到x=7.18.0x = -1.1-1.0

无需导入模块。

这是一种使用 和modulobool

n = 2.3
int(n) + bool(n%1)

输出：

3

这应该有效。

a=16
b= int(input("Please enter a number greater than 0 \n"))

if b==0:
    print ( "Wrong input")

elif a%b != 0:
    c=a/b
    d= int(c)+1
    print (c)
    print (d)
else:
    c=a/b
    d=c        
print (c)
print (d)

这是一个非常简单的答案，基于默认 round（） 的使用

def round_up(arg):
    if arg > round(arg):
        return round(arg) + 1
    else:
        return round(arg)

确实如此

1 to 1     -1 to -1     1.0 to 1    1.00000001 to 2    -1.00000001 to -1