对不起，我想对阿洛克辛格海的回答发表评论，但由于缺乏声誉，它不让我评论=/

总之，我们可以再归纳一步:

def myround(x, base=5):
    return base * round(float(x) / base)

这允许我们使用非整数进制，如。25或任何其他分数进制。

这是我的C代码。如果我理解正确的话，应该是这样的;

#include <stdio.h>

int main(){
int number;

printf("Enter number: \n");
scanf("%d" , &number);

if(number%5 == 0)
    printf("It is multiple of 5\n");
else{
    while(number%5 != 0)
        number++;
  printf("%d\n",number);
  }
}

这也是四舍五入到最接近5的倍数而不是四舍五入;

#include <stdio.h>

int main(){
int number;

printf("Enter number: \n");
scanf("%d" , &number);

if(number%5 == 0)
    printf("It is multiple of 5\n");
else{
    while(number%5 != 0)
        if (number%5 < 3)
            number--;
        else
        number++;
  printf("nearest multiple of 5 is: %d\n",number);
  }
}

对于整数和Python 3:

def divround_down(value, step):
    return value//step*step


def divround_up(value, step):
    return (value+step-1)//step*step

生产:

>>> [divround_down(x,5) for x in range(20)]
[0, 0, 0, 0, 0, 5, 5, 5, 5, 5, 10, 10, 10, 10, 10, 15, 15, 15, 15, 15]
>>> [divround_up(x,5) for x in range(20)]
[0, 5, 5, 5, 5, 5, 10, 10, 10, 10, 10, 15, 15, 15, 15, 15, 20, 20, 20, 20]

一个只适用于整型的解决方案(它接受浮点数，但舍入行为就像小数组件不存在一样)，但不像任何依赖于临时转换到浮点数的解决方案(所有math.floor/math.浮点数)。基于天花板的解决方案，所有的解决方案使用/，大多数解决方案使用round)，它适用于任意巨大的int输入，永远不会失去精度，永远不会引发异常或导致无穷大的值。

它是一个最简单的解决方案的改编，四舍五入到一个数字的下一个低倍数:

def round_to_nearest(num, base=5):
    num += base // 2
    return num - (num % base)

它所基于的四舍五入食谱是:

def round_down(num, base=5):
    return num - (num % base)

唯一的变化是你提前给数字加上一半的基数，所以它四舍五入到最接近的值。对于精确的中点值，只有偶数底数才可能，因此round_to_nearest(3,6)将舍入为6而不是0，而round_to_nearest(- 3,6)将舍入为0而不是-6。如果希望中点值向下舍入，可以将第一行更改为num += (base - 1) // 2。

Use:

>>> def round_to_nearest(n, m):
        r = n % m
        return n + m - r if r + r >= m else n - r

它不使用乘法，也不会从/转换为浮点数。

四舍五入到最接近10的倍数:

>>> for n in range(-21, 30, 3): print('{:3d}  =>  {:3d}'.format(n, round_to_nearest(n, 10)))
-21  =>  -20
-18  =>  -20
-15  =>  -10
-12  =>  -10
 -9  =>  -10
 -6  =>  -10
 -3  =>    0
  0  =>    0
  3  =>    0
  6  =>   10
  9  =>   10
 12  =>   10
 15  =>   20
 18  =>   20
 21  =>   20
 24  =>   20
 27  =>   30

如你所见，它对负数和正数都适用。平局(例如-15和15)总是向上四舍五入。

一个类似的例子，四舍五入到5的最接近倍数，证明它也表现为不同的“基数”:

>>> for n in range(-21, 30, 3): print('{:3d}  =>  {:3d}'.format(n, round_to_nearest(n, 5)))
-21  =>  -20
-18  =>  -20
-15  =>  -15
-12  =>  -10
 -9  =>  -10
 -6  =>   -5
 -3  =>   -5
  0  =>    0
  3  =>    5
  6  =>    5
  9  =>   10
 12  =>   10
 15  =>   15
 18  =>   20
 21  =>   20
 24  =>   25
 27  =>   25

去掉“rest”会起作用:

rounded = int(val) - int(val) % 5

如果该值是一个整数:

rounded = val - val % 5

作为函数:

def roundint(value, base=5):
    return int(value) - int(value) % int(base)