Не допускати створення нових атрибутів за межами __init__

Я хочу мати можливість створити клас (на Python), який після ініціалізації за допомогою __init__не приймає нових атрибутів, але приймає модифікації існуючих атрибутів. Існує декілька хакерських способів зробити це, наприклад, маючи такий __setattr__метод, як

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

а потім редагування __dict__безпосередньо всередині __init__, але мені було цікаво, чи існує "правильний" спосіб зробити це?

Я б не використовував __dict__безпосередньо, але ви можете додати функцію, щоб явно "заморозити" екземпляр:

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

Якщо хтось зацікавлений зробити це з декоратором, ось робоче рішення:

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

Слоти - це шлях:

Пітонічний спосіб полягає у використанні слотів замість того, щоб пограти з __setter__. Незважаючи на те, що це може вирішити проблему, це не сприяє покращенню продуктивності. Атрибути об'єктів зберігаються у словнику " __dict__", ось чому ви можете динамічно додавати атрибути до об'єктів класів, які ми створили на сьогодні. Використовувати словник для зберігання атрибутів дуже зручно, але це може означати втрату місця для об’єктів, які мають лише невелику кількість змінних екземпляра.

Слоти - це приємний спосіб обійти цю проблему споживання простору. Замість того, щоб мати динамічний дикт, що дозволяє динамічно додавати атрибути до об’єктів, слоти надають статичну структуру, яка забороняє додавання після створення екземпляра.

Коли ми розробляємо клас, ми можемо використовувати слоти, щоб запобігти динамічному створенню атрибутів. Щоб визначити слоти, вам потрібно визначити список з назвою __slots__. Список повинен містити всі атрибути, які ви хочете використовувати. Ми демонструємо це в наступному класі, в якому список слотів містить лише ім'я атрибута "val".

class S(object):

    __slots__ = ['val']

    def __init__(self, v):
        self.val = v


x = S(42)
print(x.val)

x.new = "not possible"

=> Не вдається створити атрибут "new":

42 
Traceback (most recent call last):
  File "slots_ex.py", line 12, in <module>
    x.new = "not possible"
AttributeError: 'S' object has no attribute 'new'

Примітка:

1. З мовою Python 3.3 перевага в оптимізації споживання місця вже не така вражаюча. У Python 3.3 Словники спільного використання ключів використовуються для зберігання об’єктів. Атрибути примірників можуть спільно використовувати частину свого внутрішнього сховища між собою, тобто частину, яка зберігає ключі та відповідні їм хеші. Це допомагає зменшити споживання пам'яті програмами, які створюють багато екземплярів невбудованих типів. Але все-таки це шлях, щоб уникнути динамічно створених атрибутів.

2. Використання слотів також постачається за власну вартість. Це порушить серіалізацію (наприклад, соління). Це також порушить багаторазове успадкування. Клас не може успадкувати більше ніж одного класу, який або визначає слоти, або має макет екземпляра, визначений у коді С (наприклад, список, кортеж або int).

Насправді, ти не хочеш __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 або методу, щоб заморозити () в init.

Під час init я просто додаю всі атрибути класу до екземпляра.

Мені це подобається, тому що немає _frozen, freeze (), а _frozen також не відображається у вихідних даних 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

pystrict- це декоратор pypi, який можна встановити, натхненний цим питанням stackoverflow, який можна використовувати з класами для їх заморожування. Є приклад README, який показує, чому такий декоратор потрібен, навіть якщо у вашому проекті запущено mypy та pylint:

pip install pystrict

Тоді просто використовуйте декоратор @strict:

from pystrict import strict

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

Мені подобається "Заморожений" Йохена Рітцеля. Незручним є те, що змінна 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Йохен RITZEL це круто, але називати , _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