__slots__Python的目的是什么？
__slots__
__slots__在 Python 中，应该避免这种情况的目的和情况是什么？
特殊属性__slots__允许您明确说明您希望对象实例具有哪些实例属性，并具有预期的结果：
节省的空间来自
__dict__
__weakref__
小警告，您应该只在继承树中声明一次特定的插槽。例如：
class Base: __slots__ = 'foo', 'bar' class Right(Base): __slots__ = 'baz', class Wrong(Base): __slots__ = 'foo', 'bar', 'baz' # redundant foo and bar
当你犯了这个错误时，Python 不会反对（它可能应该），否则问题可能不会出现，但是你的对象会占用比它们原本应该占用的更多空间。蟒蛇 3.8：
>>> from sys import getsizeof >>> getsizeof(Right()), getsizeof(Wrong()) (56, 72)
这是因为 Base 的槽描述符有一个与 Wrong 分开的槽。这通常不应该出现，但它可以：
>>> w = Wrong() >>> w.foo = 'foo' >>> Base.foo.__get__(w) Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: foo >>> Wrong.foo.__get__(w) 'foo'
最大的警告是多重继承 - 不能组合多个“具有非空槽的父类”。
为了适应这种限制，请遵循最佳实践：除一个或所有父抽象之外，它们的具体类和您的新具体类将共同继承的所有抽象 - 给抽象空槽（就像抽象基类中的标准库）。
有关示例，请参见下面的多重继承部分。
要将名为 in__slots__的属性实际存储在插槽而不是 a__dict__中，类必须继承自object（在 Python 3 中是自动的，但在 Python 2 中必须是显式的）。
object
为了防止创建 a __dict__，您必须继承自object，并且继承中的所有类都必须声明__slots__，并且它们都不能有'__dict__'条目。
'__dict__'
如果您想继续阅读，这里有很多细节。
Python 的创建者 Guido van Rossum表示，他实际上是__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.2846834529991611 >>> min(timeit.repeat(get_set_delete_fn(not_slotted))) 0.3664822799983085
在 Ubuntu 上的 Python 3.5 中，时隙访问速度快了近 30%。
>>> 0.3664822799983085 / 0.2846834529991611 1.2873325658284342
在 Windows 上的 Python 2 中，我测得它快了大约 15%。
的另一个目的__slots__是减少每个对象实例占用的内存空间。
我自己对文档的贡献清楚地说明了这背后的原因：
使用时节省的空间__dict__可能很大。
SQLAlchemy 将大量内存节省归功于__slots__.
为了验证这一点，在 Ubuntu Linux 上使用 Python 2.7 的 Anaconda 发行版，带有guppy.hpy（又名 heapy）和sys.getsizeof，没有声明的类实例的大小__slots__是 64 字节。这 不 包括__dict__. 再次感谢 Python 的惰性求值，在__dict__被引用之前显然不会被调用，但是没有数据的类通常是无用的。当调用存在时，该__dict__属性至少额外增加 280 个字节。
guppy.hpy
sys.getsizeof
相比之下，__slots__声明为()（无数据）的类实例只有 16 个字节，总共 56 个字节，其中一个项目在插槽中，64 个字节有两个。
()
对于 64 位 Python，我说明了 Python 2.7 和 3.6 中的内存消耗（以字节为单位），对于 dict 在 3.6 中增长的每个点（除了 0、1 和 2 属性）（没有定义插槽）__slots__：__dict__
Python 2.7 Python 3.6 attrs __slots__ __dict__* __slots__ __dict__* | *(no slots defined) none 16 56 + 272鈥� 16 56 + 112鈥� | 鈥爄f __dict__ referenced one 48 56 + 272 48 56 + 112 two 56 56 + 272 56 56 + 112 six 88 56 + 1040 88 56 + 152 11 128 56 + 1040 128 56 + 240 22 216 56 + 3344 216 56 + 408 43 384 56 + 3344 384 56 + 752
因此，尽管 Python 3 中的 dicts 更小，但我们看到__slots__实例的扩展性非常好，以节省我们的内存，这是您想要使用__slots__.
只是为了我的笔记的完整性，请注意，在 Python 2 中，类命名空间中的每个插槽的一次性成本为 64 字节，在 Python 3 中为 72 字节，因为插槽使用属性等数据描述符，称为“成员”。
>>> Foo.foo <member 'foo' of 'Foo' objects> >>> type(Foo.foo) <class 'member_descriptor'> >>> getsizeof(Foo.foo) 72
要拒绝 a 的创建__dict__，您必须子类化object。Python 3 中的所有子类object，但在 Python 2 中，您必须明确：
class Base(object): __slots__ = ()
现在：
>>> b = Base() >>> b.a = 'a' Traceback (most recent call last): File "<pyshell#38>", line 1, in <module> b.a = 'a' AttributeError: 'Base' object has no attribute 'a'
或者子类化另一个定义的类__slots__
class Child(Base): __slots__ = ('a',)
c = Child() c.a = 'a'
但：
>>> c.b = 'b' Traceback (most recent call last): File "<pyshell#42>", line 1, in <module> c.b = 'b' AttributeError: 'Child' object has no attribute 'b'
要在子类化槽对象时允许__dict__创建，只需添加'__dict__'（__slots__注意槽是有序的，您不应该重复已经在父类中的槽）：
class SlottedWithDict(Child): __slots__ = ('__dict__', 'b') swd = SlottedWithDict() swd.a = 'a' swd.b = 'b' swd.c = 'c'
>>> swd.__dict__ {'c': 'c'}
或者你甚至不需要__slots__在你的子类中声明，你仍然会使用父类的插槽，但不限制 a 的创建__dict__：
class NoSlots(Child): pass ns = NoSlots() ns.a = 'a' ns.b = 'b'
和：
>>> ns.__dict__ {'b': 'b'}
但是，__slots__可能会导致多重继承问题：
class BaseA(object): __slots__ = ('a',) class BaseB(object): __slots__ = ('b',)
因为从具有两个非空槽的父级创建子类失败：
>>> class Child(BaseA, BaseB): __slots__ = () Traceback (most recent call last): File "<pyshell#68>", line 1, in <module> class Child(BaseA, BaseB): __slots__ = () TypeError: Error when calling the metaclass bases multiple bases have instance lay-out conflict
如果你遇到这个问题，你 可以 从父母中移除__slots__，或者如果你可以控制父母，给他们空槽，或者重构抽象：
from abc import ABC class AbstractA(ABC): __slots__ = () class BaseA(AbstractA): __slots__ = ('a',) class AbstractB(ABC): __slots__ = () class BaseB(AbstractB): __slots__ = ('b',) class Child(AbstractA, AbstractB): __slots__ = ('a', 'b') c = Child() # no problem!
class Foo(object): __slots__ = 'bar', 'baz', '__dict__'
>>> foo = Foo() >>> foo.boink = 'boink'
因此，使用'__dict__'in slot 时，我们失去了一些尺寸优势，因为动态分配的好处是仍然有我们所期望的名称的 slot。
当你从一个没有开槽的对象继承时，你会得到相同的语义__slots__——名称__slots__指向开槽的值，而任何其他值都放在实例的__dict__.
避免__slots__因为您希望能够即时添加属性实际上不是一个好的理由 -如果需要，只需添加"__dict__"到您的属性中。__slots__
"__dict__"
如果您需要该功能，您可以类似__weakref__地显式添加。__slots__
内置的 namedtuple 使不可变实例非常轻量级（本质上是元组的大小），但要获得好处，如果您将它们子类化，您需要自己做：
from collections import namedtuple class MyNT(namedtuple('MyNT', 'bar baz')): """MyNT is an immutable and lightweight object""" __slots__ = ()
用法：
>>> nt = MyNT('bar', 'baz') >>> nt.bar 'bar' >>> nt.baz 'baz'
并且试图分配一个意外的属性会引发一个，AttributeError因为我们已经阻止了创建__dict__：
AttributeError
>>> nt.quux = 'quux' Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: 'MyNT' object has no attribute 'quux'
您 可以__dict__通过离开来允许创建__slots__ = ()，但不能将非空__slots__与元组的子类型一起使用。
__slots__ = ()
即使多个父级的非空插槽相同，它们也不能一起使用：
class Foo(object): __slots__ = 'foo', 'bar' class Bar(object): __slots__ = 'foo', 'bar' # alas, would work if empty, i.e. () >>> class Baz(Foo, Bar): pass Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: Error when calling the metaclass bases multiple bases have instance lay-out conflict
在父级中使用空__slots__似乎提供了最大的灵活性， 允许子级选择阻止或允许 （通过添加'__dict__'以获取动态分配，参见上面 的部分）创建__dict__：
class Foo(object): __slots__ = () class Bar(object): __slots__ = () class Baz(Foo, Bar): __slots__ = ('foo', 'bar') b = Baz() b.foo, b.bar = 'foo', 'bar'
您不必 有 插槽 - 因此，如果您添加它们并稍后删除它们，它应该不会导致任何问题。
在这里 冒险：如果您正在编写mixins或使用不打算实例化的抽象基类__slots__，那么就子类的灵活性而言，这些父类中的空白似乎是最好的方法。
为了演示，首先，让我们用我们想在多重继承下使用的代码创建一个类
class AbstractBase: __slots__ = () def __init__(self, a, b): self.a = a self.b = b def __repr__(self): return f'{type(self).__name__}({repr(self.a)}, {repr(self.b)})'
我们可以通过继承和声明预期的插槽直接使用上述内容：
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
现在，如果两个基地都有非空插槽，我们就无法执行以下操作。（事实上，如果我们愿意，我们可以给AbstractBase非空槽 a 和 b，并把它们排除在下面的声明之外——把它们留在里面是错误的）：
AbstractBase
class Concretion(AbstractBase, AbstractBaseC): __slots__ = 'a b _c'.split()
现在我们通过多重继承获得了两者的功能，并且仍然可以拒绝__dict__和__weakref__实例化：
>>> c = Concretion('a', 'b') >>> c.c = c setting c! >>> c.c getting c! Concretion('a', 'b') >>> c.d = 'd' Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: 'Concretion' object has no attribute 'd'
__class__
您也许可以从__slots__ 文档的其余部分（3.7 开发文档是最新的）中梳理出进一步的警告，我最近对此做出了重要贡献。
当前的最佳答案引用了过时的信息，并且非常随意，并且在某些重要方面未达到目标。
我引用：
__slots__“如果你要实例化很多（成百上千）同一个类的对象，你会想要使用它。”
例如，来自collections模块的抽象基类没有被实例化，而是__slots__为它们声明。
collections
为什么？
如果用户希望拒绝__dict__或__weakref__创建，则这些东西在父类中必须不可用。
__slots__在创建接口或 mixin 时有助于提高可重用性。
确实，许多 Python 用户并不是为了可重用性而编写的，但是当您这样做时，可以选择拒绝不必要的空间使用是很有价值的。
腌制开槽对象时，您可能会发现它抱怨具有误导性TypeError：
TypeError
>>> pickle.loads(pickle.dumps(f)) TypeError: a class that defines __slots__ without defining __getstate__ cannot be pickled
这实际上是不正确的。此消息来自最旧的协议，这是默认协议。您可以使用参数选择最新的协议-1。在 Python 2.7 中是2（在 2.3 中引入），在 3.6 中是4.
-1
2
4
>>> pickle.loads(pickle.dumps(f, -1)) <__main__.Foo object at 0x1129C770>
在 Python 2.7 中：
>>> pickle.loads(pickle.dumps(f, 2)) <__main__.Foo object at 0x1129C770>
在 Python 3.6 中
>>> pickle.loads(pickle.dumps(f, 4)) <__main__.Foo object at 0x1129C770>
所以我会记住这一点，因为这是一个已解决的问题。
第一段是一半简短的解释，一半是预测性的。这是唯一真正回答问题的部分
正确使用__slots__是为了节省对象的空间。与允许随时向对象添加属性的动态字典不同，有一个不允许在创建后添加的静态结构。这为每个使用插槽的对象节省了一个 dict 的开销
后半段是一厢情愿，而且离题：
虽然这有时是一个有用的优化，但如果 Python 解释器足够动态，那么它就完全没有必要了，以至于它只需要 dict 实际添加到对象时。
Python 实际上做了类似的事情，只是在__dict__访问时创建，但是创建大量没有数据的对象是相当荒谬的。
第二段过于简单化并忽略了要避免的实际原因__slots__。以下 不是 避免插槽的真正原因（出于 实际 原因，请参阅上面的其余答案。）：
它们以一种可能被控制狂和静态打字小鬼滥用的方式改变了具有插槽的对象的行为。
然后继续讨论用 Python 实现这个不正当目标的其他方法，而不讨论与__slots__.
第三段则是一厢情愿。总的来说，它主要是回答者甚至没有创作的不合时宜的内容，并且为该网站的批评者提供了弹药。
创建一些普通对象和开槽对象：
>>> class Foo(object): pass >>> class Bar(object): __slots__ = ()
实例化其中的一百万个：
>>> foos = [Foo() for f in xrange(1000000)] >>> bars = [Bar() for b in xrange(1000000)]
检查guppy.hpy().heap()：
guppy.hpy().heap()
>>> guppy.hpy().heap() Partition of a set of 2028259 objects. Total size = 99763360 bytes. Index Count % Size % Cumulative % Kind (class / dict of class) 0 1000000 49 64000000 64 64000000 64 __main__.Foo 1 169 0 16281480 16 80281480 80 list 2 1000000 49 16000000 16 96281480 97 __main__.Bar 3 12284 1 987472 1 97268952 97 str ...
访问常规对象及其__dict__并再次检查：
>>> for f in foos: ... f.__dict__ >>> guppy.hpy().heap() Partition of a set of 3028258 objects. Total size = 379763480 bytes. Index Count % Size % Cumulative % Kind (class / dict of class) 0 1000000 33 280000000 74 280000000 74 dict of __main__.Foo 1 1000000 33 64000000 17 344000000 91 __main__.Foo 2 169 0 16281480 4 360281480 95 list 3 1000000 33 16000000 4 376281480 99 __main__.Bar 4 12284 0 987472 0 377268952 99 str ...
这与 Python 的历史是一致的，来自Unifying types and classes in Python 2.2
如果子类化一个内置类型，额外的空间会自动添加到实例中以容纳__dict__和__weakrefs__. （__dict__虽然在您使用它之前不会初始化，因此您不必担心创建的每个实例的空字典占用的空间。）如果您不需要这个额外的空间，您可以将短语“ __slots__ = []”添加到你的班。
__weakrefs__
__slots__ = []
