搬家的时候，你是不是总在纠结：这个背包太小，东西塞不下；那个行李箱太重，拎着费劲？最麻烦的是，每件东西都得自己装袋、自己贴标签、自己记清单，累得满头大汗。如果用 Python 写数据类，你也面临类似的烦恼：每次定义一个简单的类，都要手写 __init__ 初始化方法、__repr__ 打印方法、__eq__ 比较方法，繁琐又容易出错。 这时有位“智能收纳师”出现了——它就是 dataclass。你只需要告诉它“我要装哪些东西”，它就能自动帮你把打包、贴标签、比对物品的活儿全干了。而 __slots__ 则像一款“固定隔层行李箱”：每个行李箱只能放设计好的东西，不能乱塞，但正因如此，它比那些什么都往里塞的大背包轻得多、省空间得多。 把两者结合——让智能收纳师帮你装箱，再用固定隔层行李箱来装——恭喜你，既省心又省内存，这正是本文要带你掌握的 Python 数据类最佳实践。

岗位关联

对 AI 工程师来说，配置管理、数据模型、大规模对象处理几乎是每天都要面对的，掌握 dataclass 与 slots 能显著减少样板代码、降低内存开销，是工程落地必备技能。

目录
  1. 可视化演示
  2. dataclass 初识
  3. field 与默认值
  4. frozen 不可变
  5. 继承与排序
  6. \_\_slots\_\_ 原理
  7. \_\_slots\_\_ 限制
  8. 组合使用
  9. 应用与实战
  10. AI 应用场景
  11. Python 演示
  12. 常见误区
  13. 面试题

可视化演示

动态展示循环队列的入队与出队操作，直观呈现front和rear指针的环形移动及队列空满状态的判断机制。

本节配有交互动效（进入视口后自动加载，约 3KB）。

循环队列ENQ操作 元素入队rear指针环形移动 count计数器递增 rear=(rear+1)%N 环形索引计算

dataclass 初识

搬家时，如果每件物品都要亲手分类、装袋、写标签、做记录，光是想象就让人头大。写 Python 普通类也是这样：定义一个 Point 类，要手写 __init__ 装数据、写 __repr__ 打印信息、写 __eq__ 比较两个点是否相等。代码一多，全是无聊的样板，像极了搬家中机械的重复劳动。

这时 @dataclass 装饰器就像一位智能收纳师。你只负责声明“箱子里有 x 和 y 两个坐标”，剩下的打包工作——初始化、打印、比较——收纳师全包了。看对比：

从技术上讲，@dataclass 装饰器会读取类中的类型注解（如 x: float），把这些字段收集成一份“装箱清单”，然后自动生成 __init__、__repr__、__eq__ 等标准方法。你不需要写任何重复代码，类定义本身就像一张纯数据的表格，简洁、直观、可读性高。

有了智能收纳师，你只需要告诉它“要装哪些东西”，它就能把打包、贴标签、比对物品的活全包了。同样，有了 @dataclass，你只需要声明字段，Python 就自动生成了标准方法——这就是“省心”二字的第一层含义。

dataclass(P)→P+{__init__,__repr__,__eq__}\text{dataclass}(P) \to P + \{\text{\_\_init\_\_}, \text{\_\_repr\_\_}, \text{\_\_eq\_\_}\}
这个式子表示：@dataclass 作用于类 P 后，等价于在原始类上自动追加了 __init__（初始化）、__repr__（打印输出）、__eq__（相等比较）这三个最常用的标准方法。
  1. 类 P需要被装饰的普通类，只需写出字段名和类型注解。
    dataclass(P)\text{dataclass}(P)
  2. 自动追加方法装饰过程不修改你写的字段，只是为类补全方法。
    P+{__init__,__repr__,__eq__}P + \{\text{\_\_init\_\_}, \text{\_\_repr\_\_}, \text{\_\_eq\_\_}\}
  3. 最终产物新的类拥有完整的初始化、打印和比较能力，可以立即投入使用。
    →P′\to P'
python17 行
# 普通类class Point:    def __init__(self, x, y):        self.x = x        self.y = y     def __repr__(self):        return f"Point(x={self.x}, y={self.y})"     def __eq__(self, other):        return (self.x, self.y) == (other.x, other.y) # dataclass 版@dataclassclass Point:    x: float    y: float

field 与默认值

