Python高级技术之：深入`__slots__`：它如何节省内存，以及它的局限性。 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

各位观众老爷们，晚上好！我是你们的老朋友，今晚咱们聊点硬核的 – Python的__slots__。这玩意儿就像个藏宝图，知道的人能挖到内存优化的金矿，不知道的人…那就继续在内存的汪洋大海里漂泊吧。

开场白：内存，万恶之源？

在开始之前，咱们先来聊聊为啥要关心内存。很简单，程序跑得慢，有时候不是CPU不行，不是算法太蠢，而是内存不够用，频繁地进行垃圾回收（GC）。而GC，大家都懂的，世界难题，性能杀手。所以，优化内存使用，某种程度上就是优化程序的性能。

正文开始：__slots__是个啥？

__slots__，顾名思义，就是“槽位”。它是一个类变量，允许你显式地声明一个类实例可以拥有的属性。听起来有点抽象？没关系，咱们先看个反例，然后再来解释。

class NormalClass:
    def __init__(self, name, age):
        self.name = name
        self.age = age

instance = NormalClass("Alice", 30)
instance.city = "New York" # 动态添加属性，没问题！
print(instance.name, instance.age, instance.city) # 输出: Alice 30 New York

这段代码很普通，定义了一个类NormalClass，然后创建了一个实例instance，并且动态地给这个实例添加了一个属性city。在Python的世界里，默认情况下，每个类的实例都会有一个__dict__属性。这个__dict__就是一个字典，用来存储实例的所有属性和对应的值。

现在，咱们看看使用了__slots__的类会发生什么：

class SlotsClass:
    __slots__ = ('name', 'age') # 明确声明这个类只能有name和age属性
    def __init__(self, name, age):
        self.name = name
        self.age = age

instance = SlotsClass("Bob", 25)
# instance.city = "London"  # 这行会报错！AttributeError: 'SlotsClass' object has no attribute 'city'
print(instance.name, instance.age) # 输出: Bob 25

# 尝试访问 __dict__
try:
    print(instance.__dict__)
except AttributeError as e:
    print(f"Error: {e}") # 输出: Error: 'SlotsClass' object has no attribute '__dict__'

看到了吗？使用了__slots__之后，你不能再随意地给实例添加属性了。试图添加city属性会导致AttributeError。并且，实例也没有了__dict__属性。

__slots__如何节省内存？

关键就在于没有了__dict__。 Python的字典是出了名的内存大户。它需要维护大量的哈希表、键值对等等信息。如果一个类有很多实例，每个实例都带着一个__dict__，那内存占用量就相当可观了。

使用了__slots__之后，Python会用一种更加紧凑的数据结构来存储实例的属性。这种数据结构类似于一个固定大小的数组，数组的每个元素对应一个__slots__中定义的属性。因为数组的大小是固定的，所以占用的内存也更加可控。

为了更直观地说明内存节省的效果，咱们来做个简单的实验。

import sys
import tracemalloc

class NormalClass:
    def __init__(self, name, age):
        self.name = name
        self.age = age

class SlotsClass:
    __slots__ = ('name', 'age')
    def __init__(self, name, age):
        self.name = name
        self.age = age

def measure_memory(cls, num_instances):
    tracemalloc.start()
    instances = [cls("Test", i) for i in range(num_instances)]
    _, peak = tracemalloc.get_traced_memory()
    tracemalloc.stop()
    del instances # 清理内存，避免影响后续测试
    return peak

num_instances = 100000

memory_normal = measure_memory(NormalClass, num_instances)
memory_slots = measure_memory(SlotsClass, num_instances)

print(f"NormalClass memory usage: {memory_normal / 1024:.2f} KB")
print(f"SlotsClass memory usage: {memory_slots / 1024:.2f} KB")
print(f"Memory saving: {(memory_normal - memory_slots) / memory_normal * 100:.2f}%")

这段代码会创建大量的NormalClass和SlotsClass的实例，然后测量它们占用的内存大小。通过比较，你可以看到使用__slots__可以节省多少内存。实际节省的比例取决于类的属性数量和实例的数量，但通常情况下，都能节省不少内存。

__slots__的局限性

__slots__虽然能节省内存，但它也不是万能的。它有一些局限性，需要你在使用时注意：

动态添加属性的限制： 这是最明显的局限性。使用了__slots__之后，你不能再动态地给实例添加属性了。如果你的代码依赖于动态添加属性，那么__slots__可能就不适合你。
多重继承的复杂性： 如果一个类继承自多个使用了__slots__的父类，那么情况会变得比较复杂。如果父类的__slots__中有相同的属性名，那么可能会导致冲突。 Python的MRO（Method Resolution Order）会决定哪个父类的__slots__起作用，但最好还是避免这种情况。
需要定义所有属性： 你需要在__slots__中定义所有你想要使用的属性。如果你忘记定义某个属性，那么在访问这个属性时会报错。
无法使用弱引用： 如果一个类使用了__slots__，并且没有定义__weakref__，那么这个类的实例就无法使用弱引用。弱引用在某些场景下非常有用，例如缓存和对象跟踪。
子类的影响： 如果子类需要添加新的属性，它需要定义自己的__slots__。而且，子类的__slots__必须包含父类的__slots__中的所有属性。如果子类没有定义__slots__，那么它会创建一个__dict__，并且失去__slots__带来的内存优势。

为了更清晰地说明这些局限性，咱们再来几个例子：

例子1：多重继承

class Base1:
    __slots__ = ('x',)
    def __init__(self, x):
        self.x = x

class Base2:
    __slots__ = ('y',)
    def __init__(self, y):
        self.y = y

class Derived(Base1, Base2):
    __slots__ = ('z',)
    def __init__(self, x, y, z):
        Base1.__init__(self, x)
        Base2.__init__(self, y)
        self.z = z

instance = Derived(1, 2, 3)
print(instance.x, instance.y, instance.z) # 输出: 1 2 3

在这个例子中，Derived类继承自Base1和Base2，并且定义了自己的__slots__。这样可以避免属性冲突，并且保持内存优势。

例子2：子类没有定义__slots__

class Base:
    __slots__ = ('x',)
    def __init__(self, x):
        self.x = x

class Derived(Base):
    def __init__(self, x, y):
        Base.__init__(self, x)
        self.y = y # 自动创建了 __dict__

instance = Derived(1, 2)
print(instance.x, instance.y) # 输出: 1 2
print(instance.__dict__) # 输出: {'y': 2}

在这个例子中，Derived类没有定义__slots__，所以它会自动创建一个__dict__。这样就失去了__slots__带来的内存优势。而且，Derived类的实例可以随意添加属性，这与__slots__的初衷相悖。

例子3：弱引用

import weakref

class SlotsClass:
    __slots__ = ('name', 'age')
    def __init__(self, name, age):
        self.name = name
        self.age = age

instance = SlotsClass("Charlie", 40)

try:
    ref = weakref.ref(instance) # 会报错！
except TypeError as e:
    print(f"Error: {e}") # Error: cannot create weak reference to 'SlotsClass' object

如果要支持弱引用，需要在__slots__中添加'__weakref__'。

import weakref

class SlotsClass:
    __slots__ = ('name', 'age', '__weakref__')
    def __init__(self, name, age):
        self.name = name
        self.age = age

instance = SlotsClass("Charlie", 40)
ref = weakref.ref(instance) # 不会报错了
print(ref()) # <__main__.SlotsClass object at 0x...>

__slots__的最佳实践

只在需要节省内存时使用： __slots__会带来一些限制，所以只有在内存成为瓶颈时才应该考虑使用它。
在类的定义早期就考虑是否使用： 决定是否使用__slots__应该在类的设计阶段就考虑清楚，而不是在后期重构时才加入。
在__slots__中定义所有属性： 确保在__slots__中定义了所有你想要使用的属性，避免遗漏。
处理多重继承和子类的情况： 如果你的类继承自多个使用了__slots__的父类，或者你的类有子类，那么你需要仔细考虑__slots__的定义，避免冲突和问题。
如果需要弱引用，添加'__weakref__'： 如果你的类需要支持弱引用，那么需要在__slots__中添加'__weakref__'。

总结：__slots__的优缺点

为了方便大家记忆，咱们用表格来总结一下__slots__的优缺点：

特性	优点	缺点
内存占用	节省内存，特别是对于大量实例的类。
属性访问	理论上更快，因为避免了字典查找。
动态属性	禁止动态添加属性。	限制了灵活性，需要预先定义所有属性。
多重继承		处理复杂，可能导致属性冲突。
子类		子类需要定义自己的`__slots__`，并且包含父类的所有属性。如果子类没有定义`__slots__`，那么会失去内存优势。
弱引用		默认不支持弱引用，需要手动添加`'__weakref__'`。
代码可读性	提高代码的可读性，因为可以明确地知道一个类有哪些属性。

进阶：__slots__的实现原理（简单了解）

虽然咱们不需要深入到C源码层面去研究__slots__的实现，但是简单了解一下它的原理还是有帮助的。

简单来说，使用了__slots__之后，Python会创建一个描述器（Descriptor）对象来管理每个属性。描述器是一个实现了__get__、__set__和__delete__方法的类。当你访问一个属性时，Python会调用描述器的__get__方法来获取属性的值；当你设置一个属性时，Python会调用描述器的__set__方法来设置属性的值；当你删除一个属性时，Python会调用描述器的__delete__方法来删除属性的值。

通过使用描述器，Python可以更加精细地控制属性的访问和修改，从而实现__slots__的功能。

彩蛋：namedtuple的替代品？

namedtuple是Python标准库中的一个类，它可以用来创建轻量级的、不可变的类。 namedtuple的实例类似于元组，但是可以通过属性名来访问元素。

from collections import namedtuple

Point = namedtuple('Point', ['x', 'y'])
p = Point(1, 2)
print(p.x, p.y) # 输出: 1 2

namedtuple的一个缺点是它会创建一个__dict__，这会占用额外的内存。如果你需要创建大量的namedtuple实例，那么可以考虑使用__slots__来代替namedtuple。

class Point:
    __slots__ = ('x', 'y')
    def __init__(self, x, y):
        self.x = x
        self.y = y

p = Point(1, 2)
print(p.x, p.y) # 输出: 1 2

虽然这种方式稍微麻烦一些，但是可以节省内存。

总结的总结：

__slots__是一个强大的工具，可以帮助你优化Python程序的内存使用。但是，它也有一些局限性，需要在使用时注意。只有当你真正需要节省内存，并且能够克服__slots__带来的限制时，才应该考虑使用它。记住，优化是一个权衡的过程，你需要根据实际情况做出选择。

好了，今天的讲座就到这里。希望大家有所收获，也希望大家在使用__slots__时能够谨慎思考，避免踩坑。咱们下期再见！记得点赞关注哦！

Python高级技术之：深入`slots`：它如何节省内存，以及它的局限性。

发表回复取消回复

发表回复 取消回复

发表回复取消回复