Question

是否可以将数值分配给变量，使其限制在某个范围内？更具体地说，我想要一个永远不会低于零的变量，因为如果这种情况即将发生，则会引发异常。

虚构的例子：

>>> var = AlwaysPositive(0)
>>> print var 
0
>>> var += 3
>>> print var 
3
>>> var -= 4 
Traceback (most recent call last):   
   File "<stdin>", line 1, in <module> 
AlwaysPositiveError: dropping AlwaysPositive integer below zero

我问的原因是因为我正在调试我正在写的游戏。在人类隐含理解的情况下，你手中永远不会有-1张牌，而计算机却没有。我可以创建检查游戏中使用的所有值的函数，并在整个脚本中的多个位置调用这些函数，看看是否出现任何奇怪的值。但我想知道是否有更简单的方法可以做到这一点？

Answer 1

如果你真的需要，子类化int可能是最好的方法，但到目前为止显示的实现是天真的。我愿意：

class NegativeValueError(ValueError):
    pass


class PositiveInteger(int):

    def __new__(cls, value, base=10):
        if isinstance(value, basestring):
            inst = int.__new__(cls, value, base)
        else:
            inst = int.__new__(cls, value)
        if inst < 0:
            raise NegativeValueError()
        return inst

    def __repr__(self):
        return "PositiveInteger({})".format(int.__repr__(self))

    def __add__(self, other):
        return PositiveInteger(int.__add__(self, other))

    # ... implement other numeric type methods (__sub__, __mul__, etc.)

这使您可以像常规PositiveInteger一样构建int：

>>> PositiveInteger("FFF", 16)
PositiveInteger(4095)
>>> PositiveInteger(5)
PositiveInteger(5)
>>> PositiveInteger(-5)

Traceback (most recent call last):
  File "<pyshell#24>", line 1, in <module>
    PositiveInteger(-5)
  File "<pyshell#17>", line 8, in __new__
    raise NegativeValueError()
NegativeValueError

参见例如the datamodel docs on numeric type emulation了解您需要实施的方法的详细信息。请注意，您无需在大多数方法中明确检查负数，例如return PositiveInteger(...) __new__将为您执行此操作。使用中：

>>> i = PositiveInteger(5)
>>> i + 3
PositiveInteger(8)

或者，如果这些非负整数将是类的属性，则可以使用descriptor protocol强制执行正值，例如：

class PositiveIntegerAttribute(object):

    def __init__(self, name):
        self.name = name

    def __get__(self, obj, typ=None):
        return getattr(obj, self.name)

    def __set__(self, obj, val):
        if not isinstance(val, (int, long)):
            raise TypeError()
        if val < 0:
            raise NegativeValueError()
        setattr(obj, self.name, val)

    def __delete__(self, obj):
        delattr(obj, self.name)

然后您可以按如下方式使用它：

>>> class Test(object):
    foo = PositiveIntegerAttribute('_foo')


>>> t = Test()
>>> t.foo = 1
>>> t.foo = -1

Traceback (most recent call last):
  File "<pyshell#34>", line 1, in <module>
    t.foo = -1
  File "<pyshell#28>", line 13, in __set__
    raise NegativeValueError()
NegativeValueError
>>> t.foo += 3
>>> t.foo
4
>>> t.foo -= 5

Traceback (most recent call last):
  File "<pyshell#37>", line 1, in <module>
    t.foo -= 5
  File "<pyshell#28>", line 13, in __set__
    raise NegativeValueError()
NegativeValueError

Answer 2

您可以从int继承自己的数据类型，并为其提供a bunch of magic methods重载您需要的运算符。

class Alwayspositive(int):
    def __init__(self, *args, **kwargs):
        super(Alwayspositive, self).__init__(*args, **kwargs)

    def __neg__(self):
        raise AlwayspositiveError()

    def __sub__(self, other):
        result = super(Alwayspositive, self).__sub__(other)
        if result < 0:
            raise AlwayspositiveError()
        return result

等等。这是一个相当多的工作和调试，以使这样的类安全，但它将允许您调试代码在调试和发布模式之间进行很少的更改。

价值永远不会低于零

2 个答案: