Question

这个问题正在扼杀我。如何在Python中对数字进行综合？

我尝试了一下（数字），但它将数字向下舍入。例如：

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

我尝试了int（数字+ .5），但它再次将数字向下舍入！例如：

int(2.3 + .5) = 2

然后我尝试了回合（数字+ .5），但它在边缘情况下不起作用。例如：

WAIT! THIS WORKED!

请告知。

Answer 1

ceil（天花板）功能：

import math
print(math.ceil(4.2))

Answer 2

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

Answer 3

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

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

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

Answer 4

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

rounded_up = -(-numerator // denominator)

例如：

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

Answer 5

您可能也喜欢numpy：

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

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

无论如何，只是我遇到的一个细节。我经常使用numpy并且很惊讶它没有被提及，但当然接受的答案完全正常。

Answer 6

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

Answer 7

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

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

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

Answer 8

我很惊讶没有人建议

(numerator + denominator - 1) // denominator

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

Answer 9

应该是漂浮的圆形值

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

但

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

Answer 10

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

此功能不需要任何模块。

Answer 11

试试这个：

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

Answer 12

不使用基本环境导入数学：

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)

Answer 13

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

[HttpPost]
public ActionResult MyAction(MyViewModel viewModel) // view model properties match the form names
{
  // Add a new record to the context.
  // I have no idea how you've got your context set up
  MyContext.Set<Blah>.Add(new Blah
  {
    A = viewModel.A,
    B = viewModel.B
  });

  // Save the context - this will write any differences back to the database
  MyContext.SaveChanges();

  // Redirect to the GET action
  // Do a redirect to avoid resubmitting form data with F5 
  return RedirectToAction("MyAction");
}

Answer 14

对于那些想要整理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

Answer 15

我很惊讶我还没有看到这个答案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，则会失败，但这不太可能。

Answer 16

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

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

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 if number == round_down

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

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

Answer 17

当你在python中运行4500/1000时，结果将是4，因为默认的python asume为整数结果，逻辑上： 4500/1000 = 4.5 - ＆gt; int（4.5）= 4 4个明显的细胞是4个

使用4500 / 1000.0，结果将是4.5，而ceil是4.5 - > 5

使用javascript你将收到4.5作为4500/1000的结果，因为javascript只将结果作为“数字类型”并直接返回结果为float

祝你好运!!

Answer 18

如果您不想导入任何内容，您可以随时编写自己的简单功能：

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

Answer 19

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

-round(-x-0.5)

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

干杯

Answer 20

无需任何导入即可完成：

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

Answer 21

你可以使用 rond

cost_per_person = round(150 / 2, 2)

Answer 22

您可以使用地面划分并为其添加1。 2.3 // 2 + 1

Answer 23

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

如果给出浮点数，

int()总是截断十进制数;而round()，如果2.5 2和3距2.5的距离相等，则Python会返回距离0点更远的地方。

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

Answer 24

我的分享

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

现在进行四舍五入：

101 * 19% = 19.19

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

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

Answer 25

我基本上是Python的初学者，但是如果你只想尝试整理而不是为什么不这样做：

round(integer) + 1

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

25 个答案: