Python的`__slots__`与对象字典：内存节省与属性查找性能的底层权衡 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

Python的`slots`与对象字典：内存节省与属性查找性能的底层权衡

大家好，今天我们来深入探讨Python中一个经常被提及但可能不够理解的特性：__slots__。我们将从对象的内存结构和属性查找机制入手，理解__slots__如何影响对象的内存占用和属性访问速度，并探讨在实际应用中如何权衡使用__slots__。

Python对象的内存结构

要理解__slots__的作用，首先需要了解Python对象在内存中的结构。在Python中，一切皆对象。每个对象都包含以下信息：

类型指针 (Type Pointer): 指向对象的类型对象，类型对象定义了对象的行为和属性。
引用计数 (Reference Count): 用于垃圾回收，记录有多少个引用指向该对象。
对象数据 (Object Data): 存储对象实际的数据。

对于普通的Python对象，其对象数据通常存储在一个字典 (__dict__) 中。这个字典以字符串作为键，存储对象的属性和对应的值。例如，我们定义一个简单的类：

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

obj = MyClass(10, 20)
print(obj.__dict__)  # 输出: {'x': 10, 'y': 20}

在这个例子中，obj 对象的数据存储在 obj.__dict__ 中，包含属性 x 和 y 及其对应的值。

这种基于字典的存储方式非常灵活，允许我们在运行时动态地添加、删除属性。但是，这种灵活性是有代价的：

内存占用： 字典本身会占用额外的内存空间。此外，字典的键（属性名）通常是字符串，字符串对象也会占用一定的内存。如果创建大量对象，每个对象都有一个字典，那么总的内存占用就会非常可观。
属性查找： 查找字典中的键值对需要进行哈希运算，这比直接访问内存地址要慢。

`slots`的引入：优化内存占用

__slots__ 就是为了解决上述问题而引入的。通过在类定义中声明 __slots__，我们可以告诉Python解释器：这个类的实例只有这些属性，不要为每个实例创建 __dict__。

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

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

obj_with_slots = MyClassWithSlots(10, 20)
# print(obj_with_slots.__dict__)  # 会抛出 AttributeError: 'MyClassWithSlots' object has no attribute '__dict__'

在这个例子中，我们声明了 __slots__ = ('x', 'y')。这意味着 MyClassWithSlots 的实例只有 x 和 y 两个属性。Python解释器会为这两个属性分配固定的内存空间，而不是使用字典来存储。因此，MyClassWithSlots 的实例不再具有 __dict__ 属性。

内存节省的原理：

使用 __slots__ 后，对象的数据不再存储在字典中，而是直接存储在对象的内存空间中，相当于将属性名和偏移量绑定，通过偏移量直接访问属性值。这可以显著减少对象的内存占用，尤其是在创建大量对象时。

示例：内存占用对比

为了更直观地展示 __slots__ 对内存的影响，我们使用 sys.getsizeof() 函数来测量对象的大小。

import sys

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

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

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

obj = MyClass(10, 20)
obj_with_slots = MyClassWithSlots(10, 20)

print(f"MyClass object size: {sys.getsizeof(obj)}")
print(f"MyClassWithSlots object size: {sys.getsizeof(obj_with_slots)}")

在我的机器上，运行结果如下：

MyClass object size: 64
MyClassWithSlots object size: 48

可以看到，使用了 __slots__ 的 MyClassWithSlots 对象比普通的 MyClass 对象小 16 字节。虽然单个对象的内存节省可能不多，但如果创建成千上万个对象，节省的内存将非常可观。

为了进一步验证，我们可以使用 memory_profiler 模块来更详细地分析内存使用情况。

# 需要安装 memory_profiler: pip install memory_profiler

from memory_profiler import profile

@profile
def create_objects():
    objects = [MyClass(i, i * 2) for i in range(10000)]
    objects_with_slots = [MyClassWithSlots(i, i * 2) for i in range(10000)]
    return objects, objects_with_slots

objects, objects_with_slots = create_objects()

运行这段代码，memory_profiler 会生成一个详细的内存使用报告，显示在创建大量对象时，使用 __slots__ 可以显著降低内存占用。

总结：

__slots__ 通过避免创建 __dict__，从而减少了对象的内存占用。这对于内存敏感的应用，例如处理大量数据的应用，非常有意义。

`slots`对属性查找性能的影响

除了内存占用，__slots__ 还会影响属性查找的性能。由于对象的数据不再存储在字典中，而是直接存储在对象的内存空间中，因此属性访问的速度会更快。

原理：

当访问一个对象的属性时，Python解释器首先会检查对象是否具有 __slots__。如果对象具有 __slots__，则解释器会直接访问对象内存中对应于该属性的偏移量，从而获取属性值。这种直接访问内存的方式比查找字典要快得多。

示例：性能对比

为了测试 __slots__ 对属性访问速度的影响，我们可以使用 timeit 模块来测量属性访问的时间。

import timeit

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

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

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

obj = MyClass(10, 20)
obj_with_slots = MyClassWithSlots(10, 20)

def access_attribute(obj):
    return obj.x

def access_attribute_with_slots(obj):
    return obj.x

