__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__的场景，就是当你发现你的应用程序因为创建了巨量的、结构相似的、属性固定的对象而导致内存占用过高时。
举个例子，如果你正在开发一个游戏，每个游戏角色、道具、地图块都可能是一个对象，这些对象成千上万，甚至几十万个。每个对象如果都带一个
__dict__，那内存消耗就相当惊人了。这时候，如果这些对象的属性是预先确定的（比如一个角色只有生命值、攻击力、位置等），那么使用
__slots__就能立竿见影地减少总内存占用。
再比如，处理大量数据记录的场景，比如一个ORM（对象关系映射）框架，将数据库中的每一行数据映射成一个Python对象。如果你的数据库表有几百万行，而每个数据行对象只包含固定的几个字段，那么
__slots__就是个非常值得尝试的优化手段。它能让你的程序在处理同样多的数据时，占用更少的内存，从而可能避免内存溢出，或者让程序在配置较低的机器上也能跑起来。
当然，这不是说所有类都应该用
__slots__。如果你的类实例数量不多，或者你需要实例具备高度的灵活性，能够随时添加新属性，那么强行使用
__slots__反而会带来不必要的限制和开发上的不便。这就像是，你不需要为了一辆只在城市里开的家用轿车，去给它装上F1赛车的轮胎——虽然性能可能更好，但成本、维护和实际使用场景都不匹配。
使用__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__的实际影响，我觉得最关键的一点就是：不要凭空猜测，一定要动手测量！ 很多时候，我们觉得某个优化会带来巨大收益，但实际测量下来可能微乎其微，甚至因为引入了复杂性而得不偿失。
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__会增加一些开发和维护的复杂性，比如前面提到的继承、动态属性限制等。你需要权衡这些复杂性带来的成本，是否值得那些内存和性能上的收益。有时候，“足够好”的代码，比“极致优化”但难以维护的代码，更有价值。
