75

在关于插槽的 Python 数据模型参考部分中，有一个关于使用__slots__. 我对第 1 项和第 6 项感到非常困惑，因为它们似乎相互矛盾。

第一项：

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

第六项：

  • 声明的作用__slots__ 仅限于定义它的类。因此，子类将有一个__dict__ 除非它们也定义__slots__ （它必须只包含任何附加插槽的名称）。

在我看来，这些项目可以更好地措辞或通过代码显示，但我一直在努力解决这个问题，但仍然感到困惑。我确实了解应该如何使用__slots__，并且我正在尝试更好地了解它们的工作原理。

问题：

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

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

4

5 回答 5

124

正如其他人所提到的，定义的唯一原因__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__，但根本没有，实际上是获得它的微小优势）。

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

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

如您所见，您可以a在AB实例上设置属性——AB它本身只定义了 slot ，b但它继承了 slot 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

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

于 2009-11-29T20:20:43.040 回答
20 
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__在不久的将来使用。它只是以牺牲一些灵活性为代价来节省内存。除非您有数以万计的对象，否则这无关紧要。

于 2009-11-29T19:34:53.447 回答
8

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

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

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

未实现的类的子类__slots__

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

当从一个类 without 继承时，该类__slots__的__dict__属性总是可以访问的，因此__slots__子类中的定义是没有意义的。

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

此更改已被接受，现在位于最新文档中。

这是一个例子：

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__and __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__，请在此处查看我的答案。）

于 2016-08-17T16:58:41.513 回答
2

从您链接的答案中：

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

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

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

于 2009-11-29T19:35:17.690 回答
1

我的理解如下：

  • 类X没有__dict__ <------->类X，并且它的超类都__slots__指定了

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

于 2009-11-29T19:22:38.240 回答