Python将整数舍入到下一百

似乎应该已经被问过数百次了（双关很有趣=），但是我只能找到舍入浮点数的函数。如何围捕一个整数，例如：130 -> 200？

四舍五入通常是对浮点数进行的，这里您应该了解三个基本函数：（round四舍五入到最接近的整数），math.floor（总是四舍五入）和math.ceil（总是四舍五入）。

您询问整数并舍入到数百，但是math.ceil只要您的数字小于2 ⁵³，我们仍然可以使用。要使用math.ceil，我们只需先除以100，向上舍入，然后再乘以100：

>>> import math
>>> def roundup(x):
...     return int(math.ceil(x / 100.0)) * 100
... 
>>> roundup(100)
100
>>> roundup(101)
200

先除以100，然后再乘以100，然后将“小数点”向左和向右移动两位，这样就math.ceil可以处理数百个数字。10**n如果您想舍入到十（n = 1），数千（n = 3）等，可以使用而不是100 。

执行此操作的另一种方法是避免浮点数（精度有限），而仅使用整数。整数在Python中具有任意精度，因此可以四舍五入任意大小的数字。四舍五入的规则很简单：除以100后找到余数，如果非零则加100减去此余数：

>>> def roundup(x):
...     return x if x % 100 == 0 else x + 100 - x % 100

这适用于任何大小的数字：

>>> roundup(100)
100
>>> roundup(130)
200
>>> roundup(1234567891234567891)
1234567891234567900L

我对这两种解决方案做了一个迷你基准测试：

$ python -m timeit -s 'import math' -s 'x = 130' 'int(math.ceil(x/100.0)) * 100'
1000000 loops, best of 3: 0.364 usec per loop
$ python -m timeit -s 'x = 130' 'x if x % 100 == 0 else x + 100 - x % 100'
10000000 loops, best of 3: 0.162 usec per loop

与该math.ceil解相比，纯整数解的速度快两倍。

Thomas提出了一种基于整数的解决方案，该解决方案与我上面的解决方案完全相同，不同之处在于它通过将布尔值相乘来使用技巧。有趣的是，以这种方式编写代码没有速度优势：

$ python -m timeit -s 'x = 130' 'x + 100*(x%100>0) - x%100'
10000000 loops, best of 3: 0.167 usec per loop

最后，请允许我注意一下，如果您想将101–149舍入到100，并将150–199舍入到200，例如，舍入到最接近的百位，则内置round函数可以为您做到这一点：

>>> int(round(130, -2))
100
>>> int(round(170, -2))
200

这是一个迟到的回答，但有一个简单的解决方案，结合了现有的答案的最好方面的下一个倍数100最多的x是x - x % -100（或者，如果你喜欢，x + (-x) % 100）。

>>> x = 130
>>> x -= x % -100  # Round x up to next multiple of 100.
>>> x
200

这是快速而简单的，可以给出任何整数的正确结果x（例如John Machin的答案），并且如果x是浮点数（例如Martin Geisler的答案），也可以给出合理的结果（对浮点表示法的常见警告进行模运算）。

>>> x = 0.1
>>> x -= x % -100
>>> x
100.0

试试这个：

int(round(130 + 49, -2))

这是舍入到任何正整数的最接近倍数的一般方法：

def roundUpToMultiple(number, multiple):
    num = number + (multiple - 1)
    return num - (num % multiple)

用法示例：

>>> roundUpToMultiple（101，100）
200
>>> roundUpToMultiple（654，321）
963

对于a非负，b正两个整数：

>>> rup = lambda a, b: (a + b - 1) // b * b
>>> [(x, rup(x, 100)) for x in (199, 200, 201)]
[(199, 200), (200, 200), (201, 300)]

更新 当前接受的答案与整数分开，以致无法将float（x）/ float（y）准确地表示为float。参见以下代码：

import math

def geisler(x, y): return int(math.ceil(x / float(y))) * y