time_without_slots = timeit.timeit(lambda: access_attribute(obj), number=1000000)
time_with_slots = timeit.timeit(lambda: access_attribute_with_slots(obj_with_slots), number=1000000)

print(f"Time without slots: {time_without_slots}")
print(f"Time with slots: {time_with_slots}")

在我的机器上，运行结果如下：

Time without slots: 0.09245648100029958
Time with slots: 0.06137075799997894

可以看到，使用 __slots__ 后，属性访问速度提高了约 33%。

总结：

__slots__ 通过避免字典查找，直接访问对象内存，从而提高了属性访问速度。这对于性能敏感的应用，例如需要频繁访问对象属性的应用，非常有意义。

`slots`的限制与注意事项

虽然 __slots__ 可以节省内存和提高属性访问速度，但也存在一些限制和注意事项：

不支持动态添加属性： 一旦声明了 __slots__，就不能再动态地添加新的属性。尝试添加新的属性会抛出 AttributeError。

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

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

obj_with_slots = MyClassWithSlots(10, 20)
try:
    obj_with_slots.z = 30  # 会抛出 AttributeError
except AttributeError as e:
    print(e) # 输出: 'MyClassWithSlots' object has no attribute 'z'

继承问题： 如果一个类定义了 __slots__，那么其子类也需要定义 __slots__，否则子类仍然会使用 __dict__。如果子类需要添加新的属性，可以在子类的 __slots__ 中添加。

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

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

class MySubClass(MyClassWithSlots):
    __slots__ = ('z',)  # 添加新的属性 z

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

obj_sub = MySubClass(10, 20, 30)
print(obj_sub.x, obj_sub.y, obj_sub.z) # 输出: 10 20 30

__weakref__问题： 默认情况下，Python对象可以使用弱引用 (weak reference)。如果一个类定义了 __slots__，并且没有包含 __weakref__，那么该类的实例就不能被弱引用。如果需要支持弱引用，需要在 __slots__ 中包含 __weakref__。

import weakref

class MyClassWithSlots:
    __slots__ = ('x', 'y', '__weakref__') # 需要显式声明 __weakref__

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

obj_with_slots = MyClassWithSlots(10, 20)
ref = weakref.ref(obj_with_slots)
print(ref()) # 输出: <__main__.MyClassWithSlots object at 0x...>

元类 (Metaclass) 的影响： 如果使用了元类，需要确保元类正确处理 __slots__。
与动态语言特性的冲突： __slots__ 限制了对象动态添加属性的能力，这与Python作为动态语言的灵活性有所冲突。因此，在设计类的时候，需要仔细考虑是否需要动态添加属性。

总结：

使用 __slots__ 需要权衡内存占用、属性访问速度和灵活性。在决定使用 __slots__ 之前，需要仔细考虑类的设计和应用场景。

何时使用`slots`？

在以下情况下，可以考虑使用 __slots__：

需要创建大量对象： 如果需要创建成千上万个对象，并且内存占用是一个重要的考虑因素，那么使用 __slots__ 可以显著减少内存占用。
属性访问非常频繁： 如果需要频繁访问对象的属性，并且性能是一个重要的考虑因素，那么使用 __slots__ 可以提高属性访问速度。
类的属性是固定的： 如果类的属性是固定的，不需要动态地添加、删除属性，那么可以使用 __slots__。

在以下情况下，不应该使用 __slots__：

需要动态地添加属性： 如果需要动态地添加、删除属性，那么不能使用 __slots__。
类的继承关系复杂： 如果类的继承关系复杂，使用 __slots__ 可能会增加代码的复杂性。
对内存占用和性能要求不高： 如果对内存占用和性能要求不高，那么没有必要使用 __slots__。

表格总结：__slots__的优缺点

特性	优点	缺点
内存占用	显著减少对象的内存占用，尤其是在创建大量对象时。	/
属性访问速度	提高属性访问速度，避免字典查找。	/
灵活性	/	不支持动态添加属性。继承时需要注意。需要显式声明`__weakref__`以支持弱引用。与元类和某些动态语言特性可能存在冲突。
适用场景	需要创建大量对象，属性访问频繁，类的属性是固定的。	/
不适用场景	需要动态地添加属性，类的继承关系复杂，对内存占用和性能要求不高。	/

实际应用案例

数据类 (Data Class): 如果定义的数据类只包含一些固定的属性，并且需要创建大量的实例，那么可以使用 __slots__ 来减少内存占用。
游戏开发： 在游戏开发中，需要创建大量的游戏对象，例如角色、道具等。使用 __slots__ 可以减少内存占用，提高游戏性能。
科学计算： 在科学计算中，需要处理大量的数据。如果数据结构是固定的，可以使用 __slots__ 来提高计算效率。

总结：内存、速度与灵活性的权衡

__slots__ 是Python中一个强大的工具，可以用来优化对象的内存占用和属性访问速度。但是，使用 __slots__ 需要权衡内存占用、属性访问速度和灵活性。在决定使用 __slots__ 之前，需要仔细考虑类的设计和应用场景，才能充分发挥 __slots__ 的优势。

更多IT精英技术系列讲座，到智猿学院