Metaclasses y __slots__?

Question

Por lo tanto, estoy leyendo un poco sobre metaclases en Python, y cómo el alter-ego de tres argumentos de type() se usa para crear clases dinámicamente. Sin embargo, el tercer argumento es generalmente un dict que inicializa la clase '__dict__' de la clase que se creará.

Si quiero crear dinámicamente clases basadas en una metaclase que use __slots__ en lugar de __dict__, ¿cómo podría hacer esto? ¿Todavía se usa type() de alguna manera junto con __new__()?

Como un FYI, soy consciente de los usos adecuados para __slots__, para ahorrar memoria al crear grandes cantidades de una clase en lugar de abusar de ella para aplicar una forma de seguridad de tipo.

ejemplo de una clase normal (de nuevo estilo) que establece __metaclass__ y utiliza un __dict__: el cuarto argumento

class Meta(type): 
    def __new__(cls, name, bases, dctn): 
     # Do something unique ... 
     return type.__new__(cls, name, bases, dctn) 

class Foo(object): 
    __metaclass__ = Meta 

    def __init__(self): 
     pass 

En lo anterior, type.__new__() se llama y (que se convierte en la tercera cuando se utiliza en realidad) crea un __dict__ en Foo. Pero si quisiera modificar Meta para incluir __slots__, entonces no tengo ningún diccionario para pasar a la función type()__new__() (hasta donde yo sé, no he probado nada de esto todavía, solo ponderando e intentando encontrar algo tipo de escenario de caso de uso).

Editar: Un cálculo rápido, pero no probado, es tomar un diccionario de los valores que se ponga en las variables de __slots__ y pasarlo a type.__new__(). A continuación, agregue __init__() a Meta que rellena las variables __slots__ del dict. Aunque, no estoy seguro de cómo que dict alcanzaría __init__(), debido a que la declaración de __slots__ impide __dict__ que se creen menos __dict__ se define en __slots__ ...

Answer 1

No se puede crear un tipo con un atributo __slots__ no vacío. Lo que puede hacer es insertar un atributo __slots__ en dict de la nueva clase, así:

class Meta(type): 
    def __new__(cls, name, bases, dctn): 
     dctn['__slots__'] = ('x',) 
     return type.__new__(cls, name, bases, dctn) 

class Foo(object): 
    __metaclass__ = Meta 

    def __init__(self): 
     pass 

atributos Ahora Foo ha ranurados:

foo = Foo() 
foo.y = 1 

tiros

AttributeError: 'Foo' object has no attribute 'y' 

Answer 2

dctn en su ejemplo de una metaclase es el diccionario clase, no el instancia diccionario. __slots__ reemplaza el ejemplo diccionario. Si crea dos ejemplos:

class Meta(type): 
    def __new__(cls, name, bases, dctn): 
     return type.__new__(cls, name, bases, dctn) 

class Foo1(object): 
    __metaclass__ = Meta 

class Foo2(object): 
    __metaclass__ = Meta 
    __slots__ = ['a', 'b'] 

continuación:

>>> f1 = Foo1() 
>>> f2 = Foo2() 
>>> f1.__dict__ is Foo1.__dict__ 
False 
>>> f2.__dict__ 
Traceback (most recent call last): 
    ... 
AttributeError: 'Foo2' object has no attribute '__dict__' 

Answer 3

Más sobre ranuras definido en metaclases.

si subclase type 's define no vacío __slots__, Python lanza una TypeError debido a algún complicated implementation-related stuff.

In [1]: 

class Meta(type): 
    __slots__ = ('x') 

--------------------------------------------------------------------------- 
TypeError         Traceback (most recent call last) 
<ipython-input-38-1b16edef8eca> in <module>() 
----> 1 class Meta(type): 
     2  __slots__ = ('x') 

TypeError: nonempty __slots__ not supported for subtype of 'type' 

vacío __slots__ por el contrario no producen ningún error, pero la costura no tener ningún efecto.

In [2]: 

class Meta(type): 
    __slots__ =() 

class Foo(metaclass=Meta): 
    pass 

type(Foo) 

Out [2]: 

__main__.Meta 

In [3]: 

Foo.y = 42 
Foo.y 

Out [3]: 

42 

In [4]: 

Foo.__dict__ 

Out [4]: 

mappingproxy({'y': 42, '__dict__': <attribute '__dict__' of 'Foo' objects>, '__doc__': None, '__weakref__': <attribute '__weakref__' of 'Foo' objects>, '__module__': '__main__'}) 

In [5]: 

foo = Meta('foo',(), {}) 
type(foo).__slots__ 

Out [5]: 

() 

In [6]: 

foo.x = 42 
foo.x 

Out [6]: 

42 

In [7]: 

foo.__dict__ 

Out [7]: 

mappingproxy({'__dict__': <attribute '__dict__' of 'foo' objects>, 'x': 42, '__module__': '__main__', '__doc__': None, '__weakref__': <attribute '__weakref__' of 'foo' objects>}) 

In [8]: 

# Testing on non-metaclasses. Just in case. 
class Bar: 
    __slots__ =() 

b = Bar() 
b.__dict__ 

--------------------------------------------------------------------------- 
AttributeError       Traceback (most recent call last) 
<ipython-input-54-843730c66f3f> in <module>() 
     3 
     4 b = Bar() 
----> 5 b.__dict__ 

AttributeError: 'Bar' object has no attribute '__dict__'