파이썬에서 반올림 5 (또는 다른 숫자)

다음과 같이 반올림 할 수있는 내장 함수가 있습니까?

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

파이썬의 표준 함수를 모르지만 이것은 저에게 효과적입니다.

파이썬 2

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

파이썬 3

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

위의 이유가 무엇인지 쉽게 알 수 있습니다. 숫자를 5로 나눈 값이 올바르게 반올림 된 정수인지 확인하려고합니다. 그래서, 우리는 먼저 정확히 (그렇게 round(float(x)/5)곳이 float우리는 5 곱셈, 그리고 우리가 5로 나눈 이후에만 Python2 필요하다)뿐만 아니라. 최종 전환 int은round() 은 Python 2에서 부동 소수점 값을 반환 입니다.

base매개 변수 를 제공하여 기본적으로 5 로 설정하여 함수를보다 일반적으로 만들었습니다 .

정수가 아닌 값 (예 : 0.05)으로 반올림하는 경우 :

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

매개 변수 값을 변경하지 않고도 검색을 수행하고 코드에서 "round ("를 "myround (")로 변경하기 때문에이 기능이 유용하다는 것을 알았습니다.

스케일링의 문제 일뿐입니다

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

'휴식'을 제거하면 효과가 있습니다.

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

값이 정수인 경우 정수 :

rounded = val - val % 5

기능으로서 :

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

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

round (x [, n]) : 값은 10의 거듭 제곱 n에 가장 가까운 배수로 반올림됩니다. 따라서 n이 음수이면 ...

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

10 = 5 * 2이므로 5.0으로 부동 나누기와 곱셈 대신 정수 나누기와 곱셈을 2로 사용할 수 있습니다. 비트 쉬프팅을 좋아하지 않는 한 그게 중요하지 않습니다.

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

죄송합니다, Alok Singhai의 답변에 댓글을 달고 싶지만 평판이 부족하여 = /

어쨌든, 우리는 한 단계 더 일반화하고 갈 수 있습니다.

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

이것은 우리가 정수가 아닌베이스, .25또는 다른 분수베이스 를 사용할 수있게 합니다.

divround의 수정 된 버전 :-)

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

사용하다:

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

누군가 "재무 반올림"이 필요한 경우 (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 (0에서 멀어짐).
ROUND_05UP (0으로 반올림 한 마지막 숫자가 0 또는 5이면 0에서 멀어짐, 그렇지 않으면 0으로)

기본적으로 파이썬은 ROUND_HALF_EVEN을 사용하는데 통계적인 장점이 있습니다 (반올림 된 결과는 바이어스되지 않습니다).

정수 및 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 divround(value, step):
     return divmod(value, step)[0] * step

5의 다음 배수

51을 55로 변환해야합니다.

code here

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

여기 내 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);
  }
}

이를 수행하는 또 다른 방법 (명시 적 곱셈 또는 나누기 연산자없이) :

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

전달하는 숫자를 int()더하여 반올림하는 대신 반올림하는 방법을 "트릭"할 수 있습니다 .0.5int()