가장 가까운 정수로 반올림

가장 가까운 정수로 반올림

나는 다음과 같은 긴 부동 소수점들을 반올림하려고 노력해왔다:

32.268907563;
32.268907563;
31.2396694215;
33.6206896552;
...

이치노는 는 i i는노노 i i i i i.math.ceil(x),math.floor(x) 있는 것은 ) 및 (그것은 가 찾고 있는 것이 )round(x)이데올로기 때문에

내가 뭘 할 수 있을까?

코드:

for i in widthRange:
    for j in heightRange:
        r, g, b = rgb_im.getpixel((i, j))
        h, s, v = colorsys.rgb_to_hsv(r/255.0, g/255.0, b/255.0)
        h = h * 360
        int(round(h))
        print(h)

TL;DR:

round(x)

반올림하여 정수로 변경합니다.

.round(h)모든 변수에 대응합니다.했을 때round(h)、 되지만 다른은 수행되지 않습니다.이은 다음해야 합니다.이 노래에 대해서

h = round(h)

h.

---

@의 @plowman은 Python의 @plowman입니다.round()보통 예상대로 동작하지 않습니다.숫자가 변수로 저장되는 방식은 보통 화면에서 보는 방식이 아니기 때문입니다.이 행동을 설명하는 많은 답이 있습니다.

이 문제를 회피하는 한 가지 방법은 이 답변에 기재된 10진수를 사용하는 것입니다.

이 답변이 추가 라이브러리를 사용하지 않고 올바르게 작동하려면 커스텀 반올림 기능을 사용하면 편리합니다.테스트한 결과, 보관에 관한 모든 문제를 회피할 수 있는 다음과 같은 솔루션을 생각해 냈습니다.으로 하고 .repr()(★★★★★★★★★★★★★★★)str()할 수 이었다.Python2 3 Python3 。

def proper_round(num, dec=0):
    num = str(num)[:str(num).index('.')+dec+2]
    if num[-1]>='5':
        return float(num[:-2-(not dec)]+str(int(num[-2-(not dec)])+1))
    return float(num[:-1])

테스트:

>>> print(proper_round(1.0005,3))
1.001
>>> print(proper_round(2.0005,3))
2.001
>>> print(proper_round(3.0005,3))
3.001
>>> print(proper_round(4.0005,3))
4.001
>>> print(proper_round(5.0005,3))
5.001
>>> print(proper_round(1.005,2))
1.01
>>> print(proper_round(2.005,2))
2.01
>>> print(proper_round(3.005,2))
3.01
>>> print(proper_round(4.005,2))
4.01
>>> print(proper_round(5.005,2))
5.01
>>> print(proper_round(1.05,1))
1.1
>>> print(proper_round(2.05,1))
2.1
>>> print(proper_round(3.05,1))
3.1
>>> print(proper_round(4.05,1))
4.1
>>> print(proper_round(5.05,1))
5.1
>>> print(proper_round(1.5))
2.0
>>> print(proper_round(2.5))
3.0
>>> print(proper_round(3.5))
4.0
>>> print(proper_round(4.5))
5.0
>>> print(proper_round(5.5))
6.0
>>> 
>>> print(proper_round(1.000499999999,3))
1.0
>>> print(proper_round(2.000499999999,3))
2.0
>>> print(proper_round(3.000499999999,3))
3.0
>>> print(proper_round(4.000499999999,3))
4.0
>>> print(proper_round(5.000499999999,3))
5.0
>>> print(proper_round(1.00499999999,2))
1.0
>>> print(proper_round(2.00499999999,2))
2.0
>>> print(proper_round(3.00499999999,2))
3.0
>>> print(proper_round(4.00499999999,2))
4.0
>>> print(proper_round(5.00499999999,2))
5.0
>>> print(proper_round(1.0499999999,1))
1.0
>>> print(proper_round(2.0499999999,1))
2.0
>>> print(proper_round(3.0499999999,1))
3.0
>>> print(proper_round(4.0499999999,1))
4.0
>>> print(proper_round(5.0499999999,1))
5.0
>>> print(proper_round(1.499999999))
1.0
>>> print(proper_round(2.499999999))
2.0
>>> print(proper_round(3.499999999))
3.0
>>> print(proper_round(4.499999999))
4.0
>>> print(proper_round(5.499999999))
5.0

