好的，各位观众，欢迎来到今天的Python小课堂！今天我们要聊的是一个听起来有点高深，但实际上很有趣的话题：__slots__与继承，特别是多重继承下的__slots__行为。
__slots__：内存优化小能手，但要小心使用！
首先，让我们来认识一下__slots__。想象一下，你是一个包租婆，手底下管理着一大堆房子（对象）。传统的Python对象就像是每个房子里都有一个巨大的储物间（__dict__），里面可以随便塞东西，你想放什么属性就放什么属性。
class 传统房子:
def __init__(self, 面积, 租金):
self.面积 = 面积
self.租金 = 租金
房子1 = 传统房子(100, 5000)
房子1.朝向 = "南" # 随便添加属性
print(房子1.__dict__) # 看看储物间里都有些啥
# 输出: {'面积': 100, '租金': 5000, '朝向': '南'}这种方式很灵活，但问题是，每个房子都得配一个这么大的储物间，不管你用不用，都得占着地方。如果房子数量很多，那可就浪费大了。
这时候，__slots__就派上用场了。它就像是预先规定好每个房子里只能放哪些东西，比如只能放面积、租金，其他东西一概不许放。这样一来，就不用给每个房子都配一个巨大的储物间了，可以省下不少空间。
class slots房子:
__slots__ = ('面积', '租金') # 预先规定好只能放面积和租金
def __init__(self, 面积, 租金):
self.面积 = 面积
self.租金 = 租金
房子2 = slots房子(100, 5000)
#房子2.朝向 = "南" # 报错！因为朝向不在__slots__里
#AttributeError: 'slots房子' object has no attribute '朝向'
#print(房子2.__dict__) # 报错！因为没有__dict__
#AttributeError: 'slots房子' object has no attribute '__dict__'使用了__slots__之后，就不能随意添加属性了，而且对象也不再拥有__dict__属性。这就是它节省内存的秘密。
__slots__的优点：
- 节省内存： 特别是在创建大量对象时，效果显著。
- 限制属性： 可以防止随意添加属性，提高代码的可维护性。
- 性能提升： 在某些情况下，属性访问速度可能会更快。
__slots__的缺点：
- 灵活性降低： 不能随意添加属性。
- 继承问题： 在继承时需要特别注意，这是我们今天要重点讨论的内容。
- 无法进行弱引用: 因为弱引用需要
__dict__
单继承下的__slots__：还算老实
在单继承的情况下，__slots__的行为还算比较简单。如果父类定义了__slots__，子类可以选择：
-
不定义
__slots__： 这种情况下，子类会继承父类的__slots__，并且会拥有一个__dict__，可以随意添加属性。相当于子类放弃了__slots__的内存优化，重新变成了传统的对象。class 父类: __slots__ = ('姓名', '年龄') def __init__(self, 姓名, 年龄): self.姓名 = 姓名 self.年龄 = 年龄 class 子类(父类): def __init__(self, 姓名, 年龄, 爱好): super().__init__(姓名, 年龄) self.爱好 = 爱好 # 子类可以随意添加属性 小明 = 子类("小明", 10, "打游戏") print(小明.姓名) print(小明.爱好) print(小明.__dict__) #子类有了__dict__ #{'爱好': '打游戏'} -
定义自己的
__slots__： 这种情况下，子类会继承父类的__slots__，并且会将自己的__slots__与父类的__slots__合并。但是，如果子类要添加新的属性，必须在自己的__slots__中声明。class 父类: __slots__ = ('姓名', '年龄') def __init__(self, 姓名, 年龄): self.姓名 = 姓名 self.年龄 = 年龄 class 子类(父类): __slots__ = ('爱好',) # 子类定义了自己的__slots__ def __init__(self, 姓名, 年龄, 爱好): super().__init__(姓名, 年龄) self.爱好 = 爱好 # 必须在__slots__中声明 小明 = 子类("小明", 10, "打游戏") print(小明.姓名) print(小明.爱好) #print(小明.__dict__) # 报错！因为没有__dict__
多重继承下的__slots__：混乱的开始
多重继承是Python中一个强大的特性，但同时也带来了一些复杂性。在多重继承中，__slots__的行为会变得更加难以预测。
规则一：只有当所有父类都定义了__slots__时，子类才能使用__slots__。
如果任何一个父类没有定义__slots__（也就是拥有__dict__），那么子类就不能使用__slots__，即使子类自己定义了__slots__，也会被忽略。
class 父类1:
__slots__ = ('属性1',)
def __init__(self, 属性1):
self.属性1 = 属性1
class 父类2:
def __init__(self, 属性2):
self.属性2 = 属性2 # 没有定义__slots__，拥有__dict__
class 子类(父类1, 父类2):
__slots__ = ('属性3',) # 即使定义了__slots__，也会被忽略
def __init__(self, 属性1, 属性2, 属性3):
父类1.__init__(self, 属性1)
父类2.__init__(self, 属性2)
self.属性3 = 属性3
小明 = 子类("值1", "值2", "值3")
print(小明.属性1)
print(小明.属性2)
print(小明.属性3)
print(小明.__dict__) #子类还是有了__dict__
#{'属性3': '值3'}规则二：如果所有父类都定义了__slots__，但它们的__slots__中有重复的属性名，那么子类也不能使用__slots__。
class 父类1:
__slots__ = ('属性1', '属性2')
def __init__(self, 属性1, 属性2):
self.属性1 = 属性1
self.属性2 = 属性2
class 父类2:
__slots__ = ('属性2', '属性3') # 属性2重复了
def __init__(self, 属性2, 属性3):
self.属性2 = 属性2
self.属性3 = 属性3
class 子类(父类1, 父类2):
__slots__ = ('属性4',)
def __init__(self, 属性1, 属性2, 属性3, 属性4):
父类1.__init__(self, 属性1, 属性2)
父类2.__init__(self, 属性2, 属性3)
self.属性4 = 属性4
小明 = 子类("值1", "值2", "值3", "值4")
print(小明.属性1)
print(小明.属性2)
print(小明.属性3)
print(小明.属性4)
print(小明.__dict__)#子类还是有了__dict__
#{'属性4': '值4'}规则三：如果所有父类都定义了__slots__，且它们的__slots__中没有重复的属性名，那么子类可以使用__slots__，并且会将所有父类的__slots__与自己的__slots__合并。
class 父类1:
__slots__ = ('属性1', '属性2')
def __init__(self, 属性1, 属性2):
self.属性1 = 属性1
self.属性2 = 属性2
class 父类2:
__slots__ = ('属性3', '属性4')
def __init__(self, 属性3, 属性4):
self.属性3 = 属性3
self.属性4 = 属性4
class 子类(父类1, 父类2):
__slots__ = ('属性5',)
def __init__(self, 属性1, 属性2, 属性3, 属性4, 属性5):
父类1.__init__(self, 属性1, 属性2)
父类2.__init__(self, 属性3, 属性4)
self.属性5 = 属性5
小明 = 子类("值1", "值2", "值3", "值4", "值5")
print(小明.属性1)
print(小明.属性2)
print(小明.属性3)
print(小明.属性4)
print(小明.属性5)
#print(小明.__dict__) #子类没有了__dict__总结一下，多重继承下的__slots__行为可以总结为以下几点：
| 条件 | 结果 |
|---|---|
任何一个父类没有定义__slots__（拥有__dict__） |
子类不能使用__slots__，即使子类定义了__slots__，也会被忽略。 |
所有父类都定义了__slots__，但它们的__slots__中有重复的属性名 |
子类不能使用__slots__。 |
所有父类都定义了__slots__，且它们的__slots__中没有重复的属性名 |
子类可以使用__slots__，并且会将所有父类的__slots__与自己的__slots__合并。 |
一些建议和注意事项：
- 尽量避免在多重继承中使用
__slots__： 因为它的行为非常复杂，容易出错。如果你真的需要使用__slots__，一定要仔细阅读文档，并且进行充分的测试。 - 如果必须在多重继承中使用
__slots__，尽量保证所有父类都定义了__slots__，并且它们的__slots__中没有重复的属性名。 - 在继承时，要确保父类的
__init__方法被正确调用。 这是多重继承中一个常见的陷阱。 - 使用
__slots__可能会影响pickle序列化：__slots__对象默认无法使用pickle进行序列化和反序列化。如果需要支持pickle，需要在类中定义__getstate__和__setstate__方法。
__slots__与动态添加属性：
使用__slots__的一个直接后果是无法动态添加属性。如果你尝试这样做，会引发AttributeError。
class MyClass:
__slots__ = ('name', 'age')
def __init__(self, name, age):
self.name = name
self.age = age
obj = MyClass("Alice", 30)
#obj.city = "New York" # 报错! AttributeError: 'MyClass' object has no attribute 'city'__slots__与描述器（Descriptors）：
__slots__可以与描述器一起使用，但需要注意一些细节。描述器可以让你控制属性的访问、设置和删除行为。
class MyDescriptor:
def __get__(self, instance, owner):
if instance is None:
return self
return instance._my_attribute
def __set__(self, instance, value):
instance._my_attribute = value
class MyClass:
__slots__ = ('_my_attribute',)
my_property = MyDescriptor()
def __init__(self):
self.my_property = 10
obj = MyClass()
print(obj.my_property) # 输出: 10
obj.my_property = 20
print(obj.my_property) # 输出: 20在这个例子中，my_property是一个描述器，它控制对_my_attribute的访问。_my_attribute被声明在__slots__中，因此可以正常工作。
总结：__slots__，用还是不用？
__slots__是一个强大的工具，可以帮助你优化Python程序的内存使用。但是，它也有一些限制，需要小心使用。
什么时候应该使用__slots__？
- 当你需要创建大量对象，并且对内存使用非常敏感时。
- 当你希望限制对象的属性，提高代码的可维护性时。
什么时候应该避免使用__slots__？
- 当你需要频繁地动态添加属性时。
- 当你使用多重继承，并且难以满足
__slots__的限制条件时。 - 当你需要支持pickle序列化，并且不想编写额外的代码时。
总而言之，__slots__是一个需要谨慎使用的工具。在使用之前，一定要仔细评估它的优缺点，并且进行充分的测试。
好了，今天的Python小课堂就到这里。希望大家对__slots__与继承有了更深入的了解。记住，编程就像盖房子，地基要打好，才能盖出稳固的大楼。而__slots__就像是地基里的一根钢筋，用好了能让房子更结实，用不好反而会适得其反。感谢大家的收看！