Question

如何在python中将数字向上舍入到第二个小数位？例如：

0.022499999999999999

应该向上舍入到0.03

0.1111111111111000

应该向上舍入到0.12

如果小数点后三位有任何值，我希望它总是向上舍入，留下小数点后面的2个值。

Answer 1

Python包含round()函数lets you specify您想要的位数。来自文档：

round(x[, n])

将浮点值x舍入为小数点后的n位数。如果省略n，则默认为零。结果是一个浮点数。数值四舍五入为10的最接近倍数，功率减去n;如果两个倍数相等，则舍入远离0（例如，round（0.5）为1.0，round（-0.5）为-1.0）。

因此，您希望使用round(x, 2)进行正常舍入。要确保数字始终为 up ，您需要使用ceil(x)函数。同样，要围绕向下使用floor(x)。

Answer 2

from math import ceil

num = 0.1111111111000
num = ceil(num * 100) / 100.0

请参阅：
math.ceil documentation
round documentation - 您可能希望无论如何都要查看此信息以供将来参考

Answer 3

根据埃德温的回答推断：

from math import ceil, floor
def float_round(num, places = 0, direction = floor):
    return direction(num * (10**places)) / float(10**places)

使用：

>>> float_round(0.21111, 3, ceil)  #round up
>>> 0.212
>>> float_round(0.21111, 3)        #round down
>>> 0.211
>>> float_round(0.21111, 3, round) #round naturally
>>> 0.211

Answer 4

x = math.ceil(x * 100.0) / 100.0

Answer 5

这取决于您在考虑正数和负数时所需的行为，但如果您想要总是舍入到更大的值（例如2.0449 - > 2.05，-2.0449 - > -2.04），那么您可以执行以下操作：

round(x + 0.005, 2)

或有点爱好者：

def round_up(x, place):
    return round(x + 5 * 10**(-1 * (place + 1)), place)

这似乎也起作用如下：

round(144, -1)
# 140
round_up(144, -1)
# 150
round_up(1e308, -307)
# 1.1e308

Answer 6

请注意ceil(num * 100) / 100技巧会在某些退化输入上崩溃，例如1e308。这可能不会经常出现，但我可以告诉你它只花了我几天。为了避免这种情况，＆＃34;如果＆＃34; ceil()和floor()采用了小数位数参数，就像round()一样...同时，任何人都知道一个干净的替代方案会在这样的输入上崩溃吗？我对decimal包有一些希望，但它似乎也死了：

>>> from math import ceil
>>> from decimal import Decimal, ROUND_DOWN, ROUND_UP
>>> num = 0.1111111111000
>>> ceil(num * 100) / 100
0.12
>>> float(Decimal(num).quantize(Decimal('.01'), rounding=ROUND_UP))
0.12
>>> num = 1e308
>>> ceil(num * 100) / 100
Traceback (most recent call last):
  File "<string>", line 301, in runcode
  File "<interactive input>", line 1, in <module>
OverflowError: cannot convert float infinity to integer
>>> float(Decimal(num).quantize(Decimal('.01'), rounding=ROUND_UP))
Traceback (most recent call last):
  File "<string>", line 301, in runcode
  File "<interactive input>", line 1, in <module>
decimal.InvalidOperation: [<class 'decimal.InvalidOperation'>]

当然有人可能会说崩溃是这种投入上唯一理智的行为，但我认为这不是四舍五入，而是引起问题的倍增（这就是为什么例如，1e306不会崩溃），并且更圆的第n个fn的更清晰的实现将避免乘法黑客。

Answer 7

def round_up(number, ndigits=None):
    # start by just rounding the number, as sometimes this rounds it up
    result = round(number, ndigits if ndigits else 0)
    if result < number:
        # whoops, the number was rounded down instead, so correct for that
        if ndigits:
            # use the type of number provided, e.g. float, decimal, fraction
            Numerical = type(number)
            # add the digit 1 in the correct decimal place
            result += Numerical(10) ** -ndigits
            # may need to be tweaked slightly if the addition was inexact
            result = round(result, ndigits)
        else:
            result += 1 # same as 10 ** -0 for precision of zero digits
    return result

assert round_up(0.022499999999999999, 2) == 0.03
assert round_up(0.1111111111111000, 2) == 0.12

assert round_up(1.11, 2) == 1.11
assert round_up(1e308, 2) == 1e308

Answer 8

这是适用于任何数字的更通用的单行代码：

import math
def ceil(number, digits) -> float: return math.ceil((10.0 ** digits) * number) / (10.0 ** digits)

用法示例：

>>> ceil(1.111111, 2)
1.12

注意：如nimeshkiranverma所述：

>>> ceil(1.11, 2) 
1.12  #Because: 1.11 * 100.0 has value 111.00000000000001

Answer 9

所述的圆形功能不适用于如下定义的整数：

α= 8
  轮（A，3）
  8.0
  A = 8.00
  轮（A，3）
  8.0
  A = 8.000000000000000000000000
  轮（A，3）
  8.0

但是，适用于：

R = 400 / 3.0
  [R
      133.33333333333334
  圆（R，3）
      133.333

除了像2.675这样的小数，其四舍五入为2.67而不是2.68 更好地使用上面提供的其他方法。

Answer 10

python round函数可能正在为您带来意想不到的结果。

使用Decimal.quantize

可以更详细地说明舍入方法

例如

from decimal import Decimal, ROUND_HALF_UP
res = Decimal('0.25').quantize(Decimal('0.0'), rounding=ROUND_HALF_UP)
print(res) 
# prints 0.3

更多参考：

https://gist.github.com/jackiekazil/6201722

Answer 11

这是一种简单的方法，我在其他答案中没有看到。

舍入到小数点后两位：

    requestInput := &s3.GetObjectInput{
        Bucket: aws.String(bucket),
        Key:    aws.String(key),
    }

    result, err := s3Client.GetObject(requestInput)
    if err != nil {
        fmt.Println(err)
    }
    defer result.Body.Close()
    body1, err := ioutil.ReadAll(result.Body)
    if err != nil {
        fmt.Println(err)
    }
    bodyString1 := fmt.Sprintf("%s", body1)

    var s3data StockInfo
    decoder := json.NewDecoder(strings.NewReader(bodyString1))
    err = decoder.Decode(&s3data)
    if err != nil {
        fmt.Println("twas an error")
    }

    fmt.Println(s3data)

其他值：

>>> n = 0.022499999999999999
>>> 
>>> -(-n//.01) * .01
0.03
>>>

使用浮点数时，偶尔会出现一些不精确的值，如果您正在显示例如以下值，则可以对其进行校正：

>>> n = 0.1111111111111000
>>> 
>>> -(-n//.01) * .01
0.12
>>>

具有参数以指定精度的简单汇总函数：

>>> n = 10.1111111111111000
>>> 
>>> -(-n//0.01) * 0.01
10.120000000000001
>>> 
>>> f"{-(-n//0.01) * 0.01:.2f}"
'10.12'
>>>

在Python中舍入到第二个小数位

11 个答案: