Python __slots__：减少内存占用的高级技巧

class Employee:
    __slots__ = ('id', 'name', 'salary')  # 元组形式更高效
    
    def __init__(self, id, name, salary):
        self.id = id
        self.name = name
        self.salary = salary

emp = Employee(1001, 'Alice', 8500)
emp.department = 'HR'  # 抛出 AttributeError

2. 特殊需求处理

当需要弱引用或动态属性时，可通过扩展 __slots__实现：

# 支持弱引用
class WeakRefSupport:
    __slots__ = ('data', '__weakref__')

# 保留部分动态性
class HybridClass:
    __slots__ = ('fixed_attr', '__dict__')
    
    def __init__(self):
        self.fixed_attr = 42
        self.dynamic_attr = 'flexible'  # 存储在__dict__中

需注意：添加 __dict__会使内存占用回升至普通类的 80% 左右，应谨慎使用。

3. 性能验证方法

使用 sys.getsizeof()和 tracemalloc模块验证优化效果：

import sys
import tracemalloc

tracemalloc.start()

# 创建 10,000 个普通对象
regular_objs = [RegularPoint(i, i*2) for i in range(10000)]
print(f"普通对象内存：{sys.getsizeof(regular_objs[0])} bytes")

# 创建 10,000 个 slotted 对象
slotted_objs = [SlottedPoint(i, i*2) for i in range(10000)]
print(f"Slotted 对象内存：{sys.getsizeof(slotted_objs[0])} bytes")

snapshot = tracemalloc.take_snapshot()
top_stats = snapshot.statistics('lineno')
for stat in top_stats[:5]:
    print(stat)

四、继承场景的深度解析

1. 单层继承优化

子类必须显式定义 __slots__才能继承优化效果：

class Parent:
    __slots__ = ('a', 'b')

class Child(Parent):
    __slots__ = ('c',)  # 必须显式声明
    
    def __init__(self, a, b, c):
        super().__init__()
        self.a, self.b, self.c = a, b, c

child = Child(1, 2, 3)
print(hasattr(child, '__dict__'))  # 输出 False

若子类未定义 __slots__，则会恢复 __dict__存储，失去优化效果：

class UnoptimizedChild(Parent):
    def __init__(self, a, b, c):
        super().__init__()
        self.a, self.b, self.c = a, b, c

unopt_child = UnoptimizedChild(1, 2, 3)
print(hasattr(unopt_child, '__dict__'))  # 输出 True

2. 多重继承处理

当继承多个定义了 __slots__的父类时，需手动合并槽位：

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

class BaseB:
    __slots__ = ('z',)

class Child(BaseA, BaseB):
    __slots__ = ()  # 显式声明合并父类槽位
    
    def __init__(self, x, y, z):
        self.x, self.y, self.z = x, y, z

若任一父类未定义 __slots__，子类将被迫使用 __dict__：

class FlexibleBase:
    pass  # 未定义__slots__

class BrokenChild(BaseA, FlexibleBase):
    __slots__ = ('w',)  # 无效，仍会创建__dict__

3. 属性冲突规避

避免在继承链中重复声明同名槽位：

class Parent:
    __slots__ = ('common',)

class WrongChild(Parent):
    __slots__ = ('common', 'extra')  # 合法但危险

这种重复声明不会引发错误，但会导致内存布局混乱。正确做法是：

class CorrectChild(Parent):
    __slots__ = ('extra',)  # 扩展新属性

五、典型应用场景

1. 数据密集型应用

在 ORM 模型或科学计算中，处理大量结构化数据时效果显著：

class TransactionRecord:
    __slots__ = ('id', 'amount', 'timestamp', 'account')
    
    def __init__(self, id, amount, timestamp, account):
        self.id = id
        self.amount = amount
        self.timestamp = timestamp
        self.account = account

# 处理 100 万条交易记录
records = [TransactionRecord(i, i*100, i*3600, f'ACC{i%1000}') for i in range(1000000)]

2. 游戏实体系统

在 MMORPG 中管理数万游戏对象时，可显著降低内存压力：

class GameEntity:
    __slots__ = ('x', 'y', 'hp', 'speed', 'type')
    
    def __init__(self, x, y, hp, speed, entity_type):
        self.x = x
        self.y = y
        self.hp = hp
        self.speed = speed
        self.type = entity_type

# 创建 10,000 个游戏对象
entities = [GameEntity(i%100, i%200, 100, 5, 'monster') for i in range(10000)]

3. 高频访问缓存

在缓存系统中存储大量轻量级对象时，可提升缓存命中率：

class CacheItem:
    __slots__ = ('key', 'value', 'expires')
    
    def __init__(self, key, value, expires):
        self.key = key
        self.value = value
        self.expires = expires

# 创建 100 万缓存项
cache = {i: CacheItem(i, f'value_{i}', i+3600) for i in range(1000000)}

六、使用限制与注意事项

1. 灵活性代价

禁止动态添加属性可能影响框架设计：

class User:
    __slots__ = ('name',)

user = User()
user.name = 'Alice'
user.role = 'admin'  # 抛出 AttributeError

在需要动态扩展的场景中，可考虑混合使用 __slots__和 __dict__，但需权衡内存开销。

2. 序列化兼容性

部分库依赖 __dict__进行序列化：

import pickle

class Serializable:
    __slots__ = ('data',)
    
    def __init__(self, data):
        self.data = data

obj = Serializable(42)
serialized = pickle.dumps(obj)  # 可能报错

解决方案是为需要序列化的类实现 __getstate__和 __setstate__方法。

3. 调试复杂性

缺少 __dict__导致调试信息不完整：

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

obj = DebugTarget(1, 2)
print(vars(obj))  # 抛出 AttributeError

调试时可临时移除 __slots__或使用 dir(obj)查看属性列表。

七、性能对比数据

测试环境：Python 3.10，64 位系统，每个对象包含 2-10 个属性

八、总结与建议

__slots__是 Python 中'空间换时间'的典型优化策略，其核心价值在于：

1. 内存占用减少 30%-50%
2. 属性访问速度提升 20%-50%
3. 强制属性规范，增强代码健壮性

适用场景：

• 需要创建大量简单对象的场景
• 内存敏感型应用（如移动端、嵌入式系统）
• 性能关键型代码（如高频交易系统）

不适用场景：

• 需要高度动态扩展的类
• 复杂继承体系（多继承且父类未规范使用 __slots__）
• 依赖 __dict__的库（如某些序列化框架）

最佳实践：

1. 在性能关键路径上使用
2. 配合内存分析工具验证效果
3. 文档化说明属性契约
4. 避免在基础库中过度使用

通过合理应用 __slots__，可在不牺牲 Python 动态特性的前提下，实现显著的内存和性能优化。