마지막으로 수정된 답변은 다음과 같습니다.

# Having proper_round defined as previously stated
h = int(proper_round(h))

---

테스트:

>>> proper_round(6.39764125, 2)
6.31 # should be 6.4
>>> proper_round(6.9764125, 1)
6.1  # should be 7

여기서 중요한 건 그 사람이dec- 이하에는 할 수 , -가 9일 ,dec+1, 은 - 아, > = 5 아, 9 아, 0 이 .dec-1- - 자릿수.

이 점을 고려한다면 다음과 같은 이점이 있습니다.

def proper_round(num, dec=0):
    num = str(num)[:str(num).index('.')+dec+2]
    if num[-1]>='5':
      a = num[:-2-(not dec)]       # integer part
      b = int(num[-2-(not dec)])+1 # decimal part
      return float(a)+b**(-dec+1) if a and b == 10 else float(a+str(b))
    return float(num[:-1])

b = 10은 그냥 되었습니다.a ★★★★★★★★★★★★★★★★★」b, 그, which, which, 의, 의, which, which, which, which, which, which, which, which, which, which, which, which, which, which100으로 하다은 " " "를 변환합니다.b 이하 dec

round(x, y)원하는 소수점 이하 자리까지 숫자를 반올림합니다.

예를 들어 다음과 같습니다.

>>> round(32.268907563, 3)
32.269

