Python __slots__ 技术指南

Python __slots__ 技术指南

目录

1. 1. 核心概念：什么是 __slots__ ？
2. 2. 基础语法与示例
3. 3. 底层原理：为何能优化内存和性能？
4. 4. 性能对比实测
5. 5. 继承行为详解
6. 6. 高级用法与特殊需求
7. 7. 适用场景与最佳实践
8. 8. 总结

1. 核心概念：什么是 slots？

__slots__ 是 Python 中一个强大的类属性，它通过改变实例属性的存储方式，在内存占用和属性访问速度上带来显著优化，其代价是牺牲了动态添加属性的灵活性。

简单来说，它让您能明确地告诉 Python 解释器："这个类的实例只能拥有这些预定义的属性"，从而避免为每个实例创建一个耗内存的 __dict__ 字典。

下面的表格清晰地展示了使用 __slots__ 与普通类的核心区别：

特性	普通类（使用 __dict__）	使用 __slots__ 的类
属性存储机制	动态字典 (__dict__)	固定大小的数组（类似C结构体）
内存占用	较高（每个字典基准开销约240字节）	显著降低（可减少30%-50%）
属性访问速度	相对较慢（需字典哈希查找）	更快（通过数组偏移量直接访问）
动态添加属性	支持（非常灵活）	禁止（只能拥有 __slots__ 中声明的属性）
适用场景	常规开发，需要高度灵活性	内存敏感、性能关键、需严格约束属性

2. 基础语法与示例

使用 __slots__ 非常简单，只需在类定义中将其声明为一个包含允许属性名称的序列（如列表或元组）。

class Point:
    __slots__ = ('x', 'y')  # 声明实例只能拥有 x 和 y 两个属性

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

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

# 尝试动态添加属性将引发 AttributeError
# p.z = 3  # AttributeError: 'Point' object has no attribute 'z'

关键点：

• __slots__ 仅声明了允许的属性，并不会自动初始化它们。您仍需在 __init__ 等方法中为这些属性赋值。
• 直接访问未初始化的属性同样会引发 AttributeError。

3. 底层原理：为何能优化内存和性能？

要理解 __slots__ 的魔力，需要对比其与默认机制的存储方式。

3.1 默认机制（使用 __dict__）

当您创建一个普通 Python 类的实例时，它会拥有一个 __dict__ 属性。这是一个字典，用于动态存储所有的实例属性和值。虽然灵活，但每个字典本身都有不小的内存开销（存储哈希表、键值对等元数据）。

3.2 __slots__ 机制

当您定义了 __slots__ = ['x', 'y']，Python 解释器会为该类的每个实例预先分配一个固定大小的内存空间（就像一个C语言的结构体），专门用于存放 x 和 y 这两个属性的值。这意味着实例不再拥有 __dict__ 属性。

这种转变带来了两大核心优势：

1. 内存优化：消除了每个实例的 __dict__ 字典开销，尤其当创建海量（如数百万个）实例时，内存节省效果极其显著。
2. 性能提升：属性访问从字典的哈希查找转变为数组的偏移量直接访问，速度更快。

4. 性能对比实测

理论需用数据验证。以下示例展示了 __slots__ 在内存和速度上的优势。

4.1 内存占用测试

import sys

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

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

# 创建大量实例对比
num_instances = 100_000
list_regular = [RegularPoint(i, i) for i in range(num_instances)]
list_slotted = [SlottedPoint(i, i) for i in range(num_instances)]

# 计算总内存差异（粗略估计）
mem_regular = sum(sys.getsizeof(obj) + sys.getsizeof(obj.__dict__) for obj in list_regular)
mem_slotted = sum(sys.getsizeof(obj) for obj in list_slotted)

print(f"普通对象内存占用: ~{mem_regular / 1024 / 1024:.2f} MB")
print(f"Slots对象内存占用: ~{mem_slotted / 1024 / 1024:.2f} MB")
# 输出可能类似：普通对象内存占用: ~25.00 MB, Slots对象内存占用: ~10.00 MB

4.2 属性访问速度测试

import timeit

setup_regular = """
class Regular:
    pass
r = Regular()
r.x = 1
"""
setup_slotted = """
class Slotted:
    __slots__ = ('x',)
s = Slotted()
s.x = 1
"""

time_regular = timeit.timeit("r.x = 2", setup=setup_regular, number=10_000_000)
time_slotted = timeit.timeit("s.x = 2", setup=setup_slotted, number=10_000_000)

