Какова цель __slots__ в Python?

n

Какова цель __slots__ в Python. Особенно в отношении того, когда его использовать, а когда нет?

n

TLDR:

Специальный атрибут __slots__ позволяет вам явно указать, какие атрибуты экземпляра вы ожидаете от экземпляров вашего объекта, с ожидаемыми результатами:

n
1. быстрый доступ к атрибутам.
n
2. экономия памяти.
n

Место экономится потому что

n
1. n

   Ссылки сохраняются на значение слотов а не в __dict__

   n
n
2. n

   Запрещение создания __dict__ и __weakref__, если родительские классы запрещают их, и вы объявляете __slots__.

   n
n

Краткие предупреждения

В дереве наследования объявлять определённый слот надо лишь один раз

Например:

class Base:n    __slots__ = 'foo', 'bar'nclass Right(Base):n    __slots__ = 'baz',n    nclass Wrong(Base):n    __slots__ = 'foo', 'bar', 'baz' # избыточные foo и barn

Python не возражает, когда вы ошибаетесь (вероятно должен), иначе проблемы могут не проявиться, но ваши объекты будут занимать больше места, чем должны.

Python 3.8:

>>> from sys import getsizeofn>>> getsizeof(Right()), getsizeof(Wrong())n(56, 72) n

Это происходит потому, что дескриптор слота Base имеет слот, отдельный от Wrong.

>>> w = Wrong()n>>> w.foo = 'foo'n>>> Base.foo.__get__(w)nTraceback (most recent call last):n  File ""<stdin>"", line 1, in <module>nAttributeError: foon>>> Wrong.foo.__get__(w)n'foo'n

Самое большое предостережение касается множественного наследования - несколько «родительских классов с непустыми слотами» не могут быть объединены.

Чтобы обойти это ограничение, следуйте рекомендациям: Вычлените все абстракции родителей, кроме одного или всех, от которых будет унаследован их конкретный класс, и ваш новый класс - предоставив абстракциям пустые слоты(точно так же, как абстрактные базовые классы в стандартной библиотеке)

См. Пример ниже в разделе о множественном наследовании.

Требования:

n
1. n

   Чтобы атрибуты, названные в __slots__, хранились в слотах а не в __dict__, класс должен наследовать от object.

   n
n
2. n

   Чтобы предотвратить создание __dict__, вы должны наследовать от objectw, и все классы в наследовании должны объявлять __slots__, и ни один из них не может иметь запись __dict__.

   n
n

Если вы хотите продолжить чтение, есть ещё много деталей.

Зачем использовать __slots__: более быстрый доступ к атрибутам.

Создатель Python, Guido van Rossum, , что на самом деле он создал __slots__ для более быстрого доступа к атрибутам.

Продемонстрировать боле�� быстрый доступ - это тривиальная задача:

import timeitnclass Foo(object): __slots__ = 'foo',nclass Bar(object): passnslotted = Foo()nnot_slotted = Bar()ndef get_set_delete_fn(obj):n    def get_set_delete():n        obj.foo = 'foo'n        obj.foon        del obj.foon    retu get_set_deleten

и

>>> min(timeit.repeat(get_set_delete_fn(slotted)))n0.2846834529991611n>>> min(timeit.repeat(get_set_delete_fn(not_slotted)))n0.3664822799983085 n

В Python 3.5 на Ubuntu доступ с использованием слотов почти на 30% быстрее.

>>> 0.3664822799983085 / 0.2846834529991611n1.2873325658284342 n

Я измерил это В Python 2 в Windows получилось что примерно на 15% быстрее.

Зачем использовать __slots__: экономия памяти

Другая цель __slots__ - уменьшить объем в памяти, которое занимает каждый экземпляр объекта.

n

Пространство, сэкономленное при использовании __dict__, может быть значительным.

n

значительную экономию памяти приписывает __slots__.

Чтобы проверить это, используя дистрибутив Anaconda для Python 2.7 в Ubuntu Linux с guppy.hpy (он же heapy) и sys.getsizeof, размер экземпляра класса без объявленного __slots__ и ничего другого составляет 64 байта. Это не включает __dict__. Еще раз спасибо Python за ленивую оценку, __dict__, по-видимому, не вызывается до тех пор, пока на него не будет ссылаться, но классы без данных обычно бесполезны. При вызове атрибут __dict__ имеет дополнительно минимум 280 байтов.

Напротив, экземпляр класса с __slots__, объявленным как () (без данных), составляет всего 16 байтов, и всего 56 байтов с одним элементом в слотах, 64 с двумя.

