子类中 __slots__ 的继承实际上是如何工作的？

Posted 2023-02-22

【中文标题】子类中 __slots__ 的继承实际上是如何工作的？

【英文标题】：How does inheritance of __slots__ in subclasses actually work?

【发布时间】：2010-12-21 10:47:51

【问题描述】：

在Python data model reference section on slots 中有一个使用__slots__ 的注意事项列表。我对第 1 项和第 6 项感到非常困惑，因为它们似乎相互矛盾。

第一项：

当从一个类继承时没有 __slots__，__dict__ 属性 该类的将永远是 可访问，所以__slots__ 子类中的定义是 毫无意义。

第六条：

__slots__ 的操作 声明仅限于类 它在哪里定义。因此， 子类将有一个__dict__ 除非他们也定义了__slots__ （其中必须只包含任何名称 额外的插槽）。

在我看来，这些项目可以更好地措辞或通过代码显示，但我一直在努力解决这个问题，但仍然感到困惑。我确实了解 __slots__ 和 supposed to be used 的区别，我正在努力更好地了解它们的工作原理。

问题：

谁能用简单的语言向我解释子类化时插槽继承的条件是什么？

（简单的代码示例会有所帮助，但不是必需的。）

【参考方案1】：

正如其他人所提到的，定义__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__ 对于 setting 属性具有更大的相对优势，但在所有，对于获得来说确实是一个微小的缺点优势）。

现在，关于继承：对于无字典的实例，其继承链上的所有类也必须具有无字典的实例。具有无字典实例的类是定义__slots__ 的类，以及大多数内置类型（实例具有字典的内置类型是那些您可以在其实例上设置任意属性的类，例如函数）。插槽名称的重叠是不被禁止的，但它们是无用的，并且会浪费一些内存，因为插槽是继承的：

>>> class A(object): __slots__='a'
... 
>>> class AB(A): __slots__='b'
... 
>>> ab=AB()
>>> ab.a = ab.b = 23
>>> 

如您所见，您可以在AB 实例上设置属性a ——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

所以真的没有理由这样做。

【讨论】：

根据文档docs.python.org/2/reference/datamodel.html#slots "如果一个类定义了一个也定义在基类中的槽，则由基类槽定义的实例变量是不可访问的（除非直接从基类中检索其描述符类）。这使得程序的含义未定义。将来，可能会添加一个检查来防止这种情况。” - 这个未定义的行为让我有点担心 - 我已经问过了（***.com/q/41159714/281545）但没有得到答案

对dict-less这个词的创造的精彩解释和赞誉

插槽也可以确保类的对象不会获得不需要的属性。

我不会说 sole 的原因 - 像 PyCharm 或 linter 这样的 IDE 可以使用 slots 在代码中发现错误之前执行。

【参考方案2】：

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__。它只是以牺牲一些灵活性为代价来节省内存。除非你有数以万计的对象，否则没关系。

【参考方案3】：

Python：子类中__slots__ 的继承实际上是如何工作的？

我对第 1 项和第 6 项感到非常困惑，因为它们似乎相互矛盾。

这些项目实际上并不矛盾。第一个涉及不实现__slots__ 的类的子类，第二个涉及确实实现__slots__ 的类的子类。

没有实现__slots__的类的子类

我越来越意识到，尽管 Python 文档（正确地）享有盛誉，但它们并不完美，尤其是在该语言使用较少的特性方面。我将更改docs 如下：

从没有__slots__ 的类继承时，__dict__ 属性 该类的 将始终可访问，因此__slots__ 中的定义 子类是没有意义的。

__slots__ 对于这样的类仍然有意义。它记录了类属性的预期名称。它还为这些属性创建槽——它们将获得更快的查找并使用更少的空间。它只允许其他属性，这些属性将分配给__dict__。

这个change has been accepted，现在在latest documentation。

这是一个例子：

class Foo: 
    """instances have __dict__"""

class Bar(Foo):
    __slots__ = 'foo', 'bar'

Bar 不仅有它声明的槽，它还有 Foo 的槽——包括__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'

（有关__slots__、see my answer here的更多信息。）

【参考方案4】：

根据您链接的答案：

正确使用__slots__ 是为了节省对象空间。而不是动态字典...

“当从没有__slots__的类继承时，该类的__dict__属性将始终可访问”，因此添加自己的__slots__不能阻止对象具有__dict__，并且不能节省空间。

关于__slots__ 未被继承的说法有点迟钝。请记住，它是一个魔术属性，并且其行为与其他属性不同，然后重新阅读，说此魔术插槽行为不是继承的。 （这就是它的全部内容。）

【讨论】：

同意它有点迟钝，绝对可以从您的简洁回复中受益。谢谢。

【参考方案5】：

我的理解如下：

类X没有__dict__<------->类X及其超类都指定了__slots__

在这种情况下，类的实际槽由__slots__ 声明的联合组成，用于X 及其超类；如果这个联合不是不相交的，则行为是未定义的（并将成为错误）

【讨论】：

union is not disjoint 不是简单英语的短语。 :) 正如@Alex Martelli 所表明的，如果 slots 集合不是不相交的，则这不是错误。否则——很好的总结。

@J.F.Sebastian 如果它们不相交，则“程序的含义未定义”。文档明确说明了这一点。