print(f"常规属性设置: {time_regular:.2f} 秒")
print(f"Slots属性设置: {time_slotted:.2f} 秒")
# 输出可能类似：常规属性设置: 0.80 秒, Slots属性设置: 0.60 秒

5. 继承行为详解

__slots__ 在继承中的行为需要特别注意，处理不当会失去优化效果。

5.1 子类未定义 __slots__

子类实例将恢复使用 __dict__，因此可以动态添加属性，但也会失去内存优化优势。不过，它仍然受父类 __slots__ 的限制，即父类声明的属性依然只能通过槽位访问。

5.2 子类定义 __slots__

子类的允许属性是其自身 __slots__ 与所有父类 __slots__ 的并集。这是最常用的方式，能保持优化效果。

class Person:
    __slots__ = ('name', 'age')

class Student(Person):
    __slots__ = ('student_id',)  # 扩展新属性。注意逗号，表明是元组。

    def __init__(self, name, age, student_id):
        super().__init__(name, age)  # 初始化父类属性
        self.student_id = student_id

s = Student("Alice", 20, "S12345")
s.name = "Bob"  # 合法，继承自父类槽位
s.student_id = "S67890"  # 合法，子类自有槽位
# s.gender = "Female"  # 非法，AttributeError

5.3 多继承注意事项

当从多个都定义了非空 __slots__ 的父类继承时，需确保不同父类的 __slots__ 属性名没有冲突，子类也需要显式定义自己的 __slots__。

6. 高级用法与特殊需求

为了在特定场景下平衡灵活性与性能，__slots__ 提供了一些扩展机制。

6.1 支持弱引用

默认情况下，__slots__ 类的实例不支持弱引用。如需此功能，必须在 __slots__ 中显式添加 '__weakref__'。

import weakref

class WeakableSlotted:
    __slots__ = ('data', '__weakref__')  # 显式启用弱引用支持

obj = WeakableSlotted()
ref = weakref.ref(obj)  # 现在可以创建弱引用了

6.2 保留部分动态性

如果既想享受 __slots__ 的优化，又需要动态添加少量属性，可以在 __slots__ 中加入 '__dict__'。但这会部分牺牲内存优势，因为实例会恢复 __dict__。

class HybridSlotted:
    __slots__ = ('fixed_attr', '__dict__')

obj = HybridSlotted()
obj.fixed_attr = "I'm fixed."
obj.dynamic_attr = "I'm dynamic."  # 合法，存储在 __dict__ 中

6.3 与 @dataclass 结合（Python 3.10+）

对于主要存储数据的数据类，可以使用 @dataclass 装饰器并设置 slots=True，来自动生成包含 __slots__ 的类，非常方便。

from dataclasses import dataclass

@dataclass(slots=True)
class DataPoint:
    x: float
    y: float

p = DataPoint(1.0, 2.0)
# p.z = 3.0  # 非法，AttributeError

7. 适用场景与最佳实践

7.1 强烈建议使用 __slots__ 的场景：

1. 需要创建大量实例：例如游戏中的粒子系统、ORM框架映射的数据库记录对象、科学计算中的数据点。
2. 对内存有严苛要求：如在嵌入式设备、移动端应用或内存受限的服务器环境中。
3. 需要明确的属性契约：防止他人或自己意外添加属性，增强代码的健壮性和可维护性，例如配置类、DTO（数据传输对象）。

7.2 应谨慎或避免使用的情况：

1. 开发初期或属性不确定时：过早使用会牺牲灵活性，给开发带来不便。建议在类设计稳定后再考虑引入。
2. 需要大量动态属性的类：例如某些元编程或框架基类，其核心功能依赖于动态属性。
3. 与严重依赖 __dict__ 的第三方库或框架集成时：可能会导致兼容性问题，例如某些序列化库可能无法正常工作。

8. 总结

__slots__ 是 Python 中一项用于内存优化和性能提升的强大工具。它通过将对象的属性存储从动态字典切换到固定数组，实现了内存占用的大幅降低和属性访问的速度提升。然而，这种优势是以牺牲动态添加属性的灵活性为代价的。

因此，是否使用 __slots__ 是一个典型的权衡决策。遵循"先测量，后优化"的原则，使用 sys.getsizeof 或 memory_profiler 等工具分析程序的实际内存使用。如果您的应用场景是数据密集型的，需要创建海量对象，或者对性能有极致追求，并且类的属性结构是稳定且明确的，那么 __slots__ 将是您的得力助手。否则，在一般应用开发中，默认使用 __dict__ 提供的灵活性可能更为重要。