Для 64-битного Python я проиллюстрирую потребление памяти в байтах в Python 2.7 и 3.6 для __slots__ и __dict__ (слоты не определены) для каждой точки, где dict увеличивается в 3.6 (кроме атрибутов 0, 1 и 2):

           Python 2.7             Python 3.6n    attrs  __slots__  __dict__*   __slots__  __dict__* | *(слоты не определены)n    none   16         56 + 272†   16         56 + 112† | †если __dict__ упоминаетсяn    one    48         56 + 272    48         56 + 112n    two    56         56 + 272    56         56 + 112n    six    88         56 + 1040   88         56 + 152n    11     128        56 + 1040   128        56 + 240n    22     216        56 + 3344   216        56 + 408     n    43     384        56 + 3344   384        56 + 752n

Итак, несмотря на меньшие __dict__ в Python 3, мы видим, насколько хорошо __slots__ масштабируется для экземпляров, чтобы сэкономить нам память, и это основная причина, по которой нужно использовать __slots__.

Просто для полноты моих заметок обратите внимание, что существует единовременная стоимость одного слота в пространстве имен класса в 64 байта в Python 2 и 72 байта в Python 3, потому что слоты используют дескрипторы данных, такие как свойства, называемые «членами».

>>> Foo.foon<member 'foo' of 'Foo' objects>n>>> type(Foo.foo)n<class 'member_descriptor'>n>>> getsizeof(Foo.foo)n72n

Демонстрация __slots__: Чтобы запретить создание __dict__, вы должны создать подкласс объекта:

class Base(object):n     __slots__ = ()n

теперь же

>>> b = Base()n>>> b.a = 'a'nTraceback (most recent call last):n  File ""<pyshell#38>"", line 1, in <module>n    b.a = 'a'nAttributeError: 'Base' object has no attribute 'a'n

Или создайте подкласс другого класса, который определяет __slots__

class Child(Base):n    __slots__ = ('a',)n

И теперь:

c = Child()nc.a = 'a'n

но:

>>> c.b = 'b'nTraceback (most recent call last):n  File ""<pyshell#42>"", line 1, in <module>n    c.b = 'b'nAttributeError: 'Child' object has no attribute 'b'n

Чтобы разрешить создание __dict__ при создании подкласса для объектов со слотами, просто добавьте __dict__ к __slots__ (обратите внимание, что слоты упорядочены, и вы не должны повторять слоты, которые уже находятся в родительских классах):

class SlottedWithDict(Child): n    __slots__ = ('__dict__', 'b')nswd = SlottedWithDict()nswd.a = 'a'nswd.b = 'b'nswd.c = 'c'n

и

>>> swd.__dict__n{'c': 'c'}n

Или вам даже не нужно объявлять __slots__ в своем подклассе, и вы по-прежнему будете использовать слоты от родителей, но не ограничивать создание __dict__:

class NoSlots(Child): passnns = NoSlots()nns.a = 'a'nns.b = 'b'n

и:

>>> ns.__dict__n{'b': 'b'}n

Однако __slots__ может вызвать проблемы при множественном наследовании.

class BaseA(object): n    __slots__ = ('a',)nclass BaseB(object): n    __slots__ = ('b',) n

Создание дочернего класса от родителей с обоими непустыми слотами не удается:

>>> class Child(BaseA, BaseB): __slots__ = ()nTraceback (most recent call last):n  File ""<pyshell#68>"", line 1, in <module>n    class Child(BaseA, BaseB): __slots__ = ()nTypeError: Error when calling the metaclass basesn    multiple bases have instance lay-out conflict n

Если вы столкнетесь с этой проблемой, вы можете просто удалить __slots__ у родителей или, если вы контролируете родителей, дать им пустые слоты или выполнить рефакторинг для абстракций:

from abc import ABCnclass AbstractA(ABC):n    __slots__ = ()nclass BaseA(AbstractA): n    __slots__ = ('a',)nclass AbstractB(ABC):n    __slots__ = ()nclass BaseB(AbstractB): n    __slots__ = ('b',)nclass Child(AbstractA, AbstractB): n    __slots__ = ('a', 'b')nc = Child() # Нет ошибокn

Добавьте '__dict__' к __slots__ чтобы получить динамическое назначение:

class Foo(object):n    __slots__ = 'bar', 'baz', '__dict__'n

и сейчас

>>> foo = Foo()n>>> foo.boink = 'boink'n

Таким образом, с '__dict__' в слотах мы теряем некоторые преимущества размера с преимуществом наличия динамического назначения и по-прежнему наличия слотов для имен, которые мы ожидаем

Когда вы наследуете объект, который не имеет слотов, вы получаете такую же семантику, когда используете __slots__ - имена, которые находятся в __slots__, указывают на значения, размещенные в слотах, тогда как любые другие значения помещаются в __dict__ экземпляра.

Избегать __slots__, потому что вы хотите иметь возможность добавлять атрибуты на лету, на самом деле не является хорошей причиной - просто добавьте '__dict__' в свой __slots__, если это необходимо.

Вы можете точно так же явно добавить __weakref__ в __slots__, если вам нужна эта функция.

Установите пустой кортеж при создании подкласса именованного кортежа:

Встроенная класс namedtuple создает очень легкие неизменяемые экземпляры (по сути, размер кортежей), но чтобы получить преимущества, вам нужно сделать это самостоятельно, если вы подклассифицируете их:

from collections import namedtuplenclass MyNT(namedtuple('MyNT', 'bar baz')):n    """"""MyNT is an immutable and lightweight object""""""n    __slots__ = () n

использование

>>> nt = MyNT('bar', 'baz')n>>> nt.ba'bar'n>>> nt.bazn'baz'n

А попытка назначить неожиданный атрибут вызывает ошибку AttributeError, потому что мы предотвратили создание __dict__:

>>> nt.quux = 'quux'nTraceback (most recent call last):n  File ""<stdin>"", line 1, in <module>nAttributeError: 'MyNT' object has no attribute 'quux'n

Вы можете разрешить создание __dict__, отключив __slots__ = (), но вы не можете использовать непустые __slots__ с подтипами кортежа.

Важнейшее предостережение: множественное наследование

Даже если непустые слоты одинаковы для нескольких родителей, их нельзя использовать вместе:

class Foo(object): n    __slots__ = 'foo', 'bar'nclass Bar(object):n    __slots__ = 'foo', 'bar' # увы, будет работать, если пусто, т.е. ()n>>> class Baz(Foo, Bar): passnTraceback (most recent call last):n  File ""<stdin>"", line 1, in <module>nTypeError: Error when calling the metaclass basesn    multiple bases have instance lay-out conflict n

Использование пустого __slots__ в родительском элементе, ��о-видимому, обеспечивает максимальную гибкость, позволяя дочернему элементу выбирать, предотвращать или разрешать (добавляя '__dict__' для получения динамического назначения, см. Раздел выше) создание __dict__:

class Foo(object): __slots__ = ()nclass Bar(object): __slots__ = ()nclass Baz(Foo, Bar): __slots__ = ('foo', 'bar')nb = Baz()nb.foo, b.bar = 'foo', 'bar'n

Вам не обязательно иметь слоты - поэтому, если вы добавите их и удалите позже, это не должно вызвать никаких проблем.

Подводя итоги: если вы составляете или используете , которые не предназначены для создания экземпляров, пустой __slots__  в этих родителях кажется лучшим способом гибкости для подклассов.

Чтобы продемонстрировать, сначала давайте создадим код с классом, который мы хотели бы использовать при множественном наследовании.

class AbstractBase:n    __slots__ = ()n    def __init__(self, a, b):n        self.a = an        self.b = bn    def __repr__(self):n        retu f'{type(self).__name__}({repr(self.a)}, {repr(self.b)})'n

Мы могли бы использовать вышесказанное непосредственно путем наследования и объявления ожидаемых слотов:

class Foo(AbstractBase):n    __slots__ = 'a', 'b' n

Но нас это не волнует, это тривиальное одиночное наследование, нам нужен другой класс, от которого мы также могли бы унаследовать, возможно, с шумным атрибутом:

class AbstractBaseC:n    __slots__ = ()n    @propertyn    def c(self):n        print('getting c!')n        retu self._cn    @c.sette    def c(self, arg):n        print('setting c!')n        self._c = argn

Теперь, если бы на обеих базах были непустые слоты, мы не смогли бы сделать следующее. (На самом деле, если бы мы хотели, мы могли бы дать AbstractBase непустые слоты a и b и исключить их из приведенного ниже объявления - оставлять их было бы неправильно):

class Concretion(AbstractBase, AbstractBaseC):n    __slots__ = 'a b _c'.split() n

И теперь у нас есть функциональность от обоих через множественное наследование, и мы все еще можем запретить создание экземпляров __dict__ и __weakref__:

>>> c = Concretion('a', 'b')n>>> c.c = cnsetting c!n>>> c.cngetting c!nConcretion('a', 'b')n>>> c.d = 'd'nTraceback (most recent call last):n  File ""<stdin>"", line 1, in <module>nAttributeError: 'Concretion' object has no attribute 'd'n

Другие случаи, чтобы избежать слотов:

n
• n

  Избегайте их, если вы хотите выполнить назначение __class__ с другим классом, у которого их нет (и вы не можете их добавить), если макеты слотов не идентичны. (Мне очень интересно узнать, кто это делает и почему.)

  n
n
• n

  Избегайте их, если вы хотите создать подкласс встроенных функций переменной длины, таких как long, tuple или str, и хотите добавить к ним атрибуты.

  n
n
• n

  Избегайте их, если вы настаиваете на предоставлении значений по умолчанию через атрибуты класса для переменных экземпляра.

  n
n

Возможно, вам удастся выявить дополнительные предостережения из остальной части , в которую я недавно внес значительный вклад.

_{перевод от участника}