Python 中可以有弱引用的不可变对象

Question

几年来，我一直在继承tuple 或使用namedtuple，但现在我有一个用例，我需要一个可以用作弱引用的类。今天我学到了tuples don't support weak references。

还有其他方法可以在 Python 中创建具有固定属性集的不可变对象吗？我不需要元组的数字索引或可变宽度。

class SimpleThingWithMethods(object):
    def __init__(self, n, x):
        # I just need to store n and x as read-only attributes 
    ... ??? ...

---

我想这引发了一个显而易见的问题，即为什么不可变； “Pythonic”代码通常只是假设我们在这里都是成年人，如果有破坏类不变量的风险，没有人会进入一个类并弄乱它的值。就我而言，我在库中有一个类，我担心最终用户会意外修改对象。与我一起工作的人有时会对我的代码做出错误的假设并开始做我没想到的事情，所以如果他们不小心修改了我的代码，我可以引发错误会更干净。

我并不担心防弹的不变性；如果有人真的很邪恶，想去修改东西，好吧，好吧，他们靠自己。我只是想防止意外修改我的对象。

Answer 1

对参数（getter？）使用封装和抽象怎么样：

class SimpleThingWithMethods(object):
    def __init__(self, n, x):
        self._n = n
        self._x = x

    def x(self):
      return self._x

    def n(self):
      return self._n

    SimpleThingWithMethods(2,3).x()

=> 3

Answer 2

好吧，这不是一个很好的答案，但看起来我可以修改https://stackoverflow.com/a/4828492/44330 中的答案——基本上覆盖__setattr__ 和__delattr__ 以满足我的需求，至少可以防止意外修改。 （但不如子类化tuple）

class Point(object):
    __slots__ = ('x','y','__weakref__')
    def __init__(self, x, y):
        object.__setattr__(self, "x", x)
        object.__setattr__(self, "y", y)
    def __setattr__(self, *args):
        raise TypeError
    def __delattr__(self, *args):
        raise TypeError
    def __eq__(self, other):
        return self.x == other.x and self.y == other.y
    def __hash__(self):
        return self.x.__hash__() * 31 + self.y.__hash__()

实现@Elazar 的想法：

class Point(object):
    __slots__ = ('x','y','__weakref__')
    def __new__(cls, x, y):
        thing = object.__new__(cls) 
        object.__setattr__(thing, "x", x)
        object.__setattr__(thing, "y", y)
        return thing
    def __setattr__(self, *args):
        raise TypeError
    def __delattr__(self, *args):
        raise TypeError
    def __eq__(self, other):
        return self.x == other.x and self.y == other.y
    def __hash__(self):
        return self.x.__hash__() * 31 + self.y.__hash__()    

Answer 3

如果你不担心isinstance检查，可以加强你的回答：

def Point(x, y):
    class Point(object):
        __slots__ = ('x','y','__weakref__')
        def __setattr__(self, *args):
            raise TypeError
        def __delattr__(self, *args):
            raise TypeError
        def __eq__(self, other):
            return x == other.x and y == other.y
        def __hash__(self):
            return x.__hash__() * 31 + y.__hash__()
    p = Point()
    object.__setattr__(p, "x", x)
    object.__setattr__(p, "y", y)
    return p

我真的不推荐它（每次调用都会创建一个类！），只是想说明这种可能性。

也可以一直使用javascript，并提供将访问局部变量的__getattr__。但这也会减慢访问速度，除了创建。现在我们根本不需要这些插槽：

class MetaImmutable:
    def __setattr__(self, name, val):
        raise TypeError

def Point(x, y):
    class Point(object):
        __metaclass__ = MetaImmutable
        __slots__ = ('__weakref__',)
        def __getattr__(self, name):
            if name == 'x': return x
            if name == 'y': return y
            raise TypeError
        @property
        def x(self): return x
        @property
        def y(self): return y
        def __eq__(self, other):
            return x == other.x and y == other.y
        def __hash__(self):
            return x.__hash__() * 31 + y.__hash__()
    return Point()

测试一下：

>>> p = Point(1, 2)
>>> p.y
2
>>> p.z
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 7, in __getattr__
TypeError
>>> p.z = 5
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Point' object has no attribute 'z'
>>> object.__setattr__(p, 'z', 5)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Point' object has no attribute 'z'
>>> from weakref import ref
>>> ref(p)().x
1
>>> type(p).x = property(lambda self: 3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 4, in __setattr__
TypeError

最后，你仍然可以打破它：

>>> type.__setattr__(type(p), 'x', property(lambda self: 5))
>>> p.x
5

同样，这里不推荐任何内容。使用@Jasons 实现。