收纳师在装箱时，会给每件物品贴上预设的价签和备注，比如“这件衣服默认放左边夹层”。dataclass 中的 field() 函数就是这样的“标签机”：你可以给字段设置默认值、附加说明元数据，还可以规定哪些物品是必带的。

先要注意一个容易踩的坑：字段必须按照“无默认值在前、有默认值在后”的顺序排列，否则 Python 会直接报错。这就像收纳师必须先放必带的重要物品，再放可选的备用品。其次，默认值不能直接写 [] 或 {}——因为所有实例会共享同一个可变对象，互相污染。正确做法是 field(default_factory=list)，相当于每次装箱时都现场生产一张新的空清单。

field() 的完整能力包括：default（默认值）、default_factory（可变对象工厂）、metadata（开发者附加的说明信息，不影响逻辑）。这些参数让字段的定义像一份精细的装箱单，既清楚又灵活。

给物品贴好标签、设好默认位置，收纳师才能高效装箱。field() 正是这样一位标签管理员：它帮你细粒度控制每一个字段的默认行为和附带说明，让“省心”从方法层深入到了字段层。

field(d,f,m):x↦{d未传参f()需要可变对象\text{field}(d, f, m): x \mapsto \begin{cases} d & \text{未传参} \\ f() & \text{需要可变对象} \end{cases}
这个式子描述了 field 的工作方式：字段 x 在没有被用户传值时，返回默认值 d；如果默认值是需要新创建的可变对象，就调用工厂函数 f() 生成一份新的，而不是共享同一个。
  1. field 参数d 是直接默认值，f 是工厂函数，m 是元数据字典。
    field(d,f,m)\text{field}(d, f, m)
  2. 未传参时字段 x 返回默认值 d，比如 price: float = 0.0。
    x↦dx \mapsto d
  3. 可变对象当默认值需要是列表、字典等可变类型时，调用 f() 为每个实例生成独立对象。
    f()f()
python6 行
@dataclassclass Item:    name: str                      # 必填，无默认值    price: float = 0.0             # 可选，默认 0.0    tags: list = field(default_factory=list,                       metadata={"hint": "标签列表"})

frozen 不可变

有些贵重物品打包好后，你想贴上封条，通知全家“这个箱子不要动”。dataclass 的 frozen=True 就扮演了封条的角色：一旦把参数设为 frozen=True，类的实例就变成只读的，任何给属性赋值的操作都会抛出 FrozenInstanceError。

从内部机制看，frozen=True 会让 __setattr__ 方法在赋值时抛出异常，从而拦截所有修改。一个附带的好处是：当 eq=True 且 frozen=True 时，dataclass 会自动生成基于字段值的 __hash__ 方法，让实例可以被放入集合（set）或者用作字典（dict）的键——相当于封条自带防伪编号，可以通过内容识别身份。

不过要提醒一点：frozen 只是“粘贴了封条”，箱子内部的物品如果本身是可变对象（比如列表），它仍然可以被修改。真正的深不可变需要内部也使用不可变类型。

贴了封条的箱子，搬多远都不怕内容被意外打乱。配置类、常量对象这些“只读共享”的场景，用 frozen=True 既能防手误，又能安全地在多线程或多模块间共享，真正做到了“省心又安全”。

frozen:obj.attr=v⇒FrozenInstanceError\text{frozen}: \text{obj.attr} = v \Rightarrow \text{FrozenInstanceError}
这个式子概括了 frozen=True 的规则：对实例 obj 的属性 attr 做赋值操作时，会立即触发 FrozenInstanceError 异常，实例进入只读状态。
  1. frozen 标记类被 @dataclass(frozen=True) 修饰后，实例进入只读保护模式。
    frozen\text{frozen}
  2. 赋值操作任何试图修改属性的操作都被拦截，无论是重新赋值还是删除。
    obj.attr=v\text{obj.attr} = v
  3. 异常结果赋值行为被拒绝，程序抛出 FrozenInstanceError 以提示开发者。
    ⇒FrozenInstanceError\Rightarrow \text{FrozenInstanceError}
python7 行
@dataclass(frozen=True)class Config:    batch_size: int = 32    learning_rate: float = 0.001 config = Config()config.learning_rate = 0.01  # 抛出 FrozenInstanceError

继承与排序

搬家时，大箱子设计了几层隔板，小箱子有时会直接复用大箱子的结构，再额外增加自己的小口袋。dataclass 的继承机制正好如此：子类自动继承父类的所有字段，再追加自己声明的字段，整体行为如同把两段装箱清单拼接在一起。

order=True 是另一个强大的开关：它让收纳师按字段顺序自动生成一套比较方法（__lt__、__le__、__gt__、__ge__）。排序规则就是从第一个字段开始逐项比较，如同字典的字母顺序。配合继承时，子类的字段排在父类字段之后，排序优先级父类字段更高。

要注意的是，如果不加 order=True，dataclass 只生成 __eq__，对象无法直接比较大小。另外，eq=False 时也可以完全禁用相等方法的生成，让类退化为纯数据容器。

子箱继承母箱的隔层设计，再按顺序排好队，整个搬家过程就有条不紊。继承让代码可复用，排序让对象可比较，dataclass 把这两件事都做成了“声明式”的——你只管说“要排序”，规则它自己来。

C(a,b)≤C(a′,b′)  ⟺  (a<a′)∨(a=a′∧b≤b′)C(a, b) \leq C(a', b') \iff (a < a') \lor (a = a' \land b \leq b')
这个式子展示了 order=True 的排序逻辑：比较两个实例时，先比第一个字段 a，如果 a 小于 a' 则整体小于；如果第一个字段相等，才继续比较第二个字段 b，只有 b 也不大于时整个比较才成立。
  1. 实例表示C(a, b) 表示字段值为 a 和 b 的实例。
    C(a,b)≤C(a′,b′)C(a, b) \leq C(a', b')
  2. 字典序条件先比较第一字段，用逻辑或连接两个分支。
    (a<a′)∨(a=a′∧b≤b′)(a < a') \lor (a = a' \land b \leq b')
  3. 逐字段推进第一字段相等时才看第二字段，与查字典的规则完全一致。
    ∧b≤b′\land b \leq b'
python8 行
@dataclass(order=True)class Point:    x: float    y: float @dataclassclass ColoredPoint(Point):    color: str = "black"

\_\_slots\_\_ 原理

普通 Python 类的每个实例都自带一个名为 __dict__ 的字典，用来存储所有实例属性。这个字典就像一个弹性十足的大背包——什么都能往里塞，但代价是每个背包都占用不小的内存。当你有十万个实例时，就有十万个背包，内存开销哗哗地流走。

__slots__ 则换了一种思路：在类中声明一个固定属性名的元组，Python 就不再为实例创建 __dict__ 背包，而是改用紧凑的内部描述符槽位存储属性。这就好比把弹性背包换成了带固定隔层的行李箱——每个隔层放什么都提前设计好，存储空间大幅压缩，访问速度还有所提升。

值得强调的是，使用 __slots__ 后，同类实例之间共享描述符结构，实例本身不再有额外字典开销。实测中，带有两个浮点属性的对象，每个实例可以节省 56 到 100 多字节；当实例数量达到百万级时，节省的内存以数十 MB 计。

固定隔层的行李箱比弹性背包轻得多，这就是 __slots__ 的核心魅力。当你面对海量对象时，去掉那个塞满零碎的大背包，内存占用肉眼可见地下降，访问属性甚至更快——省内存的同时还顺手提了速。

Etotal=Nobj×SdictE_{\text{total}} = N_{\text{obj}} \times S_{\text{dict}}
这个式子表示：所有实例因 __dict__ 产生的总内存开销 E_total，等于实例数量 N_obj 乘以每个字典的平均大小 S_dict。只有去掉 __dict__，才能从根源上消除这部分消耗。
  1. 总内存开销E_total 是指所有实例携带字典带来的总额外内存。
    EtotalE_{\text{total}}
  2. 实例数量N_obj 是同时存活的对象个数，数量越大收益越明显。
    NobjN_{\text{obj}}
  3. 字典大小S_dict 是每个实例 __dict__ 字典的平均字节数，通常为 50~150 字节。
    SdictS_{\text{dict}}
python6 行
class Point:    __slots__ = ("x", "y")     def __init__(self, x, y):        self.x = x        self.y = y

\_\_slots\_\_ 限制

固定隔层行李箱的设计一旦定下来，你就不能再往里面塞新东西了。__slots__ 也一样：一旦声明了固定的属性名，实例就不能再动态添加 __slots__ 之外的属性，否则会直接抛出 AttributeError。

除了禁止动态属性，__slots__ 还有两个容易被忽略的限制：默认情况下，实例不再支持弱引用（除非在 __slots__ 中加入 __weakref__）；此外，如果你需要查看每个实例的属性字典，也会因为 __dict__ 不存在而失败。继承时更要小心：如果父类用了 __slots__ 而子类没有声明自己的 __slots__，子类实例又会自动获得 __dict__，省内存的效果就前功尽弃了。

另一个细节是，__slots__ 并不能阻止类属性（而非实例属性）的访问，也不能阻止类本身被动态添加类属性。它管的是“实例层面”的储物空间。

行李箱隔层固定，是好是坏要看场景。如果你需要极致的灵活性——给不同实例动态挂不同属性，那 __slots__ 会碍事；但如果你要的是确定性和性能，那么提前规划好属性清单，反而是一种保护。用之前，先把要装的东西想清楚。

obj.new_attr⇒AttributeError\text{obj.new\_attr} \Rightarrow \text{AttributeError}
这个式子说明 __slots__ 的边界：给实例 obj 赋予一个未在 __slots__ 中声明的新属性 new_attr 时，操作会被 Python 拒绝，并抛出 AttributeError。
  1. 新属性赋值试图通过 obj.new_attr = value 创建新属性。
    obj.new_attr\text{obj.new\_attr}
  2. 拒绝结果没有 __dict__ 承载新属性，Python 抛出属性错误异常。
    ⇒AttributeError\Rightarrow \text{AttributeError}
python2 行
p = Point(1.0, 2.0)p.z = 3.0  # AttributeError: 'Point' object has no attribute 'z'

组合使用

到现在，你已经认识了两件法宝：dataclass 负责省心，__slots__ 负责省内存。聪明如你，一定想到了：能不能让智能收纳师直接用固定隔层行李箱来装箱？答案是肯定的——Python 3.10 起，@dataclass(slots=True) 一步到位。

这一行代码的背后，dataclass 在完成标准方法生成的同时，自动为类添加了 __slots__ 声明。于是这个类既拥有 __init__、__repr__、__eq__，又没有 __dict__，既省心又省内存。对于 Python 3.9 及以下的版本，你需要手动 __slots__ = ("x", "y", "label") 再叠加 @dataclass，效果相同但多写几行。

内部的配合方式类似于：dataclass 先把字段清单整理好，然后 __slots__ 按清单打造固定槽位。两者不冲突，反而互相成就。唯一的注意点包括：slots=True 与某些基于 __dict__ 的库（如 copy.copy 的某些实现）可能不兼容，需要先确认项目依赖环境。

智能收纳师用上了固定隔层行李箱，既不用自己动手打包，又能轻装上阵。这是 Python 数据类的最优打开方式：字段声明一次，省心省内存全都有了。

dataclass(slots=True)(C)⇒C′ 同时具备省心 + 省内存\text{dataclass}(\text{slots=True})(C) \Rightarrow C' \text{ 同时具备省心 + 省内存}
这个式子表达组合效果：装饰器 @dataclass(slots=True) 作用于类 C 后，得到的新类 C' 既有自动生成的标准方法，又通过 __slots__ 消除了 __dict__，两步到位。
  1. 装饰器调用dataclass(slots=True) 是带参数的装饰器，作用于类 C。
    dataclass(slots=True)(C)\text{dataclass}(\text{slots=True})(C)
  2. 双重收益新类 C' 自动拥有 __init__ 等方法，同时实例无 __dict__。
    ⇒C′\Rightarrow C'
  3. 端到端价值从写代码到跑内存，全程高效省心。
    省心+省内存\text{省心} + \text{省内存}
python5 行
@dataclass(slots=True)class FastPoint:    x: float    y: float    label: str = ""

应用与实战

搬家的场景千差万别：一个人住的小公寓和一大家子的别墅，装备完全不同。选型 dataclass 与 __slots__ 的关键，是看清自己的使用场景和性能诉求。

最典型的场景之一是配置类：AI 训练的超参数、模型参数、环境配置，字段固定、数量不多、要求安全共享。用 @dataclass(frozen=True) 定义配置，既享受自动 __repr__ 打印调试，又防止运行中被意外篡改。

第二个场景是数据模型：API 的响应体、数据库读出的记录、消息队列中的事件对象。用 @dataclass 定义结构，配合类型注解，让整个数据管道清晰可读；如果确认字段不会动态增加，再加上 slots=True 榨干内存。

第三个场景是大规模对象处理：日志解析、传感器数据流、推荐系统的候选物。这类对象动辄百万级，__slots__ 带来的内存节省非常可观——去掉每一个实例的 __dict__，等于给整个内存画像做了瘦身。

不同搬家场景选不同装备，工程的本质就是“选对工具”。dataclass 让你在绝大多数场景下写得快、看得清；__slots__ 让你在关键场景下跑得轻、存得少。理解了选型标准，你就真正把这两个知识点变成了自己的工具箱。

---

Use Slots  ⟺  (Nobj≫1)∨(内存受限)\text{Use Slots} \iff (N_{\text{obj}} \gg 1) \lor (\text{内存受限})
这个式子给出了选型标准：当实例数量 N_obj 远大于 1，或运行环境对内存有硬性限制时，就应该使用 __slots__；反之，如果实例很少且需要动态属性，则没必要付出灵活性代价。
  1. 选型条件Use Slots 表示决定启用 __slots__ 的决策变量。
    Use Slots\text{Use Slots}
  2. 数量主导N_obj >> 1 表示实例数量极其庞大，节省的字典内存积少成多。
      ⟺  (Nobj≫1)\iff (N_{\text{obj}} \gg 1)
  3. 资源约束内存受限 表示系统对内存占用有硬性上限，如边缘设备、移动端。
    ∨(内存受限)\lor (\text{内存受限})

AI 应用场景

机器学习超参数配置管理

阶段：模型训练与调参阶段

解决的问题：训练脚本的参数常常散落在各种全局变量里，既无法统一校验，又容易在调参时误改。用 dataclass 定义超参数配置类，字段类型 + 默认值 + frozen=True 三管齐下，让所有参数一目了然、不可篡改、可自动序列化。

具体案例：一个推荐系统团队的训练脚本中，用 @dataclass(frozen=True) 定义了 TrainConfig，包含 batch_size、learning_rate、num_epochs 等 12 个超参数。团队将配置对象传入训练函数，__repr__ 自动输出完整参数快照，配合日志系统每次训练都记录配置——线上问题排查从小时级缩短到分钟级。

大规模数据处理管道

阶段：数据预处理与特征工程阶段

解决的问题：处理千万级日志或传感器数据时，每一条记录用一个普通类对象表示，__dict__ 的内存开销会被放大千万倍。用 @dataclass(slots=True) 定义数据记录类，消除了每实例的字典，内存占用大幅下降。

具体案例：某智能工厂的传感器数据管道，每秒钟产生 5000 条振动信号记录。工程师将记录类改为 @dataclass(slots=True) 后，内存占用从 1.2GB 降到 680MB，GC 压力明显缓解，处理吞吐量提升了约 40%。

API 响应数据模型

阶段：模型服务推理与结果返回阶段

解决的问题：AI 服务向外输出预测结果时，需要把内部数据结构整理成统一的 JSON 响应格式。普通字典写法容易字段拼写错误、类型不可控，用 dataclass 定义响应模型，类型自动校验、序列化结构清晰。

具体案例：一个图像识别服务用 @dataclass 定义 PredictResponse，包含 image_id、top_labels、confidences 等字段，配合 asdict() 快速转成 JSON。前后端联调时，字段名和类型有代码提示兜底，接口文档和代码天然一致。

Python 演示

python45 行
from dataclasses import dataclass, fieldimport sys  @dataclassclass Point:    x: float    y: float    label: str = field(default="", metadata={"hint": "名称"})  @dataclass(slots=True)class FastPoint:    x: float    y: float    label: str = field(default="", metadata={"hint": "名称"})  def main():    p = Point(1.0, 2.0, "A")    print("普通 dataclass:", p)    print("有 __dict__:", hasattr(p, "__dict__"))    p.z = 3.0    print("动态添加 z 成功:", p.z)     fp = FastPoint(1.0, 2.0, "A")    print("slots dataclass:", fp)    print("有 __dict__:", hasattr(fp, "__dict__"))    try:        fp.z = 3.0    except AttributeError as exc:        print("FastPoint 不能添加 z:", exc)     objs_p = [Point(i, i) for i in range(30)]    objs_fp = [FastPoint(i, i) for i in range(30)]    size_p = sum(sys.getsizeof(o) + sys.getsizeof(o.__dict__) for o in objs_p)    size_fp = sum(sys.getsizeof(o) for o in objs_fp)    print("30 个普通实例:", size_p, "bytes")    print("30 个 slots 实例:", size_fp, "bytes")    ratio = 1 - size_fp / size_p    print("内存节省比例: {:.1f}%".format(ratio * 100))  if __name__ == "__main__":    main()
目的：对比普通 dataclass 与 @dataclass(slots=True) 在动态属性和内存占用上的差异，直观展示组合使用的收益。
  1. @dataclass装饰器相当于“智能收纳师”，自动生成 __init__、__repr__、__eq__ 等方法。
  2. label: str = field(default="", metadata={"hint": "名称"})用 field 设置默认值并附加说明元数据。
  3. @dataclass(slots=True)组合模式：自动生成方法的同时开启 __slots__，省心又省内存。
  4. hasattr(p, "__dict__")检查实例是否带有动态属性字典，普通实例返回 True。
  5. p.z = 3.0普通 dataclass 实例可以动态添加新属性，因为背后有 __dict__。
  6. fp.z = 3.0slots 实例没有 __dict__，动态添加属性会抛出 AttributeError。
  7. sys.getsizeof(o) + sys.getsizeof(o.__dict__)计算实例本体加字典的总内存，slots 实例无需加字典。

常见误区

误区很多初学者以为用了 `@dataclass` 之后，`__hash__`、`__str__`、`__copy__` 等所有魔法方法都会被自动生成，于是肆无忌惮地依赖这些方法。

正解dataclass 默认只生成 __init__、__repr__、__eq__ 三个核心方法，其他方法由可选参数控制。比如 frozen=True 才会自动生成 __hash__，order=True 才会生成比较排序方法，__str__ 默认不生成（repr 会兜底但字符串格式不同）。要判断一个方法有没有生成，可以直接用 hasattr(Point, "__hash__") 检查。

为何常见：装饰器“一键补全”的心智模型太强烈，容易把自动化范围无限扩大，实际需要逐个确认参数开关。

误区有同学写下 `__slots__ = ("x", "y")` 后发现 `p.x = 1` 能成功，但 `p.z = 3` 报错，便以为 `__slots__` 让类的所有属性都不能用了。

正解__slots__ 只固定“实例可以有哪些属性”，声明的属性完全正常使用，只是禁止了声明之外的动态添加。这就像固定隔层行李箱：隔层本身能放东西，只是不能塞进隔层之外的区域。另外，类属性（class attribute）不受此限制。

为何常见：把“不能动态添加属性”错误理解为“不能有属性”，忽略了声明内属性的合法性。

误区写 `tags: list = []` 看起来没毛病，但一运行就报 `ValueError: mutable default <class 'list'> for field tags is not allowed`，初学者一脸懵。

正解dataclass 禁止使用可变对象作为直接默认值，因为所有实例会共享同一个列表，一个实例改了，所有实例都跟着变。正确做法是 field(default_factory=list)，相当于每个实例都拿到一张全新的空清单，互不干扰。

为何常见：很多语言允许可变默认值且行为不同，加上 Python 函数默认参数本身就有类似的共享陷阱，初学者容易踩坑。

误区有人给配置类加了 `frozen=True`，以为内部列表也“锁死了”，结果发现 `config.tags.append("x")` 居然成功，深感困惑。

正解frozen 只拦截“属性重新赋值”操作（如 config.tags = [...]），不拦截内部可变对象的内容修改（如 config.tags.append(...)）。列表还是那个列表，只是不能换新列表。要实现深度不可变，必须让所有内部字段也使用不可变类型（如元组代替列表）。

为何常见：“不可变”的字面理解与 Python 中“引用不可变 vs 对象内容不可变”的深层区别相混淆。

面试题

Q1. @dataclass 装饰器最擅长自动生成哪一类代码？

单选题 · easy

  • A.自动生成业务逻辑算法
  • B.自动生成重复的标准方法← 正确答案
  • C.自动生成数据库表结构
  • D.自动生成网络请求代码

答案：B。dataclass 是数据类的“智能收纳师”，专注于自动生成 __init__、__repr__、__eq__ 这类样板方法，而不是业务逻辑、数据库或网络代码。业务逻辑需要自己写，数据库和网络有专门的框架处理。

Q2. 下列哪种情况必须使用 field(default_factory=...)？

单选题 · mid

  • A.默认值是 0 或 1 整数
  • B.默认值是空列表或集合← 正确答案
  • C.默认值是固定字符串
  • D.默认值是浮点数常量

答案：B。可变默认值（列表、字典、集合）是 Python 的经典陷阱，dataclass 会直接拒绝。default_factory 会在每个实例创建时调用工厂函数生成独立对象，相当于每份行李都配一张新清单。而整数、字符串、浮点数是不可变类型，直接赋默认值完全没问题。

Q3. frozen=True 的核心效果是什么？

单选题 · easy

  • A.实例属性全部变成只读← 正确答案
  • B.类方法全部变成静态
  • C.所有字段自动变成私有
  • D.类对象变成不可变的

答案：A。frozen=True 给实例贴上封条，任何对实例属性的赋值操作都会抛出 FrozenInstanceError。它管的是实例层面的只读，与类方法是否静态、字段是否私有、类对象本身是否不可变没有关系。

Q4. __slots__ 节省内存的根本原因是什么？

单选题 · mid

  • A.消除了每个实例的字典← 正确答案
  • B.压缩了属性名的长度
  • C.将对象存储到磁盘上
  • D.通过缓存复用已有对象

答案：A。每个普通实例都自带一个 __dict__ 弹性背包，动辄 50~150 字节。__slots__ 用固定描述的槽位替代字典，实例不再携带背包，从根源上省下了内存。它不是压缩名字、也不是上磁盘或复用缓存。

Q5. 关于 __slots__ 的限制，以下哪些说法正确？

多选题 · hard

  • A.不能动态添加新的属性← 正确答案
  • B.继承时可能重新出现字典← 正确答案
  • C.所有方法变成私有方法
  • D.无法读取已有属性值

答案：AB。__slots__ 固定了属性集合，实例没有 __dict__，动态添加属性会抛 AttributeError。继承时如果子类不声明自己的 __slots__，子类实例会重新获得 __dict__，省内存效果失效。C 和 D 与 __slots__ 无关，方法不受影响，已有属性也可正常读取。

Q6. @dataclass(slots=True) 需要哪个 Python 版本以上才能使用？

单选题 · easy

  • A.Python 3.7 及以上版本
  • B.Python 3.8 及以上版本
  • C.Python 3.9 及以上版本
  • D.Python 3.10 及以上版本← 正确答案

答案：D。slots=True 参数是在 Python 3.10 中加入到 dataclass 的。3.9 及以下版本需要手动定义 __slots__ 再叠加 @dataclass 才能达到类似效果，代码会多写几行。

Q7. 普通 class 实例能够动态添加属性，依赖的是什么机制？

单选题 · mid

  • A.实例中包含了 dict← 正确答案
  • B.类中定义了类级别属性
  • C.实例共享同一个字典
  • D.Python 解释器自动分配

答案：A。普通实例自带一个 __dict__ 字典，属性就存进这个“弹性背包”，所以随时能往里塞新键。__slots__ 去掉背包后，动态添加就不再可行。类级别属性和解释器分配都不是实例动态属性的原因。

Q8. 关于 __slots__ 与继承的关系，正确的说法有哪些？

多选题 · hard

  • A.子类需声明自己的 slots← 正确答案
  • B.父类 slots 会完全失效
  • C.子类不声明会得到 dict← 正确答案
  • D.子类不能继承任何属性

答案：AC。父类的 __slots__ 描述符会自动继承，但如果子类不声明自己的 __slots__，Python 会为子类实例重新生成 __dict__，导致省内存失效。所以子类必须声明自己的槽位。B 说父类 slots 完全失效是错的——父类属性仍走槽位；D 说不能继承任何属性更是无稽之谈。

Q9. 下列哪种场景最适合使用 __slots__？

单选题 · mid

  • A.大量短生命周期实例对象← 正确答案
  • B.需要动态添加属性的类
  • C.几乎不创建对象的类
  • D.必须使用多重继承时

答案：A。__slots__ 的收益与实例数量成正比——实例越多，省下的 __dict__ 就越多。短生命周期的大量对象（如日志记录、坐标点）是最佳场景。需要动态属性的类用 __slots__ 反而受限，几乎不创建对象则收益微乎其微。

Q10. dataclass 的 order=True 参数会自动生成什么？

单选题 · easy

  • A.比较排序方法如小于等于← 正确答案
  • B.仅生成等于和不等于方法
  • C.自动生成哈希函数 hash
  • D.生成迭代器方法 iter

答案：A。order=True 会按字段顺序生成 __lt__、__le__、__gt__、__ge__ 一整套比较方法，排序逻辑类似字典序。等于不等于方法由 eq=True 控制，哈希函数由 frozen 联动控制，迭代器与排序无关。