Question

这将是我的第一个问题。我试图创建一个decimal.Decimal子类，它主要通过对自身进行自动规范化以及返回Decimal对象的可调用参数的结果来区分父对象。下面的代码有概念装饰Decimal的所有方法以返回MyDecimal实例（其创建时其字符串结尾的修剪零点）而不是decimal.Decimals。为此，使用了元类。

但是，我觉得这段代码有点hacky。此外，根据速度测试结果，它也很慢：十进制为2.5秒。对于我系统上的MyDecimal，十六分为16秒。

我的问题是：是否有更清洁（更快）的方法？

import decimal

class AutoNormalizedDecimal(type):
    def __new__(cls, name, bases, local):
        local_items = list(local.items())
        parent_items = [i for i in bases[0].__dict__.items()
            if i[0] not in local.keys()]
        for a in local_items + parent_items:
            attr_name, attr_value = a[0], a[1]
            if callable(attr_value):
                local[attr_name] = cls.decorator(attr_value)
        return super(AutoNormalizedDecimal, cls).__new__(
            cls, name, bases, local)

    @classmethod
    def decorator(cls, func):
        def wrapper_for_new(*args, **kwargs):
            new_string = args[1].rstrip('0').rstrip('.')
            if not new_string:
                new_string = '0'
            newargs = (args[0], new_string)
            return func(*newargs, **kwargs)
        def wrapper(*args, **kwargs):
            result = func(*args, **kwargs)
            if (isinstance(result, decimal.Decimal)
                and not isinstance(result, MyDecimal)):
                return MyDecimal(str(result))
            return result
        if func.__name__ == '__new__':
            return wrapper_for_new
        return wrapper

class MyDecimal(decimal.Decimal, metaclass=AutoNormalizedDecimal):
    def __str__(self):
        return decimal.Decimal.__str__(self).replace('.', ',') 

n = MyDecimal('-5423.5420000')

def speedtest():
    import time
    start = time.time()
    d = decimal.Decimal('6')
    for i in range(1000000):
        d += decimal.Decimal(str(i))
    print(time.time()-start)

    start = time.time()
    d = MyDecimal('6')
    for i in range(1000000):
        d += MyDecimal(str(i))
    print(time.time()-start)

这是如何工作的：

>>> n
Decimal('-5423.542')
>>> type(n)
<class '__main__.MyDecimal'>
>>> str(n)
'-5423,542'
>>> x = MyDecimal('542.63') / MyDecimal('5.2331')
>>> x
Decimal('103.6918843515315969501824922')
>>> type(x)
<class '__main__.MyDecimal'>
>>> y = MyDecimal('5.5252') - MyDecimal('0.0052')
>>> y
Decimal('5.52')
>>> z = decimal.Decimal('5.5252') - decimal.Decimal('0.0052')
>>> z
Decimal('5.5200')

提前致谢！

PS：感谢Anurag Uniyal的代码让我有了一个开始的方式：https://stackoverflow.com/a/3468410/2334951

EDIT1：我出来重新定义as_tuple（）方法，我可以随时调用我需要修剪的Decimal版本：

class MyDecimal(decimal.Decimal):

    def as_tuple(self):
        sign, digits_, exponent = super().as_tuple()
        digits = list(digits_)
        while exponent < 0 and digits[-1] == 0:
            digits.pop()
            exponent += 1
        while len(digits) <= abs(exponent):
            digits.insert(0, 0)
        return decimal.DecimalTuple(sign, tuple(digits), exponent)

    def __str__(self):
        as_tuple = self.as_tuple()
        left = ''.join([str(d) for d in as_tuple[1][:as_tuple[2]]])
        right = ''.join([str(d) for d in as_tuple[1][as_tuple[2]:]])
        return ','.join((left, right))

很好的十进制。十进制自动规范化

0 个答案: