在Python中四舍五入到5(或其他数字)

是否有一个内置函数可以像下面这样舍入?

10 -> 10
12 -> 10
13 -> 15
14 -> 15
16 -> 15
18 -> 20
189205 次浏览
小开
最佳答案

我不知道Python中的标准函数，但这对我来说是可行的:

Python 3

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

很容易理解为什么上面的方法是有效的。你要确保你的数字除以5是一个整数，四舍五入正确。所以，我们首先做的就是(round(x/5))，然后因为我们除以5，所以我们也乘以5。

我通过给它一个base形参使函数更通用，默认值为5。

Python 2

在Python 2中，将需要float(x)来确保/执行浮点除法，并且需要最终转换为int，因为round()在Python 2中返回一个浮点值。

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

这只是一个比例的问题

>>> a=[10,11,12,13,14,15,16,17,18,19,20]
>>> for b in a:
...     int(round(b/5.0)*5.0)
...
10
10
10
15
15
15
15
15
20
20
20
小开

round(x[， n]):数值四舍五入到10的负n次方的最接近倍数。所以如果n是负的…

def round5(x):
return int(round(x*2, -1)) / 2

由于10 = 5 * 2，您可以对2使用整数除法和乘法，而不是对5.0使用浮点除法和乘法。这并不重要，除非你喜欢位移位

def round5(x):
return int(round(x << 1, -1)) >> 1
小开

那么这个呢:

 def divround(value, step):
return divmod(value, step)[0] * step
小开

divround的修改版本:-)

def divround(value, step, barrage):
result, rest = divmod(value, step)
return result*step if rest < barrage else (result+1)*step
小开

去掉“rest”会起作用:

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

如果该值是一个整数:

rounded = val - val % 5

作为函数:

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

舍入到非整数值，例如0.05:

def myround(x, prec=2, base=.05):
return round(base * round(float(x)/base),prec)

我发现这很有用，因为我只需要在代码中进行搜索和替换，就可以将“round(”更改为“myround(”，而不必更改参数值。

小开
属性中添加0.5，可以“欺骗”int()使其舍入而不是舍入

. number你传递给int()
小开

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

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

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

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

小开

使用:

>>> 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
小开 
def round_to_next5(n):
return n + (5 - n) % 5
小开

下一个5的倍数

考虑51需要转换为55:

code here


mark = 51;
r = 100 - mark;
a = r%5;
new_mark = mark + a;
小开

万一有人需要“财务四舍五入”;(0.5轮始终向上):

def myround(x, base=5):
roundcontext = decimal.Context(rounding=decimal.ROUND_HALF_UP)
decimal.setcontext(roundcontext)
return int(base *float(decimal.Decimal(x/base).quantize(decimal.Decimal('0'))))

根据文档，其他舍入选项有:

  • ROUND_CEILING(朝向∞)
  • ROUND_DOWN(趋于0)
  • ROUND_FLOOR(朝向∞)
  • ROUND_HALF_DOWN(当领带趋于0时最接近)
  • ROUND_HALF_EVEN(最接近偶数)
  • ROUND_HALF_UP(从0开始到最近)
  • ROUND_UP (from 0)
  • ROUND_05UP(如果四舍五入后的最后一位数字为0或5，则远离0;否则趋于零)

默认情况下，Python使用ROUND_HALF_EVEN，因为它具有一些统计优势(四舍五入的结果没有偏见)。

小开

这是我的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]
小开

另一种方法(不需要显式的乘法或除法运算符):

def rnd(x, b=5):
return round(x + min(-(x % b), b - (x % b), key=abs))
小开

我想还没有人写过这个，但你可以这样做:

round(12, -1) --> 10
round(18, -1) --> 20
小开 
def round_up_to_base(x, base=10):
return x + (base - x) % base


def round_down_to_base(x, base=10):
return x - (x % base)

这给了

base=5:

>>> [i for i in range(20)]
[0, 1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

>>> [round_down_to_base(x=i, base=5) for i in range(20)]
[0, 0,  0,  0,  0,  5,  5,  5,  5,  5,  10, 10, 10, 10, 10, 15, 15, 15, 15, 15]


>>> [round_up_to_base(x=i, base=5) for i in range(20)]
[0, 5,  5,  5,  5,  5,  10, 10, 10, 10, 10, 15, 15, 15, 15, 15, 20, 20, 20, 20]

base=10:

>>> [i for i in range(20)]
[0, 1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

>>> [round_down_to_base(x=i, base=10) for i in range(20)]
[0, 0,  0,  0,  0,  0,  0,  0,  0,  0,  10, 10, 10, 10, 10, 10, 10, 10, 10, 10]


>>> [round_up_to_base(x=i, base=10) for i in range(20)]
[0, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 20, 20, 20, 20, 20, 20, 20, 20, 20]

在Python 3.7.9中测试

小开

我需要四舍五入到前面的5。

举个例子，16发到15发或者19发到15发

下面是使用的代码

    def myround(x,segment):
preRound = x / segment
roundNum = int(preRound)
segVal = segment * roundNum
return segVal
小开

对已接受答案的补充，用于指定四舍五入到最接近的5或其他值

import math


def my_round(x, base, down = True):
return base * math.floor(x/base) + (not down) * base
小开

一个只适用于int的解决方案(它接受float，但舍入行为就像小数组件不存在一样)，但不像任何依赖于临时转换到float的解决方案(所有基于math.floor/ __abc4的解决方案，所有解决方案使用/，大多数解决方案使用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)

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


提交答案