虽然我从来都不需要这样做，但我突然意识到用Python创建一个不可变对象可能有点棘手。你不能只是覆盖__setattr__，因为这样你甚至不能在__init__中设置属性。子类化一个元组是一个有效的技巧:
class Immutable(tuple):
def __new__(cls, a, b):
return tuple.__new__(cls, (a, b))
@property
def a(self):
return self[0]
@property
def b(self):
return self[1]
def __str__(self):
return "<Immutable {0}, {1}>".format(self.a, self.b)
def __setattr__(self, *ignored):
raise NotImplementedError
def __delattr__(self, *ignored):
raise NotImplementedError
但是你可以通过self[0]和self[1]访问a和b变量，这很烦人。
这在Pure Python中可行吗?如果不是，我该如何用C扩展来做呢?
(只能在python3中工作的答案是可以接受的)。
更新:
从Python 3.7开始，要使用的方法是使用@dataclass装饰器，参见最新接受的答案。
从Python 3.7开始，你可以在你的类中使用@dataclass装饰器，它将像结构体一样是不可变的!不过，它可能会也可能不会将__hash__()方法添加到类中。引用:
hash() is used by built-in hash(), and when objects are added to hashed collections such as dictionaries and sets. Having a hash() implies that instances of the class are immutable. Mutability is a complicated property that depends on the programmer’s intent, the existence and behavior of eq(), and the values of the eq and frozen flags in the dataclass() decorator.
By default, dataclass() will not implicitly add a hash() method unless it is safe to do so. Neither will it add or change an existing explicitly defined hash() method. Setting the class attribute hash = None has a specific meaning to Python, as described in the hash() documentation.
If hash() is not explicit defined, or if it is set to None, then dataclass() may add an implicit hash() method. Although not recommended, you can force dataclass() to create a hash() method with unsafe_hash=True. This might be the case if your class is logically immutable but can nonetheless be mutated. This is a specialized use case and should be considered carefully.
下面是上面链接的文档中的例子:
@dataclass
class InventoryItem:
'''Class for keeping track of an item in inventory.'''
name: str
unit_price: float
quantity_on_hand: int = 0
def total_cost(self) -> float:
return self.unit_price * self.quantity_on_hand
另一个想法是完全不允许__setattr__而使用object。构造函数中的__setattr__:
class Point(object):
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
当然你可以用object。__setattr__(p， "x"， 3)来修改一个Point实例p，但您的原始实现遭受同样的问题(尝试tuple。__setattr__(i， "x"， 42)在一个不可变实例)。
您可以在原始实现中应用相同的技巧:去掉__getitem__()，并在属性函数中使用tuple.__getitem__()。
这种方式不停止对象。__setattr__从工作，但我仍然发现它有用:
class A(object):
def __new__(cls, children, *args, **kwargs):
self = super(A, cls).__new__(cls)
self._frozen = False # allow mutation from here to end of __init__
# other stuff you need to do in __new__ goes here
return self
def __init__(self, *args, **kwargs):
super(A, self).__init__()
self._frozen = True # prevent future mutation
def __setattr__(self, name, value):
# need to special case setting _frozen.
if name != '_frozen' and self._frozen:
raise TypeError('Instances are immutable.')
else:
super(A, self).__setattr__(name, value)
def __delattr__(self, name):
if self._frozen:
raise TypeError('Instances are immutable.')
else:
super(A, self).__delattr__(name)
你可能需要根据用例重写更多的东西(比如__setitem__)。
下面的基本解决方案针对以下场景:
__init__()可以像往常一样访问属性。
在此之后，对象仅冻结属性更改:
其思想是覆盖__setattr__方法，并在每次对象冻结状态改变时替换其实现。
因此，我们需要一些方法(_freeze)来存储这两个实现，并在请求时在它们之间切换。
这个机制可以在用户类内部实现，也可以从一个特殊的freeze类继承，如下所示:
class Freezer:
def _freeze(self, do_freeze=True):
def raise_sa(*args):
raise AttributeError("Attributes are frozen and can not be changed!")
super().__setattr__('_active_setattr', (super().__setattr__, raise_sa)[do_freeze])
def __setattr__(self, key, value):
return self._active_setattr(key, value)
class A(Freezer):
def __init__(self):
self._freeze(False)
self.x = 10
self._freeze()
我通过重写__setattr__创建了不可变类，并且如果调用者是__init__，则允许该集合:
import inspect
class Immutable(object):
def __setattr__(self, name, value):
if inspect.stack()[2][3] != "__init__":
raise Exception("Can't mutate an Immutable: self.%s = %r" % (name, value))
object.__setattr__(self, name, value)
这还不够，因为它允许任何人的___init__来改变对象，但你懂的。
