__slots__通过限制实例属性并避免创建__dict__来优化内存，适用于属性固定且对象数量庞大的场景，能显著减少内存占用，但会失去动态添加属性的能力，且影响弱引用和继承行为，实际效果需通过sys.getsizeof()和timeit等工具测量评估。
python中的
__slots__
，说白了，它就是一种内存优化的手段，通过限制类实例只能拥有预先定义好的属性，从而避免为每个实例创建传统的
__dict__
（字典）来存储属性。这样做最直接的好处就是能显著减少每个对象占用的内存空间，尤其是在你需要创建大量相同结构的对象时，效果会非常明显。当然，它也带来了一些副作用，比如你不能再随意给对象添加新属性了，这就像是给你的对象上了一把“锁”，只允许它拥有你明确指定的东西。
解决方案
当我们定义一个类时，Python默认会给每个实例一个
__dict__
属性，这个字典用于动态存储实例的属性。这种灵活性固然好，但对于那些属性固定、数量庞大的对象来说，每个实例都带一个字典，内存开销就变得相当可观。
__slots__
的作用就在于此，它告诉Python解释器：“嘿，这个类的实例，它的属性就只有我
__slots__
里列出来的这些，别的东西一概不要，也别给我搞什么
__dict__
了。”
比如，我们有一个表示二维点的类：
class PointWithoutSlots: def __init__(self, x, y): self.x = x self.y = y class PointWithSlots: __slots__ = ('x', 'y') def __init__(self, x, y): self.x = x self.y = y
用
sys.getsizeof()
来比较一下它们单个实例的内存占用，你会发现
PointWithSlots
的实例通常会小得多。这是因为
PointWithoutSlots
的每个实例都额外背负了一个
__dict__
的开销。对于
__slots__
，属性的存储更像是c语言结构体那样，直接在对象内部预留固定大小的空间，而不是通过字典查找。这不仅省内存，在某些情况下，属性的访问速度也会略有提升，因为省去了字典查找的哈希开销。
立即学习“Python免费学习笔记（深入）”；
但要记住，一旦你用了
__slots__
，你就放弃了实例动态添加属性的能力。尝试给一个
PointWithSlots
的实例添加一个
z
属性，比如
p.z = 3
，就会直接报错
AttributeError
。这就是它“锁定”属性的体现。
何时应该考虑在Python类中使用
__slots__
__slots__
进行内存优化？
我觉得这个问题问得非常好，因为它直接指向了
__slots__
的核心价值所在。在我看来，你最应该考虑使用
__slots__
的场景，就是当你发现你的应用程序因为创建了巨量的、结构相似的、属性固定的对象而导致内存占用过高时。
举个例子，如果你正在开发一个游戏，每个游戏角色、道具、地图块都可能是一个对象，这些对象成千上万，甚至几十万个。每个对象如果都带一个
__dict__
，那内存消耗就相当惊人了。这时候，如果这些对象的属性是预先确定的（比如一个角色只有生命值、攻击力、位置等），那么使用
__slots__
就能立竿见影地减少总内存占用。
再比如，处理大量数据记录的场景，比如一个ORM（对象关系映射）框架，将数据库中的每一行数据映射成一个Python对象。如果你的数据库表有几百万行，而每个数据行对象只包含固定的几个字段，那么
__slots__
就是个非常值得尝试的优化手段。它能让你的程序在处理同样多的数据时，占用更少的内存，从而可能避免内存溢出，或者让程序在配置较低的机器上也能跑起来。
当然，这不是说所有类都应该用
__slots__
。如果你的类实例数量不多，或者你需要实例具备高度的灵活性，能够随时添加新属性，那么强行使用
__slots__
反而会带来不必要的限制和开发上的不便。这就像是，你不需要为了一辆只在城市里开的家用轿车，去给它装上F1赛车的轮胎——虽然性能可能更好，但成本、维护和实际使用场景都不匹配。
使用
__slots__
__slots__
会带来哪些潜在的副作用和限制？
嗯，天下没有免费的午餐，
__slots__
在带来内存优势的同时，也确实引入了一些限制和“脾气”。这些东西，我觉得作为开发者，是必须要心里有数的。
首先，最明显的就是实例不能再动态添加新属性了。一旦你定义了
__slots__
，除了
__slots__
里列出的那些属性，你就不能再给这个类的实例赋值新的属性了。这对于那些习惯了Python动态特性的开发者来说，可能需要一段时间去适应。有时候，我也会不小心写出
obj.new_attr = value
，然后就被
AttributeError
教做人。
其次，实例将不再拥有
__dict__
属性。这意味着你不能再通过
obj.__dict__
来查看或遍历实例的所有属性了，也不能使用
vars(obj)
这样的内置函数。这在调试或者某些需要反射机制的场景下，可能会造成一些不便。如果你真的需要在保持
__slots__
优化的同时，又允许部分实例拥有动态属性，你可以把
'__dict__'
这个字符串也加到
__slots__
里，但这样一来，内存优化的效果就会大打折扣，因为又把字典请回来了。
再者，默认情况下，实例也不能被弱引用（weak reference）。如果你需要弱引用功能，就必须把
'__weakref__'
也加到
__slots__
里。这又是一个需要注意的小细节，因为它不像
__dict__
那样，你通常不会默认想到它。
继承关系上，
__slots__
也有点意思。如果子类不定义
__slots__
，那么它就会重新拥有
__dict__
，并且其父类的
__slots__
依然生效。但如果子类也定义了
__slots__
，那么子类的
__slots__
会和父类的
__slots__
合并，形成一个总的属性集合。这里面稍微复杂一点的是多重继承，如果多个父类都定义了
__slots__
，并且它们之间有冲突（比如都定义了同一个名字但类型不同的属性），就可能导致一些难以预料的问题。所以，在复杂的继承体系中，使用
__slots__
需要格外小心。
最后，我觉得还有一点，虽然不算是严格意义上的副作用，但值得一提：它可能会稍微增加代码的“僵硬度”。因为它限制了灵活性，你在设计类的时候就需要更深思熟虑，提前规划好所有可能的属性。这对于快速原型开发或者需求经常变动的项目来说，可能不是最好的选择。
在实践中，如何评估
__slots__
__slots__
对内存和性能的实际影响？
评估
__slots__
的实际影响，我觉得最关键的一点就是：不要凭空猜测，一定要动手测量！ 很多时候，我们觉得某个优化会带来巨大收益，但实际测量下来可能微乎其微，甚至因为引入了复杂性而得不偿失。
1. 内存占用评估：
最直观的方法就是使用
sys.getsizeof()
。你可以创建一个不使用
__slots__
的类实例，再创建一个使用
__slots__
的类实例，然后比较它们的尺寸。
import sys class NoSlots: def __init__(self, name, age, city): self.name = name self.age = age self.city = city class WithSlots: __slots__ = ('name', 'age', 'city') def __init__(self, name, age, city): self.name = name self.age = age self.city = city ns_obj = NoSlots("Alice", 30, "New York") ws_obj = WithSlots("Bob", 25, "London") print(f"NoSlots object size: {sys.getsizeof(ns_obj)} bytes") print(f"WithSlots object size: {sys.getsizeof(ws_obj)} bytes") # 注意：sys.getsizeof()只计算对象本身的内存，不包括它引用的其他对象的内存。 # 对于字符串等不可变对象，它们可能在内存中只存一份。 # 但对于__dict__的开销，它是很准确的。
要更全面地评估，特别是当你创建了大量对象时，可以考虑使用像
pympler
或
memory_profiler
这样的第三方库。它们能让你分析整个应用程序的内存使用情况，找出内存占用的大头，这样你就能更准确地判断
__slots__
是否真的解决了你的内存问题。
2. 性能（属性访问速度）评估：
使用
timeit
模块是衡量代码执行时间的好工具。你可以编写小段代码，分别测试使用和不使用
__slots__
的类实例的属性读取或写入操作，然后比较它们的执行时间。
import timeit setup_code = """ class NoSlots: def __init__(self, x, y): self.x = x self.y = y class WithSlots: __slots__ = ('x', 'y') def __init__(self, x, y): self.x = x self.y = y ns_obj = NoSlots(1, 2) ws_obj = WithSlots(1, 2) """ # 测试属性读取 time_ns_read = timeit.timeit("ns_obj.x", setup=setup_code, number=1_000_000) time_ws_read = timeit.timeit("ws_obj.x", setup=setup_code, number=1_000_000) print(f"NoSlots attribute read time: {time_ns_read:.4f} seconds") print(f"WithSlots attribute read time: {time_ws_read:.4f} seconds") # 测试属性写入 time_ns_write = timeit.timeit("ns_obj.x = 3", setup=setup_code, number=1_000_000) time_ws_write = timeit.timeit("ws_obj.x = 3", setup=setup_code, number=1_000_000) print(f"NoSlots attribute write time: {time_ns_write:.4f} seconds") print(f"WithSlots attribute write time: {time_ws_write:.4f} seconds")
通常情况下，
__slots__
在属性访问上会有轻微的性能提升，但这往往不如内存节省那么显著。而且，这种性能差异在现代Python版本中，随着解释器的优化，可能变得越来越小，甚至在某些特定场景下，
__dict__
的哈希查找因为缓存等机制反而表现不错。所以，不要盲目追求这点微小的性能提升而牺牲代码的灵活性。
3. 综合考量：
最终的决策，我觉得还是要回到你的具体应用场景。如果内存是瓶颈，而且对象数量巨大，
__slots__
无疑是一个强大的工具。但如果内存不是主要问题，或者你更看重开发效率和代码的灵活性，那么保持默认的
__dict__
行为可能更明智。引入
__slots__
会增加一些开发和维护的复杂性，比如前面提到的继承、动态属性限制等。你需要权衡这些复杂性带来的成本，是否值得那些内存和性能上的收益。有时候，“足够好”的代码，比“极致优化”但难以维护的代码，更有价值。
评论（已关闭）
评论已关闭