Блог

Если кто-то заинтересован в том, чтобы сделать это с помощью декоратора, вот рабочее решение:

 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
 

Довольно простой в использовании:

 @froze_it 
class Foo(object):
    def __init__(self):
        self.bar = 10

foo = Foo()
foo.bar = 42
foo.foobar = "no way"
 

Результат:

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

На самом деле, вы не хотите __setattr__ , вы хотите __slots__ . Добавьте __slots__ = ('foo', 'bar', 'baz') в тело класса, и Python позаботится о том, чтобы в любом экземпляре были только foo, bar и baz. Но прочитайте предостережения в списках документации!

Правильный способ — это переопределить __setattr__ . Вот для чего он существует.

Мне очень нравится решение, в котором используется декоратор, потому что его легко использовать для многих классов в проекте с минимальными дополнениями для каждого класса. Но это плохо работает с наследованием. Итак, вот моя версия: она переопределяет только функцию __setattr__ — если атрибут не существует, а вызывающая функция не __init__, она выводит сообщение об ошибке.

 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
 

Как насчет этого:

 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)
 

Вот подход, который я придумал, для которого не требуется атрибут _frozen или метод для freeze() в init.

Во время инициализации я просто добавляю все атрибуты класса в экземпляр.

Мне это нравится, потому что нет _frozen , freeze() , а _frozen также не отображается в выходных данных vars(экземпляра).

 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
 

Мне нравится «Замороженный» Йохен Ритцель. Неудобно то, что переменная isfrozen затем появляется при печати класса.__dict Я обошел эту проблему таким образом, создав список разрешенных атрибутов (похожих на слоты):

 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
 

FrozenClass Йохен Ритцель — это круто, но вызывать _frozen() при инициализации класса каждый раз не так круто (и вам нужно рискнуть забыть об этом). Я добавил __init_slots__ функцию:

 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()
a.x = 10
b.z = 10 # fails
 

Ни в одном из ответов не упоминается влияние переопределения на производительность __setattr__ , что может быть проблемой при создании множества небольших объектов. (И __slots__ было бы эффективным решением, но ограничивает выбор / наследование).

Итак, я придумал этот вариант, который устанавливает наш более медленный settatr после инициализации:

 class FrozenClass:

    def freeze(self):
        def frozen_setattr(self, key, value):
            if not hasattr(self, key):
                raise TypeError("Cannot set {}: {} is a frozen class".format(key, self))
            object.__setattr__(self, key, value)
        self.__setattr__ = frozen_setattr

class Foo(FrozenClass): ...
 

Если вы не хотите вызывать freeze в конце __init__ , если наследование является проблемой, или если вы не хотите его vars() вводить, его также можно адаптировать: например, вот версия декоратора, основанная на pystrict ответе:

 import functools
def strict(cls):
    cls._x_setter = getattr(cls, "__setattr__", object.__setattr__)
    cls._x_init = cls.__init__
    @functools.wraps(cls.__init__)
    def wrapper(self, *args, **kwargs):
        cls._x_init(self, *args, **kwargs)
        def frozen_setattr(self, key, value):
            if not hasattr(self, key):
                raise TypeError("Class %s is frozen. Cannot set '%s'." % (cls.__name__, key))
            cls._x_setter(self, key, value)
        cls.__setattr__ = frozen_setattr
    cls.__init__ = wrapper
    return cls

@strict
class Foo: ...
 

Я написал pystrict как решение этой проблемы. Он слишком большой, чтобы вставить весь код в stackoverflow.

pystrict это устанавливаемый декоратор pypi, который можно использовать с классами для их замораживания. Многие решения здесь не поддерживают наследование должным образом.

Если __slots__ у вас это не работает (из-за проблем с наследованием), это хорошая альтернатива.

В README есть пример, который показывает, почему такой декоратор необходим, даже если в вашем проекте запущены mypy и pylint:

pip install pystrict

Затем просто используйте декоратор @strict:

 from pystrict import strict

@strict
class Blah
  def __init__(self):
     self.attr = 1