Метаклассы в Python: почему не setattr называется набор атрибутов в определение класса?

Блок класса-это примерно синтаксический сахар для построения словаря, а затем вызов метакласса для построения объекта класса.

Это:

class Foo(object):
    __metaclass__ = FooMeta
    FOO = 123
    def a(self):
        pass

Выходит почти так же, как если бы вы написали:

d = {}
d['__metaclass__'] = FooMeta
d['FOO'] = 123
def a(self):
    pass
d['a'] = a
Foo = d.get('__metaclass__', type)('Foo', (object,), d)

Только без загрязнения пространства имен (и на самом деле есть также поиск по всем базам, чтобы определить метакласс, или есть ли конфликт метакласса, но я игнорирую это здесь).

Метакласс " __setattr__ может контролировать то, что происходит, когда вы попробуйте установить атрибут на один из его экземпляров (объект класса), но внутри блока класса вы этого не делаете, вы вставляете в объект словаря, поэтому класс dict управляет тем, что происходит, а не вашим метаклассом. Так что тебе не повезло.

---

Если только вы не используете Python 3.х! В Python 3.x вы можете определить __prepare__ classmethod (или staticmethod) на метаклассе, который управляет тем, какой объект используется для накопления атрибутов, установленных в блоке класса, прежде чем они будут передается конструктору метакласса. По умолчанию __prepare__ просто возвращает обычный словарь, но вы можете построить пользовательский класс типа dict, который не позволяет переопределять ключи, и использовать его для накопления атрибутов:

from collections import MutableMapping


class SingleAssignDict(MutableMapping):
    def __init__(self, *args, **kwargs):
        self._d = dict(*args, **kwargs)

    def __getitem__(self, key):
        return self._d[key]

    def __setitem__(self, key, value):
        if key in self._d:
            raise ValueError(
                'Key {!r} already exists in SingleAssignDict'.format(key)
            )
        else:
            self._d[key] = value

    def __delitem__(self, key):
        del self._d[key]

    def __iter__(self):
        return iter(self._d)

    def __len__(self):
        return len(self._d)

    def __contains__(self, key):
        return key in self._d

    def __repr__(self):
        return '{}({!r})'.format(type(self).__name__, self._d)


class RedefBlocker(type):
    @classmethod
    def __prepare__(metacls, name, bases, **kwargs):
        return SingleAssignDict()

    def __new__(metacls, name, bases, sad):
        return super().__new__(metacls, name, bases, dict(sad))


class Okay(metaclass=RedefBlocker):
    a = 1
    b = 2


class Boom(metaclass=RedefBlocker):
    a = 1
    b = 2
    a = 3

Запуск этого дает мне:

Traceback (most recent call last):
  File "/tmp/redef.py", line 50, in <module>
    class Boom(metaclass=RedefBlocker):
  File "/tmp/redef.py", line 53, in Boom
    a = 3
  File "/tmp/redef.py", line 15, in __setitem__
    'Key {!r} already exists in SingleAssignDict'.format(key)
ValueError: Key 'a' already exists in SingleAssignDict

Некоторые примечания:

1. __prepare__ должен быть classmethod или staticmethod, потому что он вызывается до того, как экземпляр метакласса (ваш класс) существует.
2. type все еще нуждается в том, чтобы его третий параметр был реальным dict, поэтому у вас должен быть метод __new__, который преобразует SingleAssignDict в нормальный
Я мог бы подклассировать dict, что, вероятно, позволило бы избежать (2), но мне очень не нравится делать это из-за того, что неосновные методы, такие как update, не уважают ваши переопределения основных методов, таких как __setitem__. Поэтому я предпочитаю подкласс collections.MutableMapping и завернуть словарь.
3. фактический Okay.__dict__ объект является нормальным словарем, потому что он был задан type и type привередливо относится к виду словарь ей нужен. Это означает, что перезапись атрибутов класса после его создания не вызывает исключения. Вы можете перезаписать атрибут __dict__ после вызова суперкласса в __new__, Если хотите сохранить принудительную отмену перезаписи словарем объекта класса.

---

К сожалению, этот метод недоступен в Python 2.x (я проверил). Метод __prepare__ не вызывается, что имеет смысл, как и в Python 2.x метакласс определяется скорее атрибутом __metaclass__ magic чем специальное ключевое слово в classblock; это означает, что объект dict, используемый для накопления атрибутов для блока класса, уже существует ко времени, когда метакласс известен.

Сравните Python 2:

class Foo(object):
    __metaclass__ = FooMeta
    FOO = 123
    def a(self):
        pass

Примерно эквивалентно:

d = {}
d['__metaclass__'] = FooMeta
d['FOO'] = 123
def a(self):
    pass
d['a'] = a
Foo = d.get('__metaclass__', type)('Foo', (object,), d)

Где метакласс для вызова определяется из словаря, в отличие от Python 3:

class Foo(metaclass=FooMeta):
    FOO = 123
    def a(self):
        pass

Примерно эквивалентно:

d = FooMeta.__prepare__('Foo', ())
d['Foo'] = 123
def a(self):
    pass
d['a'] = a
Foo = FooMeta('Foo', (), d)

Где используемый словарь определяется из метакласса.