Python中的四舍五入（或其他数字）

是否有一个内置函数可以像下面这样循环

10 -> 10
12 -> 10
13 -> 15
14 -> 15
16 -> 15
18 -> 20

---

我不知道Python中有什么标准函数，但这对我很有用：

Python 2 蟒蛇3 很容易理解为什么上述方法有效。您要确保您的数字除以5是一个整数，正确地四舍五入。所以，我们首先要做的就是（

round（float（x）/5）

其中只有Python2需要

float

），然后因为我们除以5，所以我们也乘以5。最后转换为

int

是因为

round（）

在Python 2中返回一个浮点值

---

我给了函数一个

base

参数，默认值为5，从而使函数更加通用。

这只是一个缩放问题

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

四舍五入（x[，n]）：将值四舍五入到幂减n的最接近的10倍。所以如果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 round5（x）：
返回整数（四舍五入（x>1

这个怎么办：

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

---

divround的修改版本：-）

def divround（值、步长、弹幕）：
结果，rest=divmod（值，步长）
返回结果*如果rest

删除“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（）

的号码对不起，我想对阿洛克·辛亥的回答发表评论，但由于声誉不佳，我不愿意发表评论=/

总之，我们可以再概括一步：

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的最接近倍数，表明它的行为也与不同“基准”的预期行为相同：

---

下一个5的倍数

考虑51需要转换为55：

code here

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

如果有人需要“财务舍入”（0.5舍入始终向上）：

根据文件，其他舍入选项包括：

圆形天花板（朝向无限大），
向下取整（接近零），
圆形地板（朝向无限大），
向下四舍五入（到最近的位置，系结接近零），
四舍五入半偶数（到最近的整数，连到最近的偶数整数），
向上四舍五入（到最接近的位置，系结远离零），或
向上取整（远离零）。
向上舍入（如果向零舍入后的最后一位数字为0或5，则远离零；否则向零舍入）

---

默认情况下，Python使用ROUND_HALF_，即使它有一些统计优势（舍入的结果没有偏差）。

这是我的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);
  }
}

#包括
int main（）{
整数；
printf（“输入编号：\n”）；
scanf（“%d”和编号）；
如果（数字%5==0）
printf（“它是5的倍数”）；
否则{
while（数字%5！=0）
数字++；
printf（“%d\n”，数字）；
}
}

这也将四舍五入到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);
  }
}

#包括
int main（）{
整数；
printf（“输入编号：\n”）；
scanf（“%d”和编号）；
如果（数字%5==0）
printf（“它是5的倍数”）；
否则{
while（数字%5！=0）
如果（数字%5<3）
数字--；
其他的
数字++；
printf（“5的最近倍数为：%d\n”，数字）；
}
}

对于整数和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]

另一种方法（无显式乘法或除法运算符）：

---

我想还没有人写过这篇文章，但你可以做到：

round(12, -1) --> 10
round(18, -1) --> 20

def向上取整到基数（x，基数=10）：
返回x+（基数-x）%base
def四舍五入到基数（x，基数=10）：
返回x-（x%基本值）

给

对于

base=5

：

>[i代表范围内的i（20）]
[0, 1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

>>[范围（20）内的i向下四舍五入到基数（x=i，基数=5）]
[0, 0,  0,  0,  0,  5,  5,  5,  5,  5,  10, 10, 10, 10, 10, 15, 15, 15, 15, 15]
>>>[对于范围（20）内的i，将_向上舍入到_基（x=i，基=5）]
[0, 5,  5,  5,  5,  5,  10, 10, 10, 10, 10, 15, 15, 15, 15, 15, 20, 20, 20, 20]

对于

base=10

：

>[i代表范围内的i（20）]
[0, 1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

>>[范围（20）内的i向下四舍五入到基数（x=i，基数=10）]
[0, 0,  0,  0,  0,  0,  0,  0,  0,  0,  10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
>>>[对于范围（20）内的i，将_向上舍入到_基（x=i，基=10）]
[0, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 20, 20, 20, 20, 20, 20, 20, 20, 20]

---

在Python 3.7.9中进行了测试，因此在本例中，您可以使用divround（值，5，3）或divround（值，5，2.5）divround（值，5，3），确切地说，+1表示round（）可以处理除1.0以外的倍数的舍入，包括更高的值。（但是，请注意，位移位方法不适用于浮点数，更不用说它对大多数程序员来说可读性差得多。）@Peter Hansen感谢+1。位移位需要一个int（x）才能适用于浮点数。同意不是最可读的，我自己也不会使用它，但我喜欢“纯度”其中只涉及1，而不是2或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'))))

#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);
  }
}

#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);
  }
}

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