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

Question

在插槽上的Python数据模型参考部分中,有一个使用说明列表__slots__.我对第1和第6项完全感到困惑,因为它们似乎相互矛盾.

第一项:

• 从没有继承的类继承时,该类 __slots__的__dict__属性将始终可访问,因此__slots__ 子类中的定义毫无意义.

第六项:

• 一个的动作__slots__ 声明限制为定义它的类.因此,子类将具有一个,__dict__ 除非它们也定义__slots__ (它必须只包含任何其他槽的名称).

在我看来,这些项目可以更好地措辞或通过代码显示,但我一直试图绕过这个,我仍然感到困惑.我不明白怎么__slots__都应该被使用,而我试图让他们的工作更好地把握.

问题:

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

(简单的代码示例会有所帮助,但不是必需的.)

Answer 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个字节,n因此据称"32字节"对象明显不考虑每个实例中涉及的所有内容.您可以使用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

所以没有理由这样做.

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

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__在父类中声明可在子类中使用。但是，子子类将获得 a __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__，请在此处查看我的答案。）