在Python中舍入到5（或其他数字）

Question

是否可以像以下内容一样围绕内置功能？

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

Answer 1

对于舍入到非全能值的舍入，例如0.05：

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

我发现这很有用，因为我可以在代码中进行搜索并替换以更改“ round”（“ myround”（“”而不必更改参数值。

Answer 2

这只是扩展的问题

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

Answer 3

删除“静止”将有效：

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

如果值是acthy a acte a integer：

rounded = val - val % 5

作为一个函数：

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

Answer 4

def round_to_next5(n):
    return n + (5 - n) % 5

Answer 5

def round_up_to_base(x, base=10):
    return x + (-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]

for 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＆gt; = 3.7.9中测试

Answer 6

圆形（x [，n]）：值将圆形到最接近10的倍数n。因此，如果n为负...

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

由于10 = 5 * 2，则可以使用2个整数除法和乘法，而不是float Disemant和5.0乘法。这并不重要，除非您喜欢一点变化

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

Answer 7

抱歉，我想对Alok Singhai的答案发表评论，但是由于缺乏声誉=/

无论如何，我们可以再概括一个步骤并走了：

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

这允许我们使用非企业基础，例如 .25 或任何其他分数碱基。

Answer 8

使用：

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

Answer 9

Divround的修改版:-)

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

Answer 10

另一种做到这一点的方法（没有明确的乘法或划分运算符）：

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

Answer 11

如果有人需要“财务圆形”（总是0.5回合）：

from decimal import ROUND_HALF_UP, Decimal, localcontext

def myround(x, base: int = 5):
    # starting with Python 3.11:
    # with localcontext(rounding=decimal.ROUND_HALF_UP):
    with localcontext() as ctx:
        ctx.rounding = ROUND_HALF_UP
        return base * int(decimal.Decimal(x / base).quantize(Decimal('0')))

按文档圆形选项为：

• round_ceiling （to infinity ）
• round_down （to Zero）
• round> round_floor （to -Infinity ）
• round_half_down （到最接近零的关系）
• round_half_even （到最接近的纽带，均为最接近整数）
• round_half_up （到距离零的领带最接近）
• round_up （远离零）
• round_05up 是0或5;

默认情况下，python

Answer 12

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

Answer 13

我想没有人真正写过这篇文章，但是您可以做：

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

Answer 14

5 的下一个倍数

考虑51需要转换为55：

code here

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

Answer 15

那呢：

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

Answer 16

我需要将前5个。

示例16回合降至15或19发，降至15，

这是所使用的代码

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

Answer 17

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

Answer 18

接受的答案的补充，以指定舍入或下到最接近的5左右

import math

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

Answer 19

一种仅适用于 int s的解决方案（它接受 float s，但是圆形的行为就像小数组件不存在），但是与任何依赖临时的解决方案不同转换为 float （所有 Math.floor / Math.ceil 基于基于的解决方案，使用/的所有解决方案，大多数使用 rough ）的解决方案，它适用于任意巨大的 int 输入，永不失去精度，永不提高异常或导致无穷大值。

这是最简单的解决方案 down 到一个数字的下一个次数：

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

它基于的圆形配方仅仅是：

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

唯一的更改是，您提前将基础添加到数字中，因此它圆形到最接近。使用确切的中点值，只有使用 base s，因此， round_to_nearest（3，6）才能围绕 6 而不是<代码> 0 ，而 round_to_nearest（-3，6）将得到 0 而不是 -6 。如果您更喜欢中点值，则可以将第一行更改为 num +=（base -1）// 2 。

Answer 20

from math import isclose

def myPrice (p1,p2):
    return isclose(p1, p2, rel_tol=0.05)

print(myPrice(50.10,50.20)) 

要设置5％的公差，请通过rel_tol = 0.05。默认公差为1E-09

Answer 21

我发现这比 @mkrieger1和@alok singhal的答案要慢得多，但它更明确地说明了圆形行为，并且更易于修改或扩展。

def round_up_to_5(num):
    rounded_num = math.ceil(num / 5) * 5
    return int(rounded_num)

Answer 22

您可以“技巧” int（）进行四舍五入
您传递给 int（）的号码。

Answer 23

我不知道Python中的标准功能，但这对我来说有用：

Python 3

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

很容易理解上述原因。您要确保您的电话号码除以5是一个整数，正确圆形。因此，我们首先做到这一点（回合（x/5）），然后自从我们除以5，我们也乘以5。

我通过给出 base 参数，默认为5。python

2

在Python 2中， float（x）将需要使用 python 2，从而 使该功能更加通用。 /确实需要浮点线，并且需要最终转换为 int ，因为 round（）返回Python 2中的浮点值。

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