Специальный атрибут __slots__ позволяют явно объявлять элементы данных (например, свойства) и запрещать создание словаря __dict__ и __weakref__ (если явно не объявлено в __slots__ или не доступно в родительском элементе).
Пространство, сэкономленное от НЕ использования __dict__, может быть значительным! Скорость поиска атрибутов также может быть значительно увеличена.
Наличие магического атрибута __slots__ делает несколько вещей. Во-первых, он ограничивает допустимый набор имен атрибутов объекта только перечисленными именами. Во-вторых, поскольку атрибуты теперь фиксированы, больше нет необходимости хранить атрибуты в словаре экземпляра, поэтому атрибут __dict__ удаляется (если только базовый класс уже не имеет его; он также может быть добавлен обратно подклассом, который не имеет __slots__). При использовании атрибута __slots__ атрибуты хранятся в заранее определенных местах в массиве. Таким образом, каждый атрибут слота на самом деле является объектом дескриптора, который знает, как установить/получить каждый атрибут с помощью индекса массива. Реализация этой функции полностью на языке C и очень эффективна.
__slots__.__slots__ атрибуты __dict__ и __weakref__ экземпляров всегда будут доступны.__dict__, экземплярам нельзя назначить новые переменные/атрибуты, не указанные в определении __slots__. При попытке присвоения имени переменной, не указанной в списке, возникает ошибка AttributeError. Если требуется динамическое присвоение новых переменных, добавьте значение '__dict__' к последовательности строк в объявлении атрибута __slots__.__weakref__ для каждого экземпляра, классы, определяющие __slots__, не поддерживают слабые ссылки на его экземпляры. Если требуется поддержка слабых ссылок, добавьте значение '__weakref__' к последовательности строк в объявлении атрибута __slots__.__slots__ реализуются на уровне класса путем создания дескрипторов для каждого имени переменной. В результате атрибуты класса не могут использоваться для установки значений по умолчанию для переменных экземпляра, определенных в методе __slots__, в противном случае атрибут класса перезапишет назначение дескриптора.__slots__ не ограничивается классом, в котором он определен. Атрибуты __slots__, объявленные в родительских классах, доступны в дочерних классах. Однако дочерние подклассы получат __dict__ и __weakref__, если они не определят __slots__ (который должен содержать только имена любых дополнительных слотов).__slots__ не работает для классов, производных, от встроенных типов переменной длины, таких как int, bytes и tuple.__slots__ может быть назначен любой нестроковый итерируемый объект. Также могут использоваться словари, при этом в будущем, значениям, соответствующим каждому ключу, может быть присвоено особое значение.__class__ работает, только если оба класса имеют одинаковые __slots__.TypeError.__slots__ используется итератор, то для каждого значения итератора будет создаваться дескриптор, при этом атрибут __slots__ будет пустым итератором.__slots__.class Slot:
__slots__ = ["a", "b"]
>>> slot = Slot()
>>> slot.a = 1
>>> slot.a
# 1
>>> slot.a = 130
>>> slot.a
# 130
>>> slot.b = 13
>>> slot.b
# 13
# атрибут `c` не определен в списке `__slots__`
>>> slot.c = 1
# Traceback (most recent call last):
# File "<stdin>", line 1, in <module>
# AttributeError: 'Slot' object has no attribute 'c'
>>> slot.__dict__
# Traceback (most recent call last):
# File "<stdin>", line 1, in <module>
# AttributeError: 'Slot' object has no attribute '__dict__'
Чтобы сохранить динамическое назначение переменных для класса, то необходимо добавить значение '__dict__' в кортеж атрибута __slots__:
class Test(object):
__slots__ = ('a', 'b', '__dict__')
>>> t = Test
# переменные `foo` и `baz` не
# определены в `__slots__`
>>> t.foo, t.baz = 10, 100
>>> t.foo, t.baz
# (10, 100)
Если в классе будет использоваться функциональность слабых ссылок на объекты, то ее так же можно добавить добавив значение '__weakref__' в кортеж атрибута __slots__.
__slots__ происходит более быстрый доступ к атрибутам:import timeit
class Foo(object): __slots__ = 'foo',
class Bar(object): pass
slotted = Foo()
not_slotted = Bar()
def get_set_delete_fn(obj):
def get_set_delete():
obj.foo = 'foo'
obj.foo
del obj.foo
return get_set_delete
# измерим скорость доступа к атрибутам
>>> min(timeit.repeat(get_set_delete_fn(slotted)))
0.0844320549999793
>>> min(timeit.repeat(get_set_delete_fn(not_slotted)))
0.10562241299999187
__slots__ при множественном наследовании.Внимание! Если в слотах у нескольких родителей определены одинаковые атрибуты, то их нельзя использовать вместе при множественном наследовании:
class Foo(object):
__slots__ = 'foo', 'bar'
class Bar(object):
__slots__ = 'foo', 'bar'
# будет работать если в одном из
# родительских классов `__slots__ = ()`
>>> class Baz(Foo, Bar): pass
...
# Traceback (most recent call last):
# File "<stdin>", line 1, in <module>
# TypeError: multiple bases have instance lay-out conflict
Использование пустого __slots__ в родительском классе, обеспечивает наибольшую гибкость, позволяя дочерним классам выбирать, предотвращать или разрешать создание __dict__ (для динамического назначения атрибутов итогового класса):
class Foo(object): __slots__ = ()
class Bar(object): __slots__ = ()
class Baz(Foo, Bar): __slots__ = ('foo', 'bar')
b = Baz()
b.foo, b.bar = 'foo', 'bar'
Не обязательно иметь __slots__ с определенными атрибутами в родительских классах и если их добавить позже в дочернем классе, то это не должно вызвать никаких проблем.
Если составлять миксины или использовать абстрактные базовые классы, которые не предназначены для создания экземпляров напрямую, то пустой __slots__ в этих родителях - будет лучшим вариантом для подклассов.
Создадим класс с кодом, который будем использовать при множественном наследовании.
class AbstractBase:
__slots__ = ()
def __init__(self, a, b):
self.a = a
self.b = b
При одиночном наследовании, можно использовать AbstractBase как родительский класс, а в дочернем классе, в его __slots__ объявить ожидаемые атрибуты:
class Foo(AbstractBase):
__slots__ = 'a', 'b'
Разбираемся с множественным наследованием. Определим другой класс, от которого можно наследоваться:
class AbstractBaseC:
__slots__ = ()
@property
def c(self):
print('getting c!')
return self._c
@c.setter
def c(self, arg):
print('setting c!')
self._c = arg
Теперь, если у обоих базовых классов были слоты со своими атрибутами, то невозможно было бы сделать следующее.
class TestChild(AbstractBase, AbstractBaseC):
__slots__ = 'a b _c'.split()
Фактически, можно было в AbstractBase оставить __slots__ = 'a', 'b' и исключить их из объявления класса TestChild(), но оставлять их было бы неправильно. Зато теперь класс TestChild() имеет функциональность от обоих родительских классов через множественное наследование, и по-прежнему можно запретить создание экземпляров __dict__ и __weakref__:
>>> test = TestChild('a', 'b')
>>> test.c = 'c'
# setting c!
>>> test.c
# getting c!
# 'c'
# атрибут не определен
>>> test.d = 'd'
# Traceback (most recent call last):
# File "<stdin>", line 1, in <module>
# AttributeError: 'TestChild' object has no attribute 'd'