Question

首先，我想提一下这个问题不是重复：

我知道IEEE 754，我知道：

简单＆＃34;总是圆0.5上＆＃34;技术导致略微偏向更高的数字。通过大量计算，这可能很重要。 Python 3.0方法消除了这个问题。

我同意ROUND_HALF_UP是默认情况下在Python中实现的方法。然而，有些人不知道这一点，如果规格要求，则需要使用该方法。简单的方法是：

def round_my(num, precission):
    exp  = 2*10**(-precission)
    temp = num * exp
    if temp%2 < 1:
        return int(temp - temp%2)/exp
    else:
        return int(temp - temp%2 + 2)/exp

但我的考虑是这不是Pythonic ...根据docs我应该使用类似的东西：

def round_my(num, pricission):
    N_PLACES = Decimal(10) ** pricission       # same as Decimal('0.01')
    # Round to n places
    Decimal(num).quantize(N_PLACES)

问题是这不会通过所有测试用例：

class myRound(unittest.TestCase):
    def test_1(self):
        self.assertEqual(piotrSQL.round_my(1.53, -1), 1.5)
        self.assertEqual(piotrSQL.round_my(1.55, -1), 1.6)
        self.assertEqual(piotrSQL.round_my(1.63, -1), 1.6)
        self.assertEqual(piotrSQL.round_my(1.65, -1), 1.7)
        self.assertEqual(piotrSQL.round_my(1.53, -2), 1.53)
        self.assertEqual(piotrSQL.round_my(1.53, -3), 1.53)
        self.assertEqual(piotrSQL.round_my(1.53,  0), 2)
        self.assertEqual(piotrSQL.round_my(1.53,  1), 0)
        self.assertEqual(piotrSQL.round_my(15.3,  1), 20)
        self.assertEqual(piotrSQL.round_my(157.3,  2), 200)

由于float和decimal之间转换的性质，并且因为量化似乎不适用于像10或100这样的指数。是否有Pythonic方法来执行此操作？

而且我知道我可以添加无限小的数字，而round(num+10**(precission-20),-pricission)会起作用，但这是错误的，＃34;小狗会死的＆＃34; ...

Answer 1

正如您所说，如果您尝试使用大于1的数字quantize，则无效：

>>> Decimal('1.5').quantize(Decimal('10'))
Decimal('2')
>>> Decimal('1.5').quantize(Decimal('100'))
Decimal('2')

但你可以简单地划分，量化和乘法：

from decimal import Decimal, ROUND_HALF_UP

def round_my(num, precision):
    N_PLACES = Decimal(10) ** precision
    # Round to n places
    return (Decimal(num) / N_PLACES).quantize(1, ROUND_HALF_UP) * N_PLACES

但是，如果您输入Decimal并与Decimal进行比较，则只会通过测试：

assert round_my('1.53', -1) == Decimal('1.5')
assert round_my('1.55', -1) == Decimal('1.6')
assert round_my('1.63', -1) == Decimal('1.6')
assert round_my('1.65', -1) == Decimal('1.7')
assert round_my('1.53', -2) == Decimal('1.53')
assert round_my('1.53', -3) == Decimal('1.53')
assert round_my('1.53',  0) == Decimal('2')
assert round_my('1.53',  1) == Decimal('0')
assert round_my('15.3',  1) == Decimal('20')
assert round_my('157.3',  2) == Decimal('200')

如评论中所述，可以使用科学记数法小数作为＆＃34;工作＆＃34;量化参数，简化了函数：

def round_my(num, precision):
    quant_level = Decimal('1e{}'.format(precision))
    return Decimal(num).quantize(quant_level, ROUND_HALF_UP)

这也通过了上述测试用例。

Answer 2

以下是与内置round()函数的行为和API相匹配的版本：

from decimal import Decimal, ROUND_HALF_UP

def round_half_up(number, ndigits=None):
    return_type = type(number)
    if ndigits is None:
        ndigits = 0
        return_type = int
    if not isinstance(ndigits, int):
        msg = f"'{type(ndigits).__name__}' object cannot be interpreted as an integer"
        raise TypeError(msg)
    quant_level = Decimal(f"10E{-ndigits}")
    return return_type(Decimal(number).quantize(quant_level, ROUND_HALF_UP))

以任意精度浮点数到ROUND_HALF_UP的Pythonic方式

2 个答案: