Python `__slots__` 与继承：多重继承下的 `__slots__` 行为

好的，各位观众，欢迎来到今天的“Python的__slots__：继承大乱斗”特别节目！我是你们的导游，今天我们将深入探讨Python中一个既能省内存又能带来一些复杂性的特性——__slots__，尤其是在涉及到继承，尤其是多重继承的时候。

准备好了吗？让我们开始这场代码冒险吧！

什么是__slots__？

简单来说，__slots__ 是一个类变量，它允许你显式地声明对象应该拥有的属性（attribute）。默认情况下，Python 使用 __dict__ 来存储对象的属性，这是一个动态的字典，可以随时添加新的属性。但是，对于有很多实例的类来说，这个 __dict__ 会占用大量的内存。

__slots__ 的作用就是告诉 Python：“嘿，哥们，这个类的实例只会用到这些属性，别再浪费内存搞 __dict__ 了！”

举个例子：

class Point:
    __slots__ = ('x', 'y')

    def __init__(self, x, y):
        self.x = x
        self.y = y

p = Point(10, 20)
print(p.x, p.y)

# 尝试添加未声明的属性会报错
# p.z = 30  # AttributeError: 'Point' object has no attribute 'z'

在这个例子中，我们定义了一个 Point 类，并使用 __slots__ = ('x', 'y') 声明了它只有 x 和 y 两个属性。这意味着 Point 类的实例不再拥有 __dict__，而是直接在对象本身的空间里存储 x 和 y 的值。

__slots__ 的优点

节省内存： 这是 __slots__ 最主要的目的。通过避免使用 __dict__，可以显著减少对象的内存占用，尤其是在创建大量对象时。
更快的属性访问： 理论上，访问 __slots__ 中定义的属性比访问 __dict__ 中的属性更快，因为前者不需要进行字典查找。

__slots__ 的缺点

灵活性降低： 你不能动态地添加新的属性，必须提前在 __slots__ 中声明。
继承的复杂性： 当涉及到继承时，__slots__ 的行为会变得比较复杂，需要仔细考虑。
不能使用 __weakref__： 除非你在 __slots__ 中显式地包含 __weakref__，否则该类的实例将不能被弱引用。

__slots__ 与继承：单继承的情况

当一个类继承自另一个使用了 __slots__ 的类时，情况会稍微复杂一些。

子类也使用 __slots__： 如果子类也定义了 __slots__，那么父类和子类的 __slots__ 会合并。这意味着子类的实例将只拥有父类和子类 __slots__ 中声明的属性，而没有 __dict__。

class Point:
    __slots__ = ('x', 'y')

    def __init__(self, x, y):
        self.x = x
        self.y = y

class ColorPoint(Point):
    __slots__ = ('color',)

    def __init__(self, x, y, color):
        super().__init__(x, y)
        self.color = color

cp = ColorPoint(10, 20, 'red')
print(cp.x, cp.y, cp.color)

# cp.__dict__  # AttributeError: 'ColorPoint' object has no attribute '__dict__'

子类不使用 __slots__： 如果子类没有定义 __slots__，那么子类的实例将会拥有 __dict__。这意味着你可以动态地添加新的属性到子类的实例中。但是，这也会抵消父类使用 __slots__ 带来的内存节省效果，因为每个子类实例都会有一个 __dict__。

class Point:
    __slots__ = ('x', 'y')

    def __init__(self, x, y):
        self.x = x
        self.y = y

class ColorPoint(Point):
    def __init__(self, x, y, color):
        super().__init__(x, y)
        self.color = color

cp = ColorPoint(10, 20, 'red')
print(cp.x, cp.y, cp.color)

cp.opacity = 0.5 # 可以动态添加属性
print(cp.opacity)
print(cp.__dict__) # 子类有 __dict__

__slots__ 与多重继承：真正的挑战

多重继承是 __slots__ 最容易出错的地方。当一个类继承自多个使用了 __slots__ 的类时，需要特别小心。

所有父类都定义了 __slots__： 这是最常见的情况，也是最容易出错的情况。如果所有父类都定义了 __slots__，那么子类必须也定义 __slots__，并且包含所有父类的 __slots__ 中声明的属性。否则，将会抛出 TypeError 异常。

class Base1:
    __slots__ = ('a',)

    def __init__(self, a):
        self.a = a

class Base2:
    __slots__ = ('b',)

    def __init__(self, b):
        self.b = b

# 错误示范：缺少 __slots__ 定义
# class Derived(Base1, Base2):
#     def __init__(self, a, b):
#         Base1.__init__(self, a)
#         Base2.__init__(self, b)

