在Python data model reference section on slots中，有一个使用__slots__的注释列表。我对第1和第6项完全感到困惑，因为它们似乎相互矛盾。
第一项：
__slots__，__dict__属性
那个班级永远都是
可访问，所以__slots__
子类中的定义是
毫无意义。第六项：
__slots__的行动
声明仅限于班级
在哪里定义。结果是，
子类将有一个__dict__
除非他们也定义__slots__
（必须只包含任何名称
额外的插槽）。在我看来，这些项目可以更好地措辞或通过代码显示，但我一直试图绕过这个，我仍然感到困惑。我理解__slots__ supposed to be used是怎样的，我正在努力更好地了解它们的工作原理。
问题：
有人可以用简单的语言向我解释在子类化时继承槽的条件是什么？
（简单的代码示例会有所帮助，但不是必需的。）
答案 0 :(得分：100)
正如其他人所提到的，定义__slots__的唯一原因是为了节省一些内存，当你拥有一组具有预定义属性的简单对象并且不希望每个对象随身携带字典时。这当然只适用于您计划拥有多个实例的类。
节约可能不会立即显现 - 考虑......：
>>> class NoSlots(object): pass
...
>>> n = NoSlots()
>>> class WithSlots(object): __slots__ = 'a', 'b', 'c'
...
>>> w = WithSlots()
>>> n.a = n.b = n.c = 23
>>> w.a = w.b = w.c = 23
>>> sys.getsizeof(n)
32
>>> sys.getsizeof(w)
36
从这一点来看，似乎插槽尺寸更大比无插槽尺寸更大！但这是一个错误，因为sys.getsizeof不考虑“对象内容”，如字典：
>>> sys.getsizeof(n.__dict__)
140
由于dict单独需要140个字节，因此明确指出“32字节”对象n不会考虑每个实例中涉及的所有内容。您可以使用第三方扩展程序（例如pympler：
>>> import pympler.asizeof
>>> pympler.asizeof.asizeof(w)
96
>>> pympler.asizeof.asizeof(n)
288
这更清楚地显示了由__slots__保存的内存占用：对于一个简单的对象，例如这种情况，它有点小于200字节，几乎是对象总体占用空间的2/3。现在，既然这些日子对于大多数应用来说，一兆字节或多或少并不重要，这也告诉你__slots__如果你只有几千个实例就不值得打扰在某个时间 - 然而，对于数百万个实例，它肯定会产生非常重要的差异。您还可以获得微观加速（部分原因是对__slots__的小对象使用更好的缓存）：
$ python -mtimeit -s'class S(object): __slots__="x","y"' -s's=S(); s.x=s.y=23' 's.x'
10000000 loops, best of 3: 0.37 usec per loop
$ python -mtimeit -s'class S(object): pass' -s's=S(); s.x=s.y=23' 's.x'
1000000 loops, best of 3: 0.604 usec per loop
$ python -mtimeit -s'class S(object): __slots__="x","y"' -s's=S(); s.x=s.y=23' 's.x=45'
1000000 loops, best of 3: 0.28 usec per loop
$ python -mtimeit -s'class S(object): pass' -s's=S(); s.x=s.y=23' 's.x=45'
1000000 loops, best of 3: 0.332 usec per loop
但这在某种程度上取决于Python版本（这些是我用2.5重复测量的数字;对于2.6，我认为设置属性的__slots__具有更大的相对优势，但是没有，确实是一个微弱的 dis 优势，获得它。）
现在，关于继承：对于一个dict-less的实例，所有类的继承链也必须具有无字典的实例。具有无字典实例的类是定义__slots__的类，加上大多数内置类型（内置类型，其实例具有dicts，其实例可以设置任意属性，例如函数）。插槽名称中的重叠不是禁止的，但它们没用，浪费了一些内存，因为插槽是继承的：
>>> class A(object): __slots__='a'
...
>>> class AB(A): __slots__='b'
...
>>> ab=AB()
>>> ab.a = ab.b = 23
>>>
如您所见，您可以在a个实例上设置属性AB - AB本身只定义广告位b，但它会继承广告位a来自A。不禁止重复继承的插槽：
>>> class ABRed(A): __slots__='a','b'
...
>>> abr=ABRed()
>>> abr.a = abr.b = 23
但确实浪费了一些记忆：
>>> pympler.asizeof.asizeof(ab)
88
>>> pympler.asizeof.asizeof(abr)
96
因此没有理由这样做。
答案 1 :(得分：13)
class WithSlots(object):
__slots__ = "a_slot"
class NoSlots(object): # This class has __dict__
pass
class A(NoSlots): # even though A has __slots__, it inherits __dict__
__slots__ = "a_slot" # from NoSlots, therefore __slots__ has no effect
class B(WithSlots): # This class has no __dict__
__slots__ = "some_slot"
class C(WithSlots): # This class has __dict__, because it doesn't
pass # specify __slots__ even though the superclass does.
您可能不需要在不久的将来使用__slots__。它只是为了节省内存而牺牲了一些灵活性。除非你有成千上万的物品，否则无所谓。
答案 2 :(得分：4)
Python：子类中
__slots__的继承实际上如何工作？我对第1和第6项感到困惑，因为它们似乎相互矛盾。
这些项目实际上并不相互矛盾。第一个是关于不实现__slots__的类的子类，第二个是关于做实现__slots__的类的子类。
__slots__ 我越来越意识到，正如Python文档（正确地）所声称的那样，它们并不完美，特别是对于语言使用较少的功能。我会改变docs如下：
从没有
__slots__的类继承时，__dict__属性 该类的总是可以访问，因此在{。}}中定义 子类没有意义。
__slots__对于这样的课程仍然有意义。它记录了类的属性的预期名称。它还为这些属性创建插槽 - 它们将获得更快的查找并使用更少的空间。它只允许其他属性，这些属性将分配给__slots__。
此change has been accepted，现在位于latest documentation。
以下是一个例子：
__dict__ class Foo:
"""instances have __dict__"""
class Bar(Foo):
__slots__ = 'foo', 'bar'
不仅有声明的插槽，还有Foo的插槽 - 包括Bar：
__dict__>>> b = Bar()
>>> b.foo = 'foo'
>>> b.quux = 'quux'
>>> vars(b)
{'quux': 'quux'}
>>> b.foo
'foo'
__slots__声明的操作仅限于其所在的类 被定义为。因此，子类将具有__slots__，除非它们 还定义__dict__（必须包含任何其他名称 时隙）。
那也不太对劲。 __slots__声明的操作不完全限于定义它的类。例如，它们可能会影响多重继承。
我会改为：
对于定义
__slots__的继承树中的类，子类将具有__slots__，除非它们 还定义__dict__（必须包含任何其他名称 时隙）。
我实际上已将其更新为：
__slots__声明的动作不仅限于该类 在哪里定义。在父母中宣布的__slots__可用于 儿童班。但是，子子类将获得__slots__和__dict__除非他们还定义__weakref__（其中只应包含任何其他广告位的名称）。
以下是一个例子：
__slots__我们看到一个开槽类的子类可以使用插槽：
class Foo:
__slots__ = 'foo'
class Bar(Foo):
"""instances get __dict__ and __weakref__"""
（有关>>> b = Bar()
>>> b.foo = 'foo'
>>> b.bar = 'bar'
>>> vars(b)
{'bar': 'bar'}
>>> b.foo
'foo'
，see my answer here的更多信息。）
答案 3 :(得分：2)
从您链接的答案：
正确使用
__slots__是为了节省对象中的空间。而不是一个动态的词典...
“从没有__slots__的类继承时，该类的__dict__属性将始终可访问”，因此添加自己的__slots__无法阻止对象{{1} }，并且无法节省空间。
关于__dict__未被继承的位有点迟钝。请记住，它是一个神奇的属性，并且不像其他属性那样，然后重新读取，因为这个魔术插槽行为不会被继承。 （这就是它的全部内容。）
答案 4 :(得分：1)
我的理解如下：
班级X没有__dict__ <------->班级X，其超类都指定了__slots__
在这种情况下，类的实际插槽由__slots__及其超类的X声明的并集组成;如果此联合不是不相交的