Python에서는 5(또는 다른 수)로 반올림

Python에서는 5(또는 다른 수)로 반올림

다음과 같이 반올림할 수 있는 기능이 내장되어 있습니까?

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

Python의 표준 함수는 모르지만, 이것은 나에게 효과가 있습니다.

파이썬 3

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

왜 위와 같은 일이 일어나는지 쉽게 알 수 있다.숫자를 5로 나눈 값이 올바르게 반올림된 정수인지 확인하려고 합니다.그래서 우리는 먼저 정확히 그렇게 합니다.round(x/5)5로 나누었으므로 5도 곱합니다.

이 기능을 보다 범용적으로 만들었습니다.base파라미터, 디폴트는 5 입니다.

파이썬 2

Python 2에서는float(x)을 확실히 하기 위해서 필요하다/부동소수점 나눗셈을 하고 최종 변환을 합니다.int필요하기 때문에round()Python 2에서 부동소수점 값을 반환합니다.

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

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

값이 aready 정수인 경우:

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

미안, 알록 싱하이의 답변에 대해 코멘트를 하고 싶었는데, 평판이 좋지 않아서 =/

어쨌든 한 단계 더 일반화하면 다음과 같이 할 수 있습니다.

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

이를 통해 다음과 같은 비정수 베이스를 사용할 수 있습니다..25다른 소수점 베이스도 마찬가지고요

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에서 테스트 완료

용도:

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

divround :-)의 수정 버전

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

정수 및 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]

재무 라운딩이 필요한 경우(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(Infinity 방향)
• ROUND_DOWN0)(점수 0)
• ROUND_FLOOR(방향 - 무한대)
• ROUND_HALF_DOWN를 향해 넥타이를 가진 가장 넥타이) ( the nearest tie with 0) (to nearly)
• ROUND_HALF_EVEN ties nearest integer) ( 가까운 짝수로 가는 넥타이 포함)
• ROUND_HALF_UP 가장 넥타이를 가진 에게) (To near with tie with aways the 제로
• ROUND_UP) (0에서 멀리)
• ROUND_05UP0 5일 을 향해, 0을 (0은 0을 향해 0을 향해 5를 향해 0을 향해), 0을 향해, 0을 향해, 0을 향해 0을 향해 반올림합니다.)

은 "Python"을 사용합니다.ROUND_HALF_EVEN일부 통계적 이점이 있기 때문이다(반올림된 결과는 편향되지 않음).

5의 다음 배수

51을 55로 변환해야 한다는 점을 고려합니다.

code here

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

이를 위한 또 다른 방법(명시적 곱셈 또는 나눗셈 연산자 없음):

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

나는 앞의 5까지 반올림해야 했다.

예 16에서 15로, 19에서 15로 라운딩

사용한 코드는 다음과 같습니다.

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

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

수락된 답변에 더하여, 가장 가까운 5개 또는 그 무엇으로 반올림 또는 반올림을 지정합니다.

import math

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

int(s)를 받아들입니다)float단, 하지 않는 단, s.로의 과는 달리, s.로의 일시적인 변환에 의존하는 솔루션과는 . 단, 임시 변환에 의존하는 솔루션과는 다릅니다.float)math.floor/math.ceil- 솔루션, 사용 - 반반 using 、 - using using using using using using using using using using/를 사용하는 .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)

유일하게 달라진 점은 미리 숫자의 절반을 더해서 가장 가까운 값으로 반올림하는 것입니다.값을 라도 사용할 수 .bases, "s", "s"round_to_nearest(3, 6)60와 동시에 , 「」를 참조해 주세요.round_to_nearest(-3, 6)0-6 값을는 첫 을 반올림하다로 할 수 num += (base - 1) // 2.

꼼수'를 할 수 int() 0.5int().

언급URL : https://stackoverflow.com/questions/2272149/round-to-5-or-other-number-in-python