如果你使用 p3。

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

If you need (for example) a two digit approximation for A, then int(A*100+0.5)/100.0 will do what you are looking for.

如果你需要三位数的近似数乘数,并按千分之数。

这样做也是有益的。

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位数的平均值,其依据是正确的方法,与数值的双位调整无关。 采用适当的算法。 高级科学班和统计班教授这一点。 但为什么如此?

尽量减少累积错误!

值四舍五入时,你对该术语采用了错误值。 如果你把各种价值观聚集在一起,你总是把价值提升到[即×+1]的×500......,那么你就会对你的错误积累产生固有的偏见。

在一组N号中,其中M号为x500......,一个圆形方法将引入一个加维差级,即M级,即你四舍五入的0.5位数。

然而,如果你总是四舍五入,那么你就会有expectation<>em>,其中一半的错误术语为+ve,一半为-ve。 因此,你有expecatation,即他们将取消你与M等词的净零差。 error error error error whole whole

但是,这种净误差只是expectation。 当你考虑放弃“fair”硬币(一个类似的问题),即“heads” = +1和“tails”=-1, M倍,并加上所有单壳的总和时,就会出现一种结果的统计期望,但“wander”从0(可以是+ve 还是-ve)到来的程度一般都受到rt(M)的约束,或者它是否标志? 在相当一段时间里,打着打碎了一本统计书。 实际答案(rt或 log)与这一问题无关,因为rt和 log(M)都小于M;1 。

因此,由于涉及我们的数字假设情景,即X500......的M值,因为M是无限的,我们有expectation,即这些M值的错误术语为零,但我们还有一个更强大的expectation,即这一错误术语的规模应当受你四舍五入的0.5位数的约束。

页: 1 页: 1

是的,你可以有病理,你最终将M *0.5归为后,但这种假想应当是一种外观而不是常规,而这种少见的外消作用不会比“双向走”办法更糟。

In the correct answer mentioned in this does not work if I use 79.5. It gives an answer of 710, not 80.

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

上文提及的法典取得了更好的成果。

我使用并可能提出以下解决办法(第3页):

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

它对半年数(正数和负数)进行罚款,并比(四)点更快地工作:

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

This one is tricky, to be honest. There are many simple ways to do this nevertheless. Using math.ceil(), round(), and math.floor(), you can get a integer by using for example:

n = int(round(n))

如果我们在使用这一功能之前,<代码>n = 5.23,我们就会收到<代码>5。 如果你想要四舍五入到不同地点,你就可以利用这一功能:

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

If we used n (5.23) again, round it to the nearest tenth, and print the answer to the console, our code would be:

Round(5.23,1)

哪些将返回<代码>5.2。 最后,如果你想要把东西四舍五入到最接近的1.2条,你可以使用:

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

If we wanted n to be rounded to 1.2, our code would be:

print(Round(n,1.2))

我们的结果:

4.8

谢谢! 如果有任何问题,请补充评论: (Happy Days!)

用于四舍五入到最接近点数的圆点,使用 n:

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

页: 1

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

为此,我只建议:

int(round(x))

这将给你带来最接近的愤怒。

希望!