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

Question

在Python 数据模型关于 slots 的参考文档中，有一些关于使用__slots__的说明。我对第一条和第六条感到非常困惑，因为它们似乎在互相矛盾。

第一条：

• 当从一个没有__slots__的类继承时，那个类的__dict__属性总是可以访问的，所以在子类中定义__slots__是没有意义的。

第六条：

• __slots__声明的作用仅限于定义它的类。因此，子类会有__dict__，除非它们也定义了__slots__（而且只能包含任何额外的 slots 名称）。

我觉得这些内容可以用更清晰的语言表达出来，或者通过代码示例来说明，但我一直在努力理解这个问题，还是感到困惑。我明白__slots__是应该如何使用的，并且我想更好地掌握它们的工作原理。

问题：

能不能用简单的语言给我解释一下在子类化时，继承 slots 的条件是什么？

(简单的代码示例会很有帮助，但不是必须的。)

Answer 1

Python：子类如何继承__slots__的实际工作原理是什么？

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

其实这两条内容并不矛盾。第一条是关于那些没有实现__slots__的类的子类，第二条则是关于那些有实现__slots__的类的子类。

没有实现__slots__的类的子类

我越来越意识到，虽然Python的文档被认为非常优秀，但它们并不完美，尤其是在一些不常用的特性上。我会这样修改文档：

当从一个没有__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__和__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__的更多信息，请查看我的回答。）

Answer 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__。这个东西主要是为了节省内存，但会牺牲一些灵活性。除非你有成千上万个对象，否则用不用它都没什么大不了的。

Answer 3

正如其他人提到的，定义 __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

从这个来看，使用了 __slots__ 的对象似乎比没有使用的对象要大！但这是个误解，因为 sys.getsizeof 并没有考虑“对象内容”，比如字典：

>>> sys.getsizeof(n.__dict__)
140

仅仅字典就占用了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
>>> 

正如你所看到的，你可以在 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

所以其实没有必要这样做。