Python子类元组对象能够在内部重新实例化自身

Question

我理解Python中可变对象与不可变对象的概念，没问题。虽然任何不可变对象的内在值都不能直接修改，但不可变对象的任何实例都可以使用不同的值重新实例化。我想做的是在元组的子类上构建一个内部函数，它可以以受控的方式重新分配它自己的值。这可能是我似乎找不到的基本功能，希望得到任何帮助。

例如，这是我想要做的，但这显然行不通。

class myTuple(tuple):
    def __new__(self):
        initialValue = [1, 2, 3]
        return super(myTuple, self).__new__(self, initialValue)
    def resetMyself(self):
        newValue = [4, 5, 6]
        self = tuple(newValue)

结果如下...

>>> foo = myTuple()
>>> print foo
(1, 2, 3)
>>> foo.resetMyself()
>>> print foo
(4, 5, 6)

通过阅读本网站上对此类问题的大量回复，我知道你们中的一些人可能倾向于回答“您为什么要这样做？”但让我们用更直接的答案来节省回答空间，包括可能的“你不可能这样做，也不可能”，如果情况确实如此的话。

非常感谢大家！

编辑，感谢下面的答案，这就是我的最终结果...

class semiImmutableList(list):
    def __setitem__(self, *args):
        raise TypeError("'semiImmutableList' object doesn't support item assignment")
    __setslice__ = __setitem__
    def __delitem__(self, *args):
        raise TypeError("'semiImmutableList' object doesn't support item deletion")
    __delslice__ = __delitem__
    def append(self, *args):
        raise AttributeError("'semiImmutableList' object has no attribute 'append'")
    def extend(self, *args):
        raise AttributeError("'semiImmutableList' object has no attribute 'extend'")
    def insert(self, *args):
        raise AttributeError("'semiImmutableList' object has no attribute 'insert'")
    def remove(self, *args):
        raise AttributeError("'semiImmutableList' object has no attribute 'remove'")
    def pop(self, *args):
        raise AttributeError("'semiImmutableList' object has no attribute 'pop'")
    def __init__(self):
        x = [1, 2, 3]
        super(semiImmutableList, self).__init__(x)
    def resetMyself(self):
        super(semiImmutableList,self).append(5)

您可以看到的对上述内容的任何改进/调整，请发布。似乎 AttributeError 引发的重复可以合并？

Answer 1

如果您想要可变元组，请使用列表。

编辑：

试试这个

class FrankenList(object):
    def __init__(self, init=None):
        self.__data = init or []

    def __getitem__(self, key):
        return self.__data[key]

    def __repr__(self):
        return repr(self.__data)

    def __str__(self):
        return str(self.__data)

Answer 2

很简单，您所要做的就是包装一个列表。

class ImmutableList(object):
    def __init__(self, *args):
        self.__values = args; # internally we store the values in a list

    # make imuList[0] = 2 raise an error, just like a tuple would
    def __setitem__(self, index, value):
        raise TypeError('ImmutableList does not support item assignment')

    # del imuList[0] should also raise
    def __delitem__(self, index, value):
        raise TypeError('ImmutableList does not support item deletion')**

    # make our imuList indexable, also catch the normal index error and raise one
    # that tells that this is an immutable list, will make it easier to debug :)
    def __getitem__(self, index):
        try:
            return self.__values[index]

        except IndexError:
            raise IndexError('ImmutableList index out of range')

    # the usual stuff
    def __repr__(self):
        return repr(self.__values)

    def __str__(self):
        return str(self.__values)

# create a new imulist
e = ImmutableList(1, 2, 3, 4)

# works!
print e[0]

# raises an error
e[0] = 5

# raises another error
print e[9]

现在您所要做的就是修改类内的 self._values 。最后一个建议，仍然有可能从外部弄乱 self._values，因为 Python 不支持 私有成员。

您可以通过直接从列表子类化来采取进一步措施来防止对 __values 的操作，但这需要更多工作，而且仍然可以使用 list.__setitem__(imListInstance, 0, 5 ）等等。