Preventing the creation of new attributes outside __init__

Question

I want to be able to create a class (in Python) that, after initializing with __init__ does not accept new attributes, but accepts changes to existing attributes. There are several ways that I can see, for example, having the __setattr__ method, for example

 def __setattr__(self, attribute, value): if not attribute in self.__dict__: print "Cannot set %s" % attribute else: self.__dict__[attribute] = value 

and then editing __dict__ directly inside __init__ , but I was wondering if there is a “right” way to do this?

Answer 1

I would not use __dict__ directly, but you can add a function to explicitly freeze the instance:

 class FrozenClass(object): __isfrozen = False def __setattr__(self, key, value): if self.__isfrozen and not hasattr(self, key): raise TypeError( "%r is a frozen class" % self ) object.__setattr__(self, key, value) def _freeze(self): self.__isfrozen = True class Test(FrozenClass): def __init__(self): self.x = 42# self.y = 2**3 self._freeze() # no new attributes after this point. a,b = Test(), Test() ax = 10 bz = 10 # fails 

Answer 2

Actually you do not need __setattr__ , you want __slots__ . Add __slots__ = ('foo', 'bar', 'baz') to the class body, and Python will make sure that in any instance there are only foo, bar and baz. But read the reservations in the documentation lists!

Answer 3

If someone is interested in doing this with a decorator, here is a working solution:

 from functools import wraps def froze_it(cls): cls.__frozen = False def frozensetattr(self, key, value): if self.__frozen and not hasattr(self, key): print("Class {} is frozen. Cannot set {} = {}" .format(cls.__name__, key, value)) else: object.__setattr__(self, key, value) def init_decorator(func): @wraps(func) def wrapper(self, *args, **kwargs): func(self, *args, **kwargs) self.__frozen = True return wrapper cls.__setattr__ = frozensetattr cls.__init__ = init_decorator(cls.__init__) return cls 

Pretty easy to use:

 @froze_it class Foo(object): def __init__(self): self.bar = 10 foo = Foo() foo.bar = 42 foo.foobar = "no way" 

Result:

 >>> Class Foo is frozen. Cannot set foobar = no way 

Answer 4

The correct way is to override __setattr__ . This is what it is.

Answer 5

I really like the solution that the decorator uses, because it is easy to use for many classes in the project, with minimal additions for each class. But with inheritance, this does not work well. So here is my version: it only redefines the __setattr__ function - if the attribute does not exist, and the caller function is not __init__, it displays an error message.

 import inspect def froze_it(cls): def frozensetattr(self, key, value): if not hasattr(self, key) and inspect.stack()[1][3] != "__init__": print("Class {} is frozen. Cannot set {} = {}" .format(cls.__name__, key, value)) else: self.__dict__[key] = value cls.__setattr__ = frozensetattr return cls @froze_it class A: def __init__(self): self._a = 0 a = A() a._a = 1 a._b = 2 # error 

Answer 6

Here is the approach I came up with that does not require the _frozen attribute or the method for freezing () in init.

During init, I just add all the attributes of the class to the instance.

I like this because there is no _frozen, freeze () and _frozen also not showing up in the output of vars (instance).

 class MetaModel(type): def __setattr__(self, name, value): raise AttributeError("Model classes do not accept arbitrary attributes") class Model(object): __metaclass__ = MetaModel # init will take all CLASS attributes, and add them as SELF/INSTANCE attributes def __init__(self): for k, v in self.__class__.__dict__.iteritems(): if not k.startswith("_"): self.__setattr__(k, v) # setattr, won't allow any attributes to be set on the SELF/INSTANCE that don't already exist def __setattr__(self, name, value): if not hasattr(self, name): raise AttributeError("Model instances do not accept arbitrary attributes") else: object.__setattr__(self, name, value) # Example using class Dog(Model): name = '' kind = 'canine' d, e = Dog(), Dog() print vars(d) print vars(e) e.junk = 'stuff' # fails 

Answer 7

How about this:

 class A(): __allowed_attr=('_x', '_y') def __init__(self,x=0,y=0): self._x=x self._y=y def __setattr__(self,attribute,value): if not attribute in self.__class__.__allowed_attr: raise AttributeError else: super().__setattr__(attribute,value) 

Answer 8

I like Frozen Jochen Ritzel. The inconvenient thing is that isfrozen variable appears when printing the .__ dict class. I circumvented this problem this way by creating a list of allowed attributes (similar to slots ):

 class Frozen(object): __List = [] def __setattr__(self, key, value): setIsOK = False for item in self.__List: if key == item: setIsOK = True if setIsOK == True: object.__setattr__(self, key, value) else: raise TypeError( "%r has no attributes %r" % (self, key) ) class Test(Frozen): _Frozen__List = ["attr1","attr2"] def __init__(self): self.attr1 = 1 self.attr2 = 1 

Answer 9

FrozenClass Jochen Ritzel is cool, but calling _frozen() every time you initialize a class is not that cool (and you need to take a chance to forget it). I added the __init_slots__ function:

 class FrozenClass(object): __isfrozen = False def _freeze(self): self.__isfrozen = True def __init_slots__(self, slots): for key in slots: object.__setattr__(self, key, None) self._freeze() def __setattr__(self, key, value): if self.__isfrozen and not hasattr(self, key): raise TypeError( "%r is a frozen class" % self ) object.__setattr__(self, key, value) class Test(FrozenClass): def __init__(self): self.__init_slots__(["x", "y"]) self.x = 42# self.y = 2**3 a,b = Test(), Test() ax = 10 bz = 10 # fails