def orozco(x, y): return x + y * (x % y > 0) - x % y

def machin(x, y): return (x + y - 1) // y * y

for m, n in (
    (123456789123456789, 100),
    (1234567891234567891, 100),
    (12345678912345678912, 100),
    ):
    print; print m, "m"; print n, "n"
    for func in (geissler, orozco, machin):
        print func(m, n), func.__name__

输出：

123456789123456789 m
100 n
123456789123456800 geisler
123456789123456800 orozco
123456789123456800 machin

1234567891234567891 m
100 n
1234567891234568000 geisler <<<=== wrong
1234567891234567900 orozco
1234567891234567900 machin

12345678912345678912 m
100 n
12345678912345680000 geisler <<<=== wrong
12345678912345679000 orozco
12345678912345679000 machin

以下是一些时间安排：

>\python27\python -m timeit -s "import math;x =130" "int(math.ceil(x/100.0))*100"
1000000 loops, best of 3: 0.342 usec per loop

>\python27\python -m timeit -s "x = 130" "x + 100 * (x % 100 > 0) - x % 100"
10000000 loops, best of 3: 0.151 usec per loop

>\python27\python -m timeit -s "x = 100" "(x + 99) // 100 * 100"
10000000 loops, best of 3: 0.0903 usec per loop

如果您的int是x： x + 100 - x % 100

但是，正如注释中指出的那样，如果返回，则将返回200 x==100。

如果这不是预期的行为，则可以使用 x + 100*(x%100>0) - x%100

试试这个：

import math
def ceilm(number,multiple):
    '''Returns a float rounded up by a factor of the multiple specified'''
    return math.ceil(float(number)/multiple)*multiple

用法示例：

>>> ceilm(257,5)
260
>>> ceilm(260,5)
260

警告：过早的优化...

由于此处的答案很多，因此我想添加另一种选择。

以@Martin Geisler的

def roundup(x):
    return x if x % 100 == 0 else x + 100 - x % 100

（由于几个原因，我最喜欢）

但排除％操作

def roundup2(x):
    x100= x % 100
    return x if x100 == 0 else x + 100 - x100

与原始速度相比，速度提高约20％

def roundup3(x):
    x100 = x % 100
    return x if not x100 else x + 100 - x100

甚至更好，比原始速度快36％

最终，我以为我可以删除not运算符并更改分支的顺序，希望这样做也可以提高速度，但困惑于发现它实际上更慢，回落到仅比原始速度快23％。

def roundup4(x):
    x100 = x % 100
    return x + 100 - x100  if x100 else x


>python -m timeit -s "x = 130" "x if x % 100 == 0 else x + 100 - x % 100"
1000000 loops, best of 3: 0.359 usec per loop

>python -m timeit -s "x = 130" "x100 = x % 100"  "x if x100 == 0 else x + 100 - x100"
1000000 loops, best of 3: 0.287 usec per loop

>python -m timeit -s "x = 130" "x100 = x % 100"  "x if not x100 else x + 100 - x100"
1000000 loops, best of 3: 0.23 usec per loop

>python -m timeit -s "x = 130" "x100 = x % 100"  "x + 100 - x100 if x100 else x"
1000000 loops, best of 3: 0.277 usec per loop

关于为什么3快于4的解释将是最受欢迎的。

这是一个非常简单的解决方案：

next_hundred = x//100*100+100

它是如何工作的？

1. 用100进行整数除法（它基本上切除了正常除法的小数部分）。这样，您可以获得数的十。例如：243 // 100 = 2。
2. 乘以100，得到的原始数字不包含十进制和一个。例如：2 * 100 = 200。
3. 加100可获得所需结果。例如：200 + 100 = 300

一些例子

• 0 ... 99舍入为100
• 100 ... 199舍入为200
• 等等

稍作修改的方法将1 ... 100舍入为100，将101 ... 200舍入为200等..

next_hundred = (x-1)//100*100+100