round(value,significantDigit)만, 은, 「의 값이 「반올림」으로 끝나는 , .5의 .5 바로 값이 반올림된 값).이러한 값은 예상대로 반올림되는 경우가 있습니다(예:8.005 이하 에서는 「」가 됩니다.8.01부동 소수점 산술의 변덕으로 인한 특정 값의 경우, 대신 반올림됩니다.

예.

>>> round(1.0005,3)
1.0
>>> round(2.0005,3)
2.001
>>> round(3.0005,3)
3.001
>>> round(4.0005,3)
4.0
>>> round(1.005,2)
1.0
>>> round(5.005,2)
5.0
>>> round(6.005,2)
6.0
>>> round(7.005,2)
7.0
>>> round(3.005,2)
3.0
>>> round(8.005,2)
8.01

이상하다.

을 하는 하면, 은 과학 통계의 반올림을 할 때 입니다.round대로 import stuff extra extra extra extra extra extra 등 여분의 것Decimal.

>>> round(0.075,2)

0.07

>>> round(0.075+10**(-2*5),2)

0.08

아! 그럼 이걸 바탕으로 함수를 만들 수 있어...

def roundTraditional(val,digits):
   return round(val+10**(-len(str(val))-1), digits)

하는 값이 됩니다.round 그 절약된다.round, 가 반올림된 하면서, 의 은 다음과 같습니다.5하여 '반올림4올림합합니니다

★★★의 10**(-len(val)-1)할 수 또, 「」, 「」, 「」가 되어도, 추가하는 이 반올림 되지 합니다.., 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아...10**(-len(val))if (val>1)1 더... 더... 빼는 것이 더 간단합니다.1이 회피책으로 적절히 처리할 수 있는 10진수의 적용범위는 크게 변경되지 않습니다.이 접근법은 값이 유형의 제한에 도달하면 실패하지만 유효한 10진수 값의 거의 모든 범위에 대해 작동합니다.

이를 위해 10진 라이브러리를 사용할 수도 있지만 제안하는 래퍼가 더 단순하고 경우에 따라 선호될 수 있습니다.

---

편집: Blcknight가 지적해 주셔서 감사합니다.5프린지 대소문자는 특정 값에 대해서만 발생합니다.또, 이 회답의 이전 버전에서는, 반올림하고 있는 자리수보다 바로 아래의 자리수에 가 있는 경우에만 홀수 반올림 동작이 발생할 정도로 명확하지 않습니다.

긍정의 경우는, 시험해 주세요.

int(x + 0.5)

네거티브에도 효과가 있게 하려면

int(x + (0.5 if x > 0 else -0.5))

int()플로어 기능처럼 기능하기 때문에 이 속성을 이용할 수 있습니다.★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

Python만 IEEE 754에서 규정하는 대로 반반대반으로 하고 있지 않습니까?

재정의하거나 "비표준" 반올림 사용 시 주의하시기 바랍니다.

(https://stackoverflow.com/a/33019948/109839)도 참조).

솔루션이 두 번째 인수(소수 자릿수)를 지정하지 않고 반올림을 호출하고 있습니다.

>>> round(0.44)
0
>>> round(0.64)
1

이것은 보다 훨씬 더 나은 결과이다.

>>> int(round(0.44, 2))
0
>>> int(round(0.64, 2))
0

Python 문서(https://docs.python.org/3/library/functions.html#round에서 참조)

round(숫자[, ndigits])

소수점 뒤의 n자리 정밀도로 반올림된 반환 숫자입니다.ndigits가 생략되거나 None일 경우 입력에 가장 가까운 정수를 반환합니다.

메모

플로트에 대한 round()의 동작은 놀라울 수 있습니다.예를 들어 round(2.675, 2)는 예상된 2.68이 아닌 2.67을 나타냅니다.이것은 버그가 아닙니다.대부분의 소수점이 플로트로 정확하게 표현되지 않기 때문입니다.부동 소수점 산술 참조:자세한 내용은 문제 및 제한사항을 참조하십시오.

python3.x 를 사용하고 있는 경우는, numpy 를 사용할 수도 있습니다.

import numpy as np
x = 2.3
print(np.rint(x))
>>> 2.0

를 들어 A의 2자리 합니다.int(A*100+0.5)/100.0을 사용법

세 자리 근사치가 필요한 경우 1000으로 곱하고 나누기 등을 합니다.

이런 것도 효과가 있을 거야

import numpy as np    

def proper_round(a):
    '''
    given any real number 'a' returns an integer closest to 'a'
    '''
    a_ceil = np.ceil(a)
    a_floor = np.floor(a)
    if np.abs(a_ceil - a) < np.abs(a_floor - a):
        return int(a_ceil)
    else:
        return int(a_floor)

x500을 반올림하는 이유는...'x' 자릿수의 짝수 값까지가 올바른 방법이며 값의 이진 표기와는 아무런 관련이 없습니다.이것은 '적절한' 알고리즘입니다.고급 과학 수업과 통계 수업이 이를 가르친다.하지만 왜 그럴까?

누적 오류 최소화!

값을 반올림하면 해당 항에 오차 값이 추가됩니다.대량의 값을 합산하고 항상 x500을 반올림하는 경우...[즉, x+1까지] 값을 올리면 오류 누적에 대한 고유한 편견이 생깁니다.

N개의 숫자 집합에서 M은 x500... 형식이며, 반올림 방법론은 반올림 대상 자릿수의 크기 M * 0.5의 +ve 오차항을 도입합니다.

그러나 항상 짝수로 반올림하는 경우 M 오차항의 절반은 +ve이고 절반은 -ve일 것으로 예상됩니다.그 때문에, 그 M항으로부터 순제로 에러를 남기는 것을 취소할 수 있습니다.0의 오차는 M*0.5의 오차보다 훨씬 낫지 않나요?

그러나 그 순 0 오류는 예상에 불과합니다."앞면" = +1 및 "뒷면" = -1, M번과 같은 "공정한" 동전(유사 문제)을 던지고 모든 플립의 합계를 합하면 0의 통계적 기대치가 있지만 0(+ve 또는 -ve일 수 있음)의 크기는 일반적으로 sqrt(M) 또는 log'(로그)에 의해 제한된다.꽤 오랫동안요.sqrt(M)와 log(M)는 모두 M보다 작기 때문에 실제 답변(sqrt 또는 log)은 이 질문과 무관합니다.

따라서 숫자 합계 시나리오와 관련되기 때문에 x500 형식의 M 값은 유한하기 때문에 M 값의 오차항은 0이 될 것으로 예상되지만 반올림할 자릿수의 sqrt(M) * 0.5에 의해 오차항의 크기가 제한되어야 한다는 훨씬 더 큰 기대를 가지고 있습니다.

0은 환상적이지만 예상되는 sqrt(M)*0.5는 보증된 M*0.5보다 훨씬 좋습니다.

네, M*0.5로 끝나는 병리학적 경우를 생각할 수 있지만 이러한 시나리오는 표준이 아니라 특이치여야 합니다. 그리고 이 드문 특이치는 "항상 반올림" 접근법보다 나쁘지 않습니다.

다음 솔루션(python 3.6)을 사용하고 있습니다.

y = int(x + (x % (1 if x >= 0 else -1)))

반수(양수 및 음수)에 대해서는 정상적으로 동작하며, int(round(x)보다 더 빨리 동작합니다.

round_methods = [lambda x: int(round(x)), 
                 lambda x: int(x + (x % (1 if x >= 0 else -1))),
                 lambda x: np.rint(x).astype(int),
                 lambda x: int(proper_round(x))]

for rm in round_methods:
    %timeit rm(112.5)
Out:
201 ns ± 3.96 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
159 ns ± 0.646 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
925 ns ± 7.66 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
1.18 µs ± 8.66 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

for rm in round_methods:
    print(rm(112.4), rm(112.5), rm(112.6))
    print(rm(-12.4), rm(-12.5), rm(-12.6))
    print('=' * 11)

Out:
112 112 113
-12 -12 -13
===========
112 113 113
-12 -13 -13
===========
112 112 113
-12 -12 -13
===========
112 113 113
-12 -13 -13
===========

이치노그럼에도 불구하고 이것을 하는 많은 간단한 방법들이 있다.「」를 사용합니다.math.ceil(),round() , , , , 입니다.math.floor() ' , 으면 안 돼요.integer예를 들어 다음과 같습니다.

n = int(round(n))

에 사용했을 n = 5.23 우리는 수 , get , ,리 , , 、 , 。5. 할 수 다른 자리 값으로 반올림하려면 다음 함수를 사용할 수 있습니다.

def Round(n,k):
  point = '%0.' + str(k) + 'f'
  if k == 0:
    return int(point % n)
  else:
    return float(point % n)

n )5.23 한 번,하면 다음과 됩니다이 코드는 다음과 같습니다.

Round(5.23,1)

★★★★★★★★★★★★★★★★★★」5.2마지막으로, 예를 들어 1.2와 같이 가장 가까운 값으로 반올림하고 싶은 경우는, 다음의 코드를 사용할 수 있습니다.

def Round(n,k):
    return k * round(n/k)

가 n1.2을 사용하다

print(Round(n,1.2))

결과는 다음과 같습니다.

4.8

감사해요!궁금하신 점 있으시면 댓글 달아주세요. :) (Happy Holidays! )

설명을 보려면 링크를 클릭하십시오.제 게시물에 링크된 글에는 코드와 사용법에 대한 모든 내용이 나와 있습니다.

https://kodify.net/python/math/truncate-decimals/

import math

def truncate(number, decimals=0):
    """
    Returns a value truncated to a specific number of decimal places.
    """
    if not isinstance(decimals, int):
        raise TypeError("decimal places must be an integer.")
    elif decimals < 0:
        raise ValueError("decimal places has to be 0 or more.")
    elif decimals == 0:
        return math.trunc(number)

    factor = 10.0 ** decimals
    return math.trunc(number * factor) / factor

이 정답은 79.5를 사용하면 작동하지 않습니다.정답은 80이 아니라 710입니다.

def proper_round(num, dec=0):
num= int(num*pow(10,dec+1))
lastDigit = (str(num))[-1]
num = int(num/10)
if lastDigit >='5':
    num+=1
return float(num/pow(10,dec))

위에 언급된 코드가 더 나은 결과를 제공합니다.

가장 가까운 int 번호로 반올림하려면 numpy를 사용합니다.

p=np.array([     430.15,      57.868,      70.697,      198.13])
p=np.round(p)

및 p:

array([        430,          58,          71,         198])

이 목적을 위해 저는 다음과 같이 하는 것을 제안합니다.

int(round(x))

그러면 가장 가까운 정수를 얻을 수 있습니다.

이게 도움이 됐으면 좋겠어!!

언급URL : https://stackoverflow.com/questions/31818050/round-number-to-nearest-integer