如何在 Python 中将一个数字向上取整?
我尝试了 round(number)
,但它会将数字四舍五入。例子:
round(2.3) = 2.0
而不是 3,如我所愿。
我试过 int(number + .5)
但它又把数字四舍五入了!例子:
int(2.3 + .5) = 2
round(number + .5)
不起作用。 round(3+.5) == 4
,当您真正需要 3
时。
math.ceil(上限)函数返回大于或等于 x
的最小整数。
对于 Python 3:
import math
print(math.ceil(4.2))
对于 Python 2:
import math
print(int(math.ceil(4.2)))
我知道这个答案是针对不久前的一个问题,但是如果您不想导入数学并且只想四舍五入,这对我有用。
>>> int(21 / 5)
4
>>> int(21 / 5) + (21 % 5 > 0)
5
第一部分变为 4,如果有余数,则第二部分计算为“True”,此外 True = 1; False = 0。因此,如果没有余数,则保持相同的整数,但如果有余数,则加 1。
//
进行整数除法,因此它变为 21 // 5 + (21 % 5 > 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
如果使用整数,向上舍入的一种方法是利用 //
向下舍入的事实:只需对负数进行除法,然后否定答案。不需要导入、浮点或条件。
rounded_up = -(-numerator // denominator)
例如:
>>> print(-(-101 // 5))
21
(num + den - 1) // den
,它适用于具有正分母的 int
输入,但即使涉及单个非整数 float
(分子或分母)也会失败;这看起来更神奇,但适用于 int
和 float
。对于小分子,它也更快(在 CPython 3.7.2 上),但奇怪的是,当只有分子足够大以至于需要基于数组的数学时,你的方法会更慢;不清楚为什么会这样,因为除法工作应该相似,并且两个一元否定应该比加法+减法便宜。
你可能还喜欢 numpy:
>>> import numpy as np
>>> np.ceil(2.3)
3.0
我并不是说它比数学好,但如果你已经将 numpy 用于其他目的,你可以保持你的代码一致。
无论如何,只是我遇到的一个细节。我经常使用 numpy 并且很惊讶它没有被提及,但当然接受的答案非常好。
Use math.ceil
四舍五入:
>>> import math
>>> math.ceil(5.4)
6.0
注意:输入应该是浮动的。
如果需要整数,请调用 int
进行转换:
>>> int(math.ceil(5.4))
6
顺便说一句,使用 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)
ceil()
will take care of it,则输入不一定需要是浮点数
我很惊讶没有人建议
(numerator + denominator - 1) // denominator
用于四舍五入的整数除法。曾经是 C/C++/CUDA 的常用方式(参见 divup
)
1
而不是减去它,或者在执行数学运算之前翻转分子和分母的符号。
语法可能不像人们喜欢的那样 Pythonic,但它是一个强大的库。
https://docs.python.org/2/library/decimal.html
from decimal import *
print(int(Decimal(2.3).quantize(Decimal('1.'), rounding=ROUND_UP)))
对于那些想要四舍五入 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
必须是非负整数
int_ceil(-0.1, 1)
给出错误答案。当它是 -1.0
时应该是 0.0
int_ceil(2,-1)
为我提供 0
。所以整数必须是非负的
尝试这个:
a = 211.0
print(int(a) + ((int(a) - a) != 0))
a
需要四舍五入时,((int(a) - a) != 0)
表达式就会返回 1
。您可能想扩展您的答案并解释它是如何工作的。
舒尔四舍五入的值应该是浮点数
a = 8
b = 21
print math.ceil(a / b)
>>> 0
但
print math.ceil(float(a) / b)
>>> 1.0
上面的答案是正确的,但是,只为这个功能导入 math
模块对我来说通常感觉有点矫枉过正。幸运的是,还有另一种方法:
g = 7/5
g = int(g) + (not g.is_integer())
True
和 False
在 python 中涉及数字的语句中被解释为 1
和 0
。 g.is_interger()
基本上转换为 g.has_no_decimal()
或 g == int(g)
。所以英文的最后一个语句是round g down and add one if g has decimal
。
int(g) + (g % 1 > 0)
;-)
from math import ceil
似乎修复了导入整个数学模块 :)
import math
没有太大区别。它只是删除除 ceil
之外的所有符号。
如果有人希望四舍五入到特定的小数位:
import math
def round_up(n, decimals=0):
multiplier = 10 ** decimals
return math.ceil(n * multiplier) / multiplier
无需导入数学 // 使用基本环境:
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) 拉姆达:
ceil = lambda fl:int(fl)+(1 if fl-int(fl) else 0)
>>> def roundup(number):
... return round(number+.5)
>>> roundup(2.3)
3
>>> roundup(19.00000000001)
20
此功能不需要模块。
3
,那么它会四舍五入到 4
,这可能是也可能不是某人想要的
这是使用 modulo
和 bool
的方法
n = 2.3
int(n) + bool(n%1)
输出:
3
x * -1 // 1 * -1
令人困惑但它有效:对于 x=7.1
,你得到 8.0
。对于 x = -1.1
,您将获得 -1.0
无需导入模块。
对于那些不想使用导入的人。
对于给定的列表或任何数字:
x = [2, 2.1, 2.5, 3, 3.1, 3.5, 2.499,2.4999999999, 3.4999999,3.99999999999]
您必须首先评估该数字是否等于其整数,该整数始终向下舍入。如果结果为真,则返回数字,如果不是,则返回整数(数字)+ 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 如果数字 != round_down
== 0 如果数字 == round_down
您将数字分成两部分,整数和小数。如果小数不为 0,则加 1。
PS:我对此进行了详细解释,因为上面的一些评论要求这样做,而我在这里仍然是菜鸟,所以我无法发表评论。
如果您不想导入任何内容,您可以随时编写自己的简单函数:
def RoundUP(num):
if num== int(num):
return num
return int(num + 1)
你可以像这样使用圆形:
cost_per_person = round(150 / 2, 2)
要在没有任何导入的情况下执行此操作:
>>> 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)
这修复了边缘情况并适用于正数和负数,并且不需要任何函数导入
干杯
-round(-x-0.3) = x
-round(-3-0.5)
返回 4 而不是 3,这是应该的。
我很惊讶我还没有看到这个答案round(x + 0.4999)
,所以我要把它记下来。请注意,这适用于任何 Python 版本。对 Python 舍入方案所做的更改使事情变得困难。请参阅此post。
不导入,我使用:
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
,这将失败,但这不太可能。
math.ceil()
?
Without importing I use:
。我还提到如果 x + 0.4999
等于 [n].5000
,它将失败。
math
模块和 math.ceil()
位于标准库中,因此在任何地方都可以用于所有实际用途,而无需安装额外的东西。关于你提到它何时失败,这在你的回答中是不完整的,因为它在整个间隔内都失败了,而不仅仅是一个点。从技术上讲,您可能会争辩说您是正确的,正如您所说的 if 而不是 iff,但它会给不经意的读者留下这样的印象,即它的可能性比实际情况要小.
您可以使用楼层划分并为其添加 1。 2.3 // 2 + 1
ceil()
而不是奇怪地做相反的事然后补偿
from math import ceil; assert 4 // 2 + 1 == ceil(4 / 2)
当您在 python 中操作 4500/1000 时,结果将为 4,因为默认 python 假定结果为整数,逻辑上:4500/1000 = 4.5 --> int(4.5) = 4 并且 ceil of 4 显然是 4
使用 4500/1000.0 结果将是 4.5 和 ceil 为 4.5 --> 5
使用 javascript,您将收到 4.5 作为 4500/1000 的结果,因为 javascript 仅假定结果为“数字类型”并直接将结果作为浮点数返回
祝你好运!!
/
进行除法始终产生浮点数,因此 4500/1000
始终为 4.5。
我认为您混淆了 int()
和 round()
之间的工作机制。
如果给出浮点数,int()
总是截断十进制数;而 round()
,在 2
和 3
与 2.5
距离相等的 2.5
的情况下,Python 返回距离 0 点更远的那个。
round(2.5) = 3
int(2.5) = 2
2.3
变成了 3
,这在您的两个示例中都没有发生。
我的份额
我已经测试了上面给出的 print(-(-101 // 5)) = 21
示例。
现在进行四舍五入:
101 * 19% = 19.19
我不能使用 **
所以我将乘法扩展到除法:
(-(-101 //(1/0.19))) = 20
我基本上是 Python 的初学者,但如果你只是想向上取整而不是向下取整,为什么不这样做:
round(integer) + 1
round(integer + 0.5)
这是我经常做的
不定期副业成功案例分享
int(math.ceil(363))
math.ceil
返回一个实际的整数对象,而不仅仅是具有整数值的浮动对象。10000000 * 0.00136 = 13600.000000000002
ceil 可以增加很多math.ceil(10000000 * 0.00136) = 13601.0