# 正确示范：定义了 __slots__，并且包含了所有父类的属性
class Derived(Base1, Base2):
    __slots__ = ('a', 'b', 'c') # 必须包含父类的所有slots

    def __init__(self, a, b, c):
        Base1.__init__(self, a)
        Base2.__init__(self, b)
        self.c = c

d = Derived(1, 2, 3)
print(d.a, d.b, d.c)

在这个例子中，Derived 类继承自 Base1 和 Base2，它们都定义了 __slots__。因此，Derived 类也必须定义 __slots__，并且包含 Base1 的 a 和 Base2 的 b 属性。

如果 Derived 类没有定义 __slots__，或者没有包含所有父类的属性，那么将会抛出 TypeError: multiple bases have instance lay-out conflict 异常。

部分父类定义了 __slots__： 如果只有部分父类定义了 __slots__，那么子类可以选择是否定义 __slots__。
- 子类定义了 __slots__： 子类必须包含所有定义了 __slots__ 的父类的属性。
- 子类没有定义 __slots__： 子类的实例将会拥有 __dict__，可以动态地添加新的属性。

class Base1:
    __slots__ = ('a',)

    def __init__(self, a):
        self.a = a

class Base2:
    def __init__(self, b):
        self.b = b
        self.__dict__['b'] = b # 必须显式地将b加入到__dict__中，否则访问会报错

# 子类定义了 __slots__
class Derived1(Base1, Base2):
    __slots__ = ('a', 'c')

    def __init__(self, a, b, c):
        Base1.__init__(self, a)
        Base2.__init__(self, b)
        self.c = c

d1 = Derived1(1, 2, 3)
print(d1.a, d1.c)
print(d1.__dict__) # 没有__dict__
# print(d1.b)  # 报错，没有定义__getattribute__方法，无法访问

# 子类没有定义 __slots__
class Derived2(Base1, Base2):
    def __init__(self, a, b, c):
        Base1.__init__(self, a)
        Base2.__init__(self, b)
        self.c = c

d2 = Derived2(1, 2, 3)
print(d2.a, d2.b, d2.c)
print(d2.__dict__) # 有__dict__，包含c

菱形继承： 菱形继承是一种特殊的多重继承，其中一个类继承自两个或多个类，而这些类又继承自同一个基类。在这种情况下，__slots__ 的处理方式与普通的多重继承相同。

一些额外的注意事项

__slots__ 和 __dict__： 如果一个类定义了 __slots__，并且没有在 __slots__ 中包含 __dict__，那么该类的实例将不会拥有 __dict__。这意味着你不能动态地添加新的属性到该类的实例中。
__slots__ 和 __weakref__： 类似地，如果一个类定义了 __slots__，并且没有在 __slots__ 中包含 __weakref__，那么该类的实例将不能被弱引用。
__slots__ 和属性描述符： __slots__ 可以与属性描述符一起使用，以实现更复杂的属性访问控制。

总结

__slots__ 是一个强大的特性，可以帮助你节省内存，但同时也带来了一些复杂性，尤其是在涉及到继承时。在使用 __slots__ 时，需要仔细考虑以下几点：

是否真的需要节省内存？
是否需要动态地添加新的属性？
是否需要支持弱引用？
如果涉及到继承，需要仔细考虑父类和子类的 __slots__ 定义。

为了帮助大家更好地理解__slots__在不同继承场景下的行为，我整理了一个表格：

继承场景	父类定义了 `__slots__`	子类定义了 `__slots__`	子类实例是否有 `__dict__`	是否可以动态添加属性	是否必须包含父类的 `__slots__`
单继承	是	是	否	否	是
单继承	是	否	是	是	N/A
多重继承（全部父类）	是	是	否	否	是
多重继承（部分父类）	部分是	是	否	否	是 (针对有 `__slots__` 的父类)
多重继承（部分父类）	部分是	否	是	是	N/A

最佳实践

只在确实需要节省内存时才使用 __slots__。 不要为了使用而使用。
在定义 __slots__ 时，尽量包含所有可能用到的属性。 避免将来需要动态添加属性的情况。
如果需要支持弱引用，确保在 __slots__ 中包含 __weakref__。
在多重继承时，仔细考虑父类和子类的 __slots__ 定义，避免出现 TypeError 异常。
编写单元测试，验证 __slots__ 的行为是否符合预期。

最后的忠告

__slots__ 就像一把双刃剑，用得好可以节省内存，用不好可能会带来麻烦。只有真正理解了它的行为，才能在合适的场景下发挥它的威力。

希望今天的讲座能够帮助大家更好地理解 __slots__，并在实际项目中做出明智的决策。

谢谢大家！下次再见！

Python `slots` 与继承：多重继承下的 `slots` 行为

发表回复取消回复

发表回复 取消回复

发表回复取消回复