当前位置：首页 > article >正文

CHAPTER 5 Data Class Builders

article 2025/3/6 12:01:18

序

Data classes are like children. They are okay as a starting point, but to participate as a
grownup object, they need to take some responsibility.
—Martin Fowler and Kent Beck1

本意就是在说：数据类在编程中可作为起步阶段的简单数据载体，就像孩子一样具有初始性和基础性，但要像成熟的对象那样在系统中充分发挥作用，就不能仅局限于存储数据，还需具备处理数据的相关行为和逻辑。

Python提供了几种方法来构建简单类，这种类只是字段的集合，很少或几乎没有额外功能。这种模式被称为 “数据类”，而data classes是支持这种模式的包之一。本章将介绍三种不同的类构建器，你可以用它们作为编写数据类的快捷方式：

collections.namedtuple：这是最简单的方式，自Python 2.6起就可用。
typing.NamedTuple：一种替代方法，要求对字段进行类型提示，自Python 3.5起可用，Python 3.6中增加了类语法。
@dataclasses.dataclass：这是一个类装饰器，比之前的方法提供了更多的自定义功能，增加了许多选项，也可能带来更多复杂性，自Python 3.7起可用。
介绍完这些类构建器后，我们将讨论为什么 “数据类” 也被视为一种代码坏味道：这是一种编码模式，可能表明存在糟糕的面向对象设计。

typing.TypedDict可能看起来像是另一种数据类构建器。它使用类似的语法，在Python 3.9的typing模块文档中，紧挨着typing.NamedTuple进行介绍。然而，TypedDict并不会构建你可以实例化的具体类。它只是一种语法，用于为函数参数和变量编写类型提示，这些参数和变量将接受用作记录的映射值，其中键作为字段名。我们将在第15章 “TypedDict”（第526页）中介绍它。

本章节对于工程开发并不是很重要–选择观看

1、本章新增内容

本章是《流畅的Python》第二版新增的内容。第169页的 “经典具名元组” 一节曾出现在第一版的第2章，但本章其余部分都是全新的内容。我们将从这三种类构建器的概述开始讲起。

2、Overview of Data Class Builders

一、背景与痛点分析

1.1 传统类实现的缺陷

class Coordinate:
    def __init__(self, lat, lon):
        self.lat = lat
        self.lon = lon

问题表现：

无意义的对象表示：<coordinates.Coordinate at 0x107142f10>
默认的__eq__比较对象ID而非内容
需要手动编写大量重复的初始化代码
无法直接比较内容：location == moscow返回False

实际案例对比：

>>> loc1 = Coordinate(55.76, 37.62)
>>> loc2 = Coordinate(55.76, 37.62)
>>> loc1 == loc2  # False
>>> (loc1.lat, loc1.lon) == (loc2.lat, loc2.lon)  # True

1.2 数据类的核心需求

自动生成__init__/__repr__/__eq__方法
支持类型注解
可扩展自定义方法
内存高效

二、三种数据类构建方案对比

2.1 collections.namedtuple

基础用法

from collections import namedtuple

Coordinate = namedtuple('Coordinate', ['lat', 'lon'])
moscow = Coordinate(55.756, 37.617)

特性：
✅ 继承自tuple类型
✅ 不可变实例
✅ 自动生成__repr__和值比较
⚠️ 字段顺序敏感
⚠️ 无类型注解支持

典型错误案例：

错误字段顺序会导致数据错乱
geo = Coordinate(lon=37.617, lat=55.756)  # 正确写法
geo = Coordinate(37.617, 55.756)          # 经度纬度颠倒！

2.2 typing.NamedTuple

类型注解进阶版

from typing import NamedTuple

class Coordinate(NamedTuple):
    lat: float
    lon: float
    
    def __str__(self):
        ns = 'N' if self.lat >=0 else 'S'
        we = 'E' if self.lon >=0 else 'W'
        return f"{abs(self.lat):.1f}°{ns}, {abs(self.lon):.1f}°{we}"

核心优势：
✅ 支持PEP 526类型注解
✅ 可添加自定义方法
✅ 保持tuple特性
✅ 更好的IDE支持

类型验证示例：

>>> Coordinate(lat='55.76', lon=37.62)  # 不会报错但会有类型提示
>>> typing.get_type_hints(Coordinate)
{'lat': float, 'lon': float}

2.3 dataclass装饰器

现代解决方案

from dataclasses import dataclass

@dataclass(frozen=True, order=True)
class Coordinate:
    lat: float
    lon: float
    
    def __str__(self):
        ns = 'N' if self.lat >=0 else 'S'
        we = 'E' if self.lon >=0 else 'W'
        return f"{abs(self.lat):.1f}°{ns}, {abs(self.lon):.1f}°{we}"

三、关键选择指南

特性	namedtuple	NamedTuple	dataclass
继承关系	tuple	tuple	object
可变性	不可变	不可变	默认可变
内存效率	最高	高	一般
类型注解	不支持	支持	支持
自定义方法	有限	完全支持	完全支持
额外功能（排序/哈希）	无	无	通过参数配置

四、最佳实践建议

纯数据存储场景：优先考虑NamedTuple，兼顾类型安全和tuple特性
需要可变对象时：使用@dataclass并保持默认参数
字典替代方案：当需要字段名访问时，比传统字典更安全高效
API设计场景：frozen=True可以创建安全的不可变数据对象
性能关键路径：namedtuple内存效率最高，适合大规模数据存储

五、常见错误防范

字段顺序错误（namedtuple）：

正确创建顺序
Point = namedtuple('Point', 'x y')
p = Point(10, 20)

常见错误写法
p = Point(y=20, x=10)  # 虽然合法但破坏约定

类型注解误解：

class User(NamedTuple):
    name: str  # 实际会转换为__annotations__属性
    age: int = 0  # 默认值必须放在最后！

dataclass可变性冲突：

@dataclass(frozen=True)
class Immutable:
    items: list  # 危险！列表内容仍然可变

obj = Immutable([1,2,3])
obj.items.append(4)  # 不会报错！

继承问题：

class Base(NamedTuple):
    x: int

class Child(Base):  # 错误！NamedTuple不能被子类化
    y: int

六、综合应用示例

地理坐标系统实现

from dataclasses import dataclass
from typing import Tuple

@dataclass(order=True)
class GeoPoint:
    latitude: float
    longitude: float
    elevation: float = 0.0  # 海拔默认值
    tags: Tuple[str] = tuple()  # 不可变标签

    @property
    def hemisphere(self) -> str:
        return 'Northern' if self.latitude >=0 else 'Southern'

    def to_tuple(self) -> Tuple[float, float]:
        return (self.latitude, self.longitude)

使用示例
alps = GeoPoint(46.4432, 8.5601, 4808, ('mountain', 'Europe'))
print(alps)  # 自动生成友好的__repr__
sorted_points = sorted([alps, GeoPoint(40.7128, -74.0060)])

本实现展示了：

默认参数的使用
排序功能的启用
自定义属性的添加
类型注解的完整应用
复杂数据类型的处理（元组标签）

（针对上文）dataclass order参数深度解析

█ 知识背景
@dataclass(order=True) 会为数据类自动生成比较运算符（<, <=, >, >=），其比较逻辑基于字段声明顺序。这是Python 3.7+的特性，能显著简化需要排序的类开发。

█ 核心作用解析
原始示例说明

@dataclass(frozen=True, order=True)
class Coordinate:
    lat: float
    lon: float

此时自动生成的特殊方法：

__lt__（小于）
__le__（小于等于）
__gt__（大于）
__ge__（大于等于）

比较逻辑演示

c1 = Coordinate(35.6, 139.7)  # 东京坐标
c2 = Coordinate(40.7, 74.0)   # 纽约坐标

print(c1 < c2)  # 输出：True

比较过程分解：

先比较第一个字段 lat：35.6 vs 40.7 → 东京更小
若 lat 相同，则比较 lon
比较顺序完全由字段声明顺序决定

█ 关键特性与注意事项

字段顺序敏感

@dataclass(order=True)
class User:
    age: int
    name: str  # 年龄字段优先比较

user1 = User(25, "Alice")
user2 = User(25, "Bob")
print(user1 < user2)  # 比较字符串 "Alice" < "Bob" → True

不可变类最佳实践
当同时使用 frozen=True 时：

保证比较结果的一致性
允许对象作为字典键使用

locations = {
    Coordinate(35.6, 139.7): "Tokyo",
    Coordinate(40.7, 74.0): "New York"
}

类型一致性要求

@dataclass(order=True)
class MixedTypes:
    a: int
    b: str  # 不同类型字段可能引发比较异常

x = MixedTypes(1, "a")
y = MixedTypes(2, "b")
print(x < y)  # 先比较数字，正常执行

这里如果y = MixedTypes("b", 2) 运行print会得到

Traceback (most recent call last):
  File "/Users/wangxinnan/Downloads/baidu/personal-code/soc-code/AI_Search/rethink_intelligence.py", line 44, in <module>
    print(x < y)
  File "<string>", line 4, in __lt__
TypeError: '<' not supported between instances of 'int' and 'str'

但如果没有print语句，则会直接运行
在这里插入图片描述

MixedTypes(a=1, b='a')
MixedTypes(a='b', b=2)

性能优化提示
自动生成的比较方法等效于：

def __lt__(self, other):
    return (self.lat, self.lon) < (other.lat, other.lon)

█ 易错点警示
错误案例1：嵌套结构比较

@dataclass(order=True)
class Node:
    value: list  # 列表不可直接比较
    next: 'Node'

n1 = Node([1], None)
n2 = Node([2], None)
print(n1 < n2)  # 抛出 TypeError

█ 最佳实践总结

始终明确字段声明顺序
结合 frozen=True 确保数据完整性
类型标注应使用可比较类型
复杂比较逻辑建议手动实现 __lt__
测试时验证边界条件（如字段值相同的情况）

通过合理使用 order=True，可以减少约80%的比较逻辑代码量，同时保证排序行为的一致性。但在涉及复杂业务规则时，仍建议手动实现比较方法以保证逻辑清晰。

核心参数说明：

frozen=True：创建不可变对象（类似元组）
order=True：生成比较运算符
eq=True（默认）：自动生成__eq__

可变性对比实验：

@dataclass
class MutableCoord:
    lat: float
    lon: float

mc = MutableCoord(55.76, 37.62)
mc.lat = 0.0  # 允许修改

@dataclass(frozen=True)
class ImmutableCoord:
    lat: float
    lon: float

ic = ImmutableCoord(55.76, 37.62)
ic.lat = 0.0  # 抛出FrozenInstanceError

（针对上文的）Python 类型

类型注释的核心作用

静态类型检查（通过 mypy/pyright 等工具）
- 例：def add(a: int, b: int) -> int: 能提前发现参数类型错误
- 类比：代码的"体检报告"，在运行前发现问题

代码可读性增强

示例对比：

# 无类型提示
def process(data):
    return data.upper()
    
# 有类型提示
def process(data: str) -> str:
    return data.upper()

IDE 智能提示支持
- 类型驱动代码补全（PyCharm/VSCode 可识别字段类型）

那为什么示例代码没有报错？
根本原因：
Python 的@dataclass仅生成类型提示，不做运行时验证

运行机制分解：

@dataclass(order=True)
class MixedTypes:
    a: int  # ← 类型注解
    b: str  # ← 不会触发运行时检查

类型提示是元数据（metadata），不影响对象构造

字段赋值本质仍是动态类型操作：

y = MixedTypes("b", 2)  # 等效于直接给实例属性赋值

潜在危险点
当触发比较操作时会暴露类型问题：

print(x < y)  # 触发 TypeError: '<' not supported between 'int' and 'str'

补充验证案例
案例1：类型不匹配的运算

class Calc:
    def add(self, a: int, b: int) -> int:
        return a + b

运行时不会报错，但结果错误
print(Calc().add("1", 2))  # 输出 "12"

案例2：动态类型特性

@dataclass
class DynamicDemo:
    value: float
    
obj = DynamicDemo("hello")  # 正常创建
print(obj.value * 2)        # 运行时才报错

核心结论
Python 类型系统特点

特性	说明	示例场景
渐进式类型	类型提示可选，兼容动态类型代码	旧项目逐步引入类型检查
鸭子类型	关注对象行为而非具体类型	`__len__` 实现即视为可迭代对象
运行时无强制验证	类型注解不改变运行时行为	本课示例中的 `MixedTypes` 案例
协议驱动	通过 `Protocol` 定义接口规范	自定义可迭代类型实现

最佳实践建议

配套使用静态检查工具

pip install mypy
mypy your_script.py

能检测到示例中的类型错误：

error: Argument "a" to "MixedTypes" has incompatible type "str"; expected "int"

数据校验方案选择

# 方案1：使用 pydantic（运行时验证）
from pydantic import BaseModel

class ValidatedModel(BaseModel):
    a: int
    b: str

# 尝试构造错误类型时会报错
ValidatedModel(a='abc', b=123)  # 触发 ValidationError

防御性编程技巧

def safe_compare(a: Any, b: Any) -> bool:
    if type(a) != type(b):
        return False
    return a < b

扩展思考
当需要强制类型校验时，可以：

在 __post_init__ 方法添加验证逻辑

@dataclass
class ValidatedData:
    age: int
    
    def __post_init__(self):
        if not isinstance(self.age, int):
            raise TypeError("age must be integer")

使用 descriptor 实现类型约束

class TypedField:
    def __init__(self, type_):
        self.type = type_
    
    def __set_name__(self, owner, name):
        self.name = name
    
    def __set__(self, instance, value):
        if not isinstance(value, self.type):
            raise TypeError(f"Expected {self.type}")
        instance.__dict__[self.name] = value

（针对上文）Python不可变数据类陷阱

详解

█ 知识背景

Python 不可变类型本质

可变对象（Mutable）：对象内容修改后，内存地址不变
- 典型类型：list（列表）、dict（字典）、set（集合）
- 例如向列表追加元素时，原列表的内存地址保持不变。
不可变对象（Immutable）：对象内容修改后，内存地址改变
- 典型类型：int（整数）、str（字符串）、tuple（元组）
- 例如字符串拼接会生成新对象，旧内存地址被释放。
@dataclass(frozen=True) 仅冻结类实例属性的重新赋值，不冻结容器内部操作

核心矛盾点

@dataclass(frozen=True)
class Immutable:
    items: list  # 危险！仅冻结 items 属性本身，不冻结列表内容

obj = Immutable([1,2,3])
obj.items = [4,5,6]  # ❌ 触发 FrozenInstanceError
obj.items.append(4)   # ✅ 允许操作（潜在风险点）

█ 典型问题解析

容器嵌套问题
原始案例重现

from dataclasses import dataclass

@dataclass(frozen=True)
class ShoppingCart:
    products: list  # 可变容器
    owner: str      # 不可变类型

cart = ShoppingCart(['apple', 'book'], 'Alice')
cart.products.append('pen')  # 成功修改（违反直觉）

问题本质

frozen=True 仅阻止属性重新赋值（cart.products = [...]）
不阻止对已有可变属性的内部操作（list.append()）

多维嵌套风险
进阶案例说明

@dataclass(frozen=True)
class Matrix:
    data: list[list]  # 二维可变结构

m = Matrix([[1,2], [3,4]])
m.data[0][0] = 999  # 成功修改

字典值污染

@dataclass(frozen=True)
class Config:
    params: dict

cfg = Config({'batch_size': 32})
cfg.params['batch_size'] = 64  # 成功篡改参数

█ 解决方案与最佳实践

类型替代方案

from typing import Tuple

@dataclass(frozen=True)
class SafeImmutable:
    items: Tuple[int, ...]  # 使用元组替代列表
    metadata: frozenset     # 使用冻结集合

深度冻结方案

def deep_freeze(obj):
    if isinstance(obj, dict):
        return frozendict({k: deep_freeze(v) for k, v in obj.items()})
    elif isinstance(obj, list):
        return tuple(deep_freeze(x) for x in obj)
    return obj

@dataclass(frozen=True)
class DeepImmutable:
    items: list = field(default_factory=list)
    
    def __post_init__(self):
        object.__setattr__(self, 'items', deep_freeze(self.items))

防御性拷贝

from copy import deepcopy

@dataclass(frozen=True)
class DefensiveCopy:
    _data: list = field(repr=False)
    
    @property
    def data(self):
        return deepcopy(self._data)  # 返回副本

█ 常见错误模式
错误认知链

错误推论过程
1. 类被标记为 frozen → 
2. 所有属性不可变 → 
3. 容器内容不可修改（实际错误）

错误使用场景

class UserProfile:
    def __init__(self, history):
        self.history = history  # 接收外部可变对象

profile = UserProfile(user_input_list)
user_input_list.clear()  # 导致 profile.history 同步清空

█ 验证实验
内存验证实验

a = [1,2,3]
obj = Immutable(a)
print(id(obj.items))  # 输出地址1
a.append(4)
print(id(obj.items))  # 地址1未变，但内容已改！

哈希稳定性测试

d = {}
obj1 = Immutable([1,2])
d[obj1] = 'original'

obj1.items.append(3)
d[obj1]  # KeyError: 哈希值已改变但对象仍存在

█ 设计原则

最小暴露原则：对外仅暴露不可变接口
深度不可变：递归处理嵌套结构
输入消毒：构造函数内进行类型转换
文档警示：明确标注接口的不可变性范围

█ 扩展思考
性能权衡

浅冻结：时间复杂度 O(1)，空间复杂度 O(1)
深度冻结：时间复杂度 O(n)，空间复杂度 O(n)

框架集成

在 Django model 中，通过重写 __setattr__ 实现深度不可变
使用 pydantic 库的 allow_mutation=False 配置

[关键总结]
1. frozen=True ≠ 完全不可变 → 需配合容器冻结
2. 不可变对象中的可变元素会破坏哈希稳定性
3. 防御性编程是保证不可变性的关键
4. 类型提示应明确标注实际不可变性级别

默认参数的隐蔽共享

▮ 内存原理三维拆解
Ⅰ 定义阶段内存状态

数据类定义时 
@dataclass 
class DataClass:
    shared_dict: dict = {}  # 立即分配内存地址0x1000 
    
普通类定义时  
class NormalClass:
    def __init__(self):
        self.unique_dict = {}  # 此时无内存分配

Ⅱ 首次实例化过程

数据类实例化流程 
d1 = DataClass()
→ 自动生成__init__方法：def __init__(self, shared_dict=0x1000)
→ 实例属性指向类级字典 
 
普通类实例化流程  
n1 = NormalClass()
→ 执行__init__方法：self.unique_dict = {} → 新建字典（0x2000）
→ 实例属性指向新内存地址

Ⅲ 二次实例化对比

d2 = DataClass()  # 继续使用0x1000地址的字典 
n2 = NormalClass() # 新建字典（0x3000地址）

█ 内存地址演变表

操作序列	数据类字典地址	普通类字典地址
类定义完成时	0x1000	-
首次实例化后	0x1000	0x2000
二次实例化后	0x1000	0x3000
修改实例属性后	0x1000（全体变化）	仅当前实例变化

▮ 关键技术原理图解
数据类危险模式原理

           [DataClass类定义]
               ↓ 
创建共享字典 → 内存地址0x1000 
               ↓              
           [实例化d1] → 引用0x1000 
               ↓ 
           [实例化d2] → 引用0x1000 
               ↓ 
          任何修改 → 所有实例可见

普通类安全模式原理

           [NormalClass类定义]
               ↓ 
           [实例化n1] → 新建字典0x2000 
               ↓             
           [实例化n2] → 新建字典0x3000 
               ↓ 
         修改n1字典 → 仅影响0x2000

▮ 解决方案精讲
正确写法示例

@dataclass 
class SafeQuantumState:
    safe_config: dict = field(default_factory=dict)
    
s1 = SafeQuantumState()
s2 = SafeQuantumState()
s1.safe_config["algorithm"] = "Grover"  # 不影响s2

等效底层实现

field(default_factory=dict) 的等价展开 
def __init__(self, config_factory=lambda: dict()):
    self.safe_config = config_factory()  # 每次调用生成新字典

内存变化过程

实例化s1 → 调用dict() → 新建字典@0x4000 
实例化s2 → 调用dict() → 新建字典@0x5000 
修改s1 → 仅改变0x4000地址的数据

终极安全方案

@dataclass 
class UltraSafe: 
    config: dict = field(default_factory=lambda: defaultdict(list))
    
    def __post_init__(self):
        # 深度拷贝确保绝对隔离 
        self.config = deepcopy(self.config)

▮ 开发实践准则

防御性编程四要素：
- 对所有可变类型使用default_factory
- 对需要动态初始化的属性使用__post_init__
- 对复杂嵌套结构使用deepcopy
- 在团队规范中明确标注危险模式
调试技巧：

print(id(obj.config))  # 检查内存地址是否相同 
assert obj1.config is not obj2.config  # 添加断言验证

Main Features

一、数据类构建器概述
Python提供了三种主要的数据类构建工具，满足不同场景需求：

特性对比项	`namedtuple`	`NamedTuple`	`dataclass`
可变性	❌	❌	✅
类语法支持	❌	✅	✅
构建字典方法	`._asdict()`	`._asdict()`	`asdict()`
获取字段默认值	`._fields_defaults`	`._fields_defaults`	`[f.default for f in fields()]`

注：表格仅展示核心差异，完整对比见后续详解

二、核心特性深度解析

可变性控制
核心差异：

namedtuple/NamedTuple：基于元组不可变
dataclass：默认可变，可冻结实例

示例演示：

from dataclasses import dataclass

@dataclass(frozen=True)
class Point:
    x: int
    y: int

p = Point(3, 4)
p.x = 5  # ❌ 抛出FrozenInstanceError

常见误区：

错误尝试修改元组型数据类实例
忘记frozen=True时误认为实例不可变

类语法支持
开发模式差异：

NamedTuple支持完整类定义
from typing import NamedTuple

class Vector(NamedTuple):
    x: float
    y: float
    
    def norm(self) -> float:
        return (self.x2 + self.y2)0.5

namedtuple工厂模式
from collections import namedtuple
Vector2 = namedtuple('Vector2', ['x', 'y'])

设计建议：

需要添加方法时优先选择NamedTuple或dataclass
简单结构可使用namedtuple快速创建

元数据获取方式
正确获取类型提示：

from typing import get_type_hints

class Person(NamedTuple):
    name: str
    age: int

正确方式（Python 3.5+）
print(get_type_hints(Person))  # {'name': <class 'str'>, 'age': <class 'int'>}

危险方式（不推荐）
print(Person.__annotations__)  # 可能包含未解析的前向引用

元数据对比表：

操作	namedtuple	NamedTuple	dataclass
获取字段名	`._fields`	`._fields`	`[f.name for f in fields()]`
获取默认值	`._field_defaults`	`._field_defaults`	`[f.default for f in fields()]`
获取类型	N/A	`get_type_hints()`	`get_type_hints()`

比如：

from dataclasses import dataclass, fields 
 
@dataclass 
class Employee:
    emp_id: str 
    name: str 
    salary: float = 5000.0 
 
e = Employee('E1001', 'Bob')
print([f.name for f in fields(e)])  # 输出：['emp_id', 'name', 'salary']

实例修改与复制
不可变实例修改方案：

# namedtuple示例
from collections import namedtuple
Car = namedtuple('Car', ['color', 'speed'])
c1 = Car('red', 100)
c2 = c1._replace(color='blue')

# dataclass示例
from dataclasses import replace
@dataclass
class Truck:
    color: str
    speed: int

t1 = Truck('white', 80)
t2 = replace(t1, speed=90)

关键区别：

命名元组使用实例方法_replace
数据类使用模块级函数replace()

三、动态类创建技巧
运行时类生成方法对比

# namedtuple动态创建
Robot = namedtuple('Robot', ['name', 'battery'])

# NamedTuple动态创建
RobotNT = NamedTuple('RobotNT', [('name', str), ('battery', float)])

# dataclass动态创建
from dataclasses import make_dataclass
RobotDC = make_dataclass('RobotDC', [('name', str), ('battery', float)])

适用场景：

处理动态数据结构（如CSV表头转换）
框架级别的元编程需求
配置驱动的类生成场景

四、最佳实践指南

类型提示处理：
- 优先使用typing.get_type_hints()替代直接访问__annotations__
- 处理前向引用时使用字符串类型注解
可变性选择策略：
性能考量：
- 元组型数据类内存效率更高
- 数据类在频繁修改场景表现更优
- 冻结数据类的哈希值可安全用于字典键
版本兼容注意：
- dataclass需要Python 3.7+
- typing.NamedTuple在3.6+表现最佳
- inspect.get_annotations()需要Python 3.10+

五、综合应用示例

from dataclasses import dataclass, asdict
from typing import NamedTuple, get_type_hints

# 电商订单系统建模
@dataclass(order=True)
class Order:
    order_id: str
    items: list[str]
    total: float
    paid: bool = False

    def mark_paid(self):
        self.paid = True

# 物流坐标点建模
class Coordinate(NamedTuple):
    lat: float
    lng: float
    
    def to_geojson(self):
        return {'type': 'Point', 'coordinates': (self.lat, self.lng)}

# 使用示例
order = Order('20230227-001', ['book', 'pen'], 58.5)
print(asdict(order))  # 序列化为字典

point = Coordinate(39.9042, 116.4074)
print(point.to_geojson())  # 输出GeoJSON格式

六、调试与问题排查：

意外修改冻结实例：

@dataclass(frozen=True)
class A:
    x: int

a = A(1)
a.x = 2  # ❌ 触发

3、Classic Named Tuples

Python 的 collections.namedtuple

1. 什么是 `namedtuple`？

背景:
- namedtuple 是 Python 标准库 collections 提供的一个工厂函数。它用于创建具有字段名的元组子类。
- 通过 namedtuple 创建的类能够像普通元组一样使用，同时支持字段名访问，增强了代码可读性和可维护性。
用途：
- 大量简化了基于元组的数据结构定义。
- 经常用于需要存储简单数据对象的场景，比如返回多字段结果的函数。
- 节省内存：namedtuple 实例与普通元组占用的内存相同，因为字段名存储在类对象中，而不是实例。（其实就是这玩意直接存储在类对象的属性，是属于类本身的）
优点：
- 既能按字段名访问数据，又能像普通元组一样按索引访问。
- 提供更有意义的表示（repr），方便调试。
- 与普通元组完全兼容，支持序列解包（比如 *args），完整保留元组的功能。
- 非常适合需要轻量但具结构化的不可变数据对象。

2. 创建和访问 `namedtuple`

如何定义：
namedtuple 函数接收两个必要参数：
1. 类名（str 类型）。
2. 字段名（可以是一个由字符串组成的可迭代对象，或以空格分隔的字符串）。

示例：定义和创建 City 类。

from collections import namedtuple

# 定义 namedtuple
City = namedtuple('City', 'name country population coordinates')
# 创建实例
tokyo = City('Tokyo', 'JP', 36.933, (35.689722, 139.691667))
# 显示实例
print(tokyo)  # 输出: City(name='Tokyo', country='JP', population=36.933, coordinates=(35.689722, 139.691667))

实例访问方式：

按字段名访问：

print(tokyo.population)  # 输出: 36.933
print(tokyo.coordinates)  # 输出: (35.689722, 139.691667)

按字段位置访问（与普通元组兼容）：

print(tokyo[0])  # 输出: 'Tokyo'
print(tokyo[1])  # 输出: 'JP'

注意：
- 要求字段值按顺序作为参数传入。
- 不能像字典一样直接以 key=value 指定字段值。

3. 常见功能和进阶操作

namedtuple 提供多种内建属性和方法，帮助开发更高效地操作和转换数据。

(1) `_fields` 属性

返回字段名的元组。

示例：

print(City._fields)  # 输出: ('name', 'country', 'population', 'coordinates')

(2) `_make(iterable)` 方法

从可迭代对象（如列表、元组）创建一个对象实例。

示例：

data = ('Delhi', 'IN', 21.935, (28.613889, 77.208889))
delhi = City._make(data)  # 等价于 City(*data)
print(delhi)  # 输出: City(name='Delhi', country='IN', population=21.935, coordinates=(28.613889, 77.208889))

从功能上来说，_make(iterable) 等价于直接解包每个元素 *data 来初始化命名元组。

(3) `_asdict()` 方法

将对象实例转换为普通字典（Python >= 3.8 的字典保留插入顺序）。

示例：

print(delhi._asdict())  
# 输出: {'name': 'Delhi', 'country': 'IN', 'population': 21.935, 'coordinates': (28.613889, 77.208889)}

应用场景：在序列化成 JSON 时很有用。

import json
print(json.dumps(delhi._asdict()))
# 输出: {"name": "Delhi", "country": "IN", "population": 21.935, "coordinates": [28.613889, 77.208889]}

(4) 默认字段值

从 Python 3.7 开始，namedtuple 接受 defaults 参数，为右边的字段指定默认值。

示例：

Coordinate = namedtuple('Coordinate', 'lat lon reference', defaults=['WGS84'])
c = Coordinate(0, 0)
print(c)  # 输出: Coordinate(lat=0, lon=0, reference='WGS84')
print(Coordinate._field_defaults)  # 输出: {'reference': 'WGS84'}

4. 如何扩展 `namedtuple`

(1) 添加方法

虽然 namedtuple 是不可变的（类似元组），但可以通过某些技巧为它添加方法。

方法添加示例：

# 定义 namedtuple
from collections import namedtuple
Card = namedtuple('Card', ['rank', 'suit'])

# 添加一个函数（方法逻辑）
def spades_high(card):
    suit_values = {'spades': 3, 'hearts': 2, 'diamonds': 1, 'clubs': 0}  # 花色优先级
    rank_value = '23456789TJQKA'.index(card.rank)  # 计算等级
    return rank_value * len(suit_values) + suit_values[card.suit]

# 将函数绑定为 namedtuple 方法
Card.spades_high = spades_high

# 示例
card1 = Card('2', 'clubs')  # 最低级
card2 = Card('A', 'spades')  # 最高级
print(card1.spades_high())  # 输出: 0
print(card2.spades_high())  # 输出: 51

(2) 使用 `typing.NamedTuple`

typing.NamedTuple 提供类似的功能，但支持更灵活的定义方式（如类语法），非常适合 Python 面向对象风格编码。

示例：

from typing import NamedTuple

class City(NamedTuple):
    name: str
    country: str
    population: float
    coordinates: tuple

tokyo = City('Tokyo', 'JP', 36.933, (35.689722, 139.691667))
print(tokyo.name)  # 属性访问

5. 注意事项与易错点

不可变性：
- namedtuple 是不可变的，字段值一旦设置，不可修改。这种特性类似于普通元组。
- 如果需要可变的字段建议使用 dataclass（Python 3.7+）代替。
字段名冲突：
- 字段名不能与 namedtuple 内置的方法名称冲突（如 _fields、_make）。
- 避免使用 Python 关键词（如 class、for）。
默认值机制：
- 默认值必须为右侧连续的字段指定（类似函数参数默认值规则）。否则会抛出错误。
字段名合法性：
- 字段名需为有效的 Python 标识符，不能包含空格、数字开头或非法字符。

6. 总结与对比

特性	普通元组	`namedtuple`	`dataclass`
内存效率	高	高	较低
字段访问方式	按索引	按名或索引	按名
可变性	不可变	不可变	默认可变
默认值支持	不支持	支持	支持
适合使用场景	无需字段名的简易结构	轻量的、不可变的数据对象结构	更灵活、复杂的数据模型

4、Typed Named Tuples

背景介绍

在 Python 中，NamedTuple 是一种结合了元组的不可变特性和类的可读性的新型构造器。它允许我们定义类似类的结构体，同时支持通过名称访问字段的值。随着 Python 类型注解的引入，typing.NamedTuple 提供了更加现代化的书写方式，支持为每个字段添加显式的类型注解，增强代码的可读性和可维护性。

本节将介绍如何使用 typing.NamedTuple 定义带类型注解的命名元组，并比较它与传统 collections.namedtuple 的差别。

示例代码讲解

示例代码

from typing import NamedTuple

class Coordinate(NamedTuple):
    lat: float  # 纬度，类型为浮点数
    lon: float  # 经度，类型为浮点数
    reference: str = 'WGS84'  # 参考坐标系，默认为 'WGS84'

示例说明

字段类型注解：
- 在 NamedTuple 定义中，每个字段必须显式地声明其类型（如 lat: float）。
- 文件末尾可选地为字段添加默认值，例如 reference: str = 'WGS84'。
不可变性：
- NamedTuple 的实例是不可变的，类似普通元组。一旦实例被创建，其字段值就无法改变。
自动生成的方法：
- 定义的 NamedTuple 类会自动生成如下方法：
  - 构造函数 (__init__)：用于实例化。
  - __repr__：提供更具可读性的字符串表示。
  - 其他元组相关的功能（如索引和迭代）。
annotations 属性：
- NamedTuple 生成的类会包含一个类属性 __annotations__，记录所有字段的类型。这仅在类型检查工具和静态分析时有用，Python 运行时会忽略。

深入解析和补充示例

关键知识点

typing.NamedTuple 是 collections.namedtuple 的增强版，主要差别在于支持 显式类型注解。
如果字段需要默认值，必须将其写在所有无默认值字段之后，否则会引发 SyntaxError。

示例 1：字段顺序规则

下面代码会导致错误，因为默认值字段放在了非默认值字段之前：

from typing import NamedTuple

# 会报错：默认值字段必须在所有非默认值字段之后
class InvalidCoordinate(NamedTuple):
    reference: str = 'WGS84'  # 默认值字段
    lat: float  
    lon: float

修正后的代码：

class ValidCoordinate(NamedTuple):
    lat: float
    lon: float
    reference: str = 'WGS84'  # 默认值字段必须位于最后

示例 2：实例化过程

coord1 = Coordinate(40.7128, -74.0060)
print(coord1)  # Coordinate(lat=40.7128, lon=-74.006, reference='WGS84')

coord2 = Coordinate(34.0522, -118.2437, reference='NAD83')
print(coord2)  # Coordinate(lat=34.0522, lon=-118.2437, reference='NAD83')

# 尝试修改字段，会报错
# coord1.lat = 51.5074  # AttributeError: can't set attribute

示例 3：类型检查和 IDE 支持

typing.NamedTuple 所定义的类型注解能提供更好的开发体验：

def print_coordinate(coord: Coordinate) -> None:
    print(f"Latitude: {coord.lat}, Longitude: {coord.lon}, Reference: {coord.reference}")

# 调用时类型检查生效
print_coordinate(Coordinate(51.5074, -0.1278))  # 正确
# print_coordinate((51.5074, -0.1278))  # 错误：会被类型检查工具标记为不匹配

使用 Typed NamedTuple 的注意事项

比较和继承：
- NamedTuple 不支持普通类的继承方式，它本质上是一个特殊类，基于 tuple。
- 如果需要实现更多自定义方法，考虑使用 dataclasses.dataclass。
运行时行为：
- Python 运行时不会强制类型检查，类型注解仅供静态分析工具（如 MyPy）使用。对于运行时的参数校验，需手动实现。
默认值与顺序：
- 默认值字段必须写在无默认值字段的后面。

不可变性：

无法修改 NamedTuple 实例字段，但可以通过 ._replace() 方法生成新的实例：

new_coord = coord1._replace(reference='NAD83')
print(new_coord)  # Coordinate(lat=40.7128, lon=-74.006, reference='NAD83')

总结

typing.NamedTuple 是一个强大而简洁的数据结构工具，适用于简单的不可变对象定义。
核心特性包括显式类型注解、默认字段值及自动生成的方法。
适用场景：需要定义轻量级的数据容器，增强代码的可读性和类型安全性。
学习路径：
1. 理解其与 collections.namedtuple 的异同。
2. 熟悉字段的顺序规则及实例化操作。
3. 在静态类型检查工具中体会类型注解的优势。

通过对 NamedTuple 的语法和使用方法的掌握，我们可以编写简洁可靠且类型安全的代码，同时减少出错的可能性。

5、Type Hints 101

帮助你理解 Python 类型提示（Type Hints）背后的意图、用法，以及它们在 typing.NamedTuple 和 @dataclass 等用法中的特性与区别。

一. 类型提示的背景及目的

1. 什么是类型提示（Type Hints）？

类型提示是 Python 为函数参数、返回值、变量和属性声明预期类型的一种方式。

例子:

def greet(name: str) -> str:
    return f"Hello, {name}"

2. 类型提示的特点

类型提示不会影响运行时行为：

Python 不会在运行时检查类型是否符合声明的提示。
类型提示是纯“文档性质”，用于辅助手动阅读和借助 IDE（如 PyCharm）或工具（如 MyPy）进行静态类型检查。
例子:

from typing import NamedTuple

class Coordinate(NamedTuple):
    lat: float
    lon: float

# 虽然类型提示指出 lat 和 lon 应为 float
coord = Coordinate("Not a float", None)  # 不会触发运行时错误
print(coord)  # Coordinate(lat='Not a float', lon=None)

如果使用 MyPy 检查此代码：

$ mypy example.py
example.py:8: error: Argument 1 to "Coordinate" has incompatible type "str"; expected "float"
example.py:8: error: Argument 2 to "Coordinate" has incompatible type "None"; expected "float"

二. 类型提示的基础语法

1. 基本语法

类型提示的典型形式：

var_name: some_type

常见的类型:
1. 内置类型: int, str, float, 等。
2. 泛型集合类型: list[int], tuple[str, float], 等。
3. 可选类型: 使用 Optional[T] 表示类型允许为 T 或 None。
  - 例：Optional[str] 等价于 Union[str, None]。
支持默认值：可以同时指定类型和默认值。
```
x: int = 42
name: Optional[str] = None
```

三. 类型提示在 Python 三种数据类构建器中的作用

数据类构建器在 Python 提供了简化 class 定义的功能：普通类、NamedTuple 和 @dataclass。以下详细比较它们在类型提示中的行为。

1. 普通类的行为

普通类支持类型提示，但它们只是被写入 __annotations__ 中用于参考。

例子：

class PlainClass:
    a: int
    b: float = 1.1
    c = 'spam'

行为特点：
1. a: 作为类型注解而存在，保存在 __annotations__ 中，但不会成为类属性。
2. b: 同时作为类型注解保存在 __annotations__ 中，并作为带默认值的类属性存在。
3. c: 普通的类属性，与类型注解无关。

验证：

print(PlainClass.__annotations__)  # {'a': <class 'int'>, 'b': <class 'float'>}
print(PlainClass.a)  # AttributeError: no attribute 'a'
print(PlainClass.b)  # 1.1
print(PlainClass.c)  # 'spam'

为什么a不是类属性呢

想到一个好的例子

class PlainClass:
    a: int = 0  # 类属性，初始值为0
    b: float = 1.1
    c = 'spam'

# 修改类属性 'a'
PlainClass.a = 3

# 创建 PlainClass 的一个实例
p = PlainClass()

print(PlainClass.a)  # 输出: 3，因为 'a' 是类属性
print(p.a)           # 输出: 3，因为实例 'p' 使用类属性

# 修改实例 'p' 的实例属性 'a'
p.a = 1

print(p.a)           # 输出: 1，因为 'a' 现在是实例 'p' 的实例属性
print(PlainClass.a)  # 输出: 3，类属性没有改变

# 创建另一个实例
q = PlainClass()

print(q.a)           # 输出: 3，因为实例 'q' 使用类属性

在 Python 中，类属性和实例属性有不同的定义方式。代码中的行为是由于 a 被定义为类型注解，但没有被赋值，因此它并未成为类属性。

类属性 vs 实例属性：

类属性是在类定义中直接赋值的变量，这些变量在所有实例之间共享。
实例属性是在类的实例化过程中（通常在 __init__ 方法中）或通过实例对象直接赋值的变量，这些变量是实例特有的。

2. NamedTuple 的行为

NamedTuple 会创建不可变的类，它的每个字段既是类型注解，也是实例的只读属性。

例子：

from typing import NamedTuple

class ExampleNT(NamedTuple):
    a: int
    b: float = 1.1
    c = 'spam'

行为特点：
1. a 和 b:
  - 作为类型注解，保存在 __annotations__。
  - 同时成为只读的实例属性。
2. c:
  - 普通类属性，与类型注解无关。

验证：

obj = ExampleNT(10)
print(obj.a)      # 10
print(obj.b)      # 1.1
print(obj.c)      # 'spam'
obj.a = 20        # AttributeError: cannot set attribute

3. DataClass 的行为

@dataclass 提供一个易于定义自定义类的方式，它比 NamedTuple 更灵活，允许实例是可变的。

例子：

from dataclasses import dataclass

@dataclass
class ExampleDC:
    a: int
    b: float = 1.1
    c = 'spam'

行为特点：
1. a 和 b:
  - 作为类型注解保存在 __annotations__。
  - 成为公开的可读写实例属性。
  - b 支持默认值。
2. c:
  - 普通类属性，与实例无直接关联。

验证：

obj = ExampleDC(10)
print(obj.a)      # 10
print(obj.b)      # 1.1
print(obj.c)      # 'spam'
obj.a = 20        # OK
obj.b = 'oops'    # OK，但类型检查工具会报错。
obj.c = 'new'     # 新增实例级属性，覆盖类级同名属性。
print(ExampleDC.c)  # 'spam'，原类属性未变。

四. 关键点与常见问题总结

**类型提示的主要作用是帮助 IDE 和工具进行静态类型检查，**不会在运行时生效。
普通类的类型注解不会自动转为属性值， 仅存储在 __annotations__ 中。
NamedTuple 提供了一种不可变数据结构， 类型定义的字段自动成为类的只读实例属性。
@dataclass 提供了更灵活的便捷类实例定义， 支持默认值和实例的可变性。

五. 补充学习与实践

1. 针对不同场景的扩展例子

可选类型:

from typing import Optional

@dataclass
class ExampleOptional:
    name: Optional[str] = None  # 允许为 None
obj = ExampleOptional()
print(obj.name)  # None

嵌套复杂类型:

from typing import List, Dict
@dataclass
class ComplexDC:
    data: List[int]
    mapping: Dict[str, int]

2. 常见问题

误解类型提示会被强制执行:
记住，Python 的运行时不会管类型。然而，大型项目中建议使用 MyPy 来强化代码质量。
忽视默认值的设置规则:
如果字段有默认值，必须从最后一个字段开始连续设置。例如：
```
@dataclass
class ExampleError:
    a: int = 0
    b: float  # 语法错误！
```

6、More About @dataclass

基本介绍

Python 的 @dataclass 是从 Python 3.7 引入的一个便捷装饰器，它大大简化了处理类数据模型的重复性代码，如常用的 __init__、__repr__ 等方法的生成，适用于只包含数据的简单类。本文将逐步深入讲解 @dataclass 的功能和参数，包括使用技巧和潜在的注意事项。

1. 什么是 @dataclass？

Python 的 @dataclass 装饰器可以帮助我们快速创建数据类。数据类通常是用来存储数据的类，它们的实例以“字段”管理数据，而 @dataclass 可以自动生成如下关键方法：

__init__: 自动生成初始化方法。
__repr__: 提供对象的可读字符串表示。
__eq__: 用于比较两个对象是否相等（基于字段值）。
__hash__: 生成哈希值（可选）。

适用场景：
如果你经常编写简单的“数据容器类”， @dataclass 会让代码更清晰简洁。

2. @dataclass 的关键参数

@dataclass 的签名如下：

@dataclass(*, init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False)

*: 表示所有参数只能通过关键字传递。
参数默认值是最常见的用法，但可以根据需求修改。

以下是主要参数的详细解释和作用：

参数名	含义	默认值	注意事项
init	自动生成 `__init__` 构造方法。	True	如果你手动实现了 `__init__`，此参数会被忽略。
repr	自动生成具有可读性的 `__repr__` 方法。	True	如果手动定义 `__repr__`，此参数无效。
eq	自动生成 `__eq__` 方法，用于对象间值的比较。	True	如果手动定义 `__eq__`，此参数无效。
order	自动生成比较方法：`__lt__`、`__le__`、`__gt__` 和 `__ge__`。	False	如果 `eq=False` 或已手动定义比较方法，启用此选项会抛出异常。
unsafe_hash	强制生成 `__hash__` 方法，哪怕对象可变。	False	不推荐使用，带来复杂性和潜在问题。此选项仅适合逻辑上不可变但技术上会被修改的类。
frozen	将类实例“冻结”为不可变的（模拟实现）。	False	实例本质上仍然可修改（非常规操作可以绕过冻结），但能有效防止意外修改。

3. 常见问题与注意事项

（1）字段排除和自定义

某些字段不想被用于 eq 或 hash 比较时，可以通过 field() 的选项排除（在后续章节讨论）。

（2）深度不可变问题

虽然 frozen=True 让类实例看似不可变，但如果字段本身是可变类型（如 list, dict），内容依然可以进行修改。为确保真正不可变，应使用不可变类型（如 tuple 替代 list）。

示例：

from dataclasses import dataclass

@dataclass(frozen=True)
class Test:
    items: tuple  # 使用 tuple

（3）动态性限制

尽管数据类提供便捷功能，但如果类逻辑较复杂，需要自定义构造器或方法时，应该谨慎设计，数据类可能并非最佳选择。

Field Options

字段选项是指为数据类的属性设置额外行为（如默认值、比较行为等）的机制。通过 dataclasses.field() 函数，可以为字段定义更复杂或精确的属性行为。

一、可变默认值的重要性和陷阱

1. 为什么避免可变默认值？

Python 中的一个常见坑是 可变默认值（如 list、dict）的复用问题。当默认值是可变对象时，该值在不同实例之间是共享的。一旦某个实例修改了默认值，其他实例的行为会受到影响。

举例说明：

def add_item(item, container=[]):  # 默认参数是一个可变的列表
    container.append(item)
    return container

# 调用示例
print(add_item(1))  # 输出：[1]
print(add_item(2))  # 输出：[1, 2] —— 容器被共享，后续调用受到了影响

解释

根本原因：默认参数的绑定时机
Python 的默认参数值 会在函数定义时一次性创建并绑定，而不是每次调用函数时重新创建。 对于可变对象（如列表、字典等），这意味着所有未显式提供该参数的调用都会共享同一个默认对象。

代码示例中的关键点：
```
def add_item(item, container=[]):  # 这里的 [] 在函数定义时被创建 
```
这个空列表 [] 会作为 container 参数的默认值被永久绑定到函数对象上。

内存层面的表现

首次调用 add_item(1)：
- 使用默认列表（内存地址假设为 0x1000）
- 列表变为 [1]
第二次调用 add_item(2)：
- 继续使用同一个内存地址 0x1000 的列表
- 列表变为 [1, 2]

所有未显式传递 container 参数的调用都会持续修改这个默认列表。

Python 官方的设计逻辑
这种设计是为了优化性能：

避免每次调用函数时都创建新对象
对不可变对象（如整数、字符串）无害，但会引发可变对象的状态保留问题

解决方案（标准实践）
使用 None 作为哨兵值，在函数内部动态创建容器：

def add_item(item, container=None):
    if container is None:
        container = []  # 每次调用时创建新列表 
    container.append(item)
    return container

简短的介绍一下哨兵值：
哨兵值存在的意义是为了防止函数、方法或逻辑流程中出现意料之外的行为或潜在的 bug，或者解决某些情况下需要区分普通值与特殊情况的需求。它提供了一个简单有效的标识机制和行为控制工具。

上面的例子就是：通过引入哨兵值 None，我们能区分出“用户未提供参数”的情况，显式地执行逻辑，避免了潜在的可变对象共享问题。

验证实验
可以通过检查对象 ID 确认：

print(id(add_item(1)))  # 输出默认列表的内存地址 
print(id(add_item(2)))  # 输出相同的内存地址

通过这个机制可以理解为什么 Django 等框架中常看到 default=dict 被替换为 default=lambda: {} 的写法。因为使用default=lambda: {}替代default=dict是为了规避默认值共享问题，确保每个模型实例获得独立的字典对象。

对于数据类，如果为字段直接提供可变默认值，也会引发类似问题。

例如：

from dataclasses import dataclass

@dataclass
class ClubMember:
    name: str
    guests: list = []  # 不安全：所有实例将共享这一个列表

运行时，会报错：

ValueError: mutable default <class 'list'> for field guests is not allowed: use default_factory

2. 解决方案：使用 `default_factory`

通过 dataclasses.field() 的 default_factory 参数，可以生成每个实例一个独立的可变默认值。

改进后的代码：

from dataclasses import dataclass, field

@dataclass
class ClubMember:
    name: str
    guests: list = field(default_factory=list)  # 使用工厂函数生成独立的列表

详解：

field(default_factory=list) 中，list 是一个无参调用的工厂函数，每次创建实例时生成一个新的空列表。
这样可以避免实例间的默认值共享问题。

3. 示例对比

错误用法：

@dataclass
class ClubMember:
    name: str
    guests: list = []  # 共享同一个列表

正确用法：

@dataclass
class ClubMember:
    name: str
    guests: list = field(default_factory=list)  # 每个实例都有独立的列表

验证：

member1 = ClubMember('Alice')
member2 = ClubMember('Bob')

member1.guests.append('John')  # 添加到 member1 的 guests 列表
print(member1.guests)  # 输出：['John']
print(member2.guests)  # 输出：[] —— 不受影响

三、字段选项总结

dataclasses.field() 提供了丰富的选项来控制字段行为，以下是常用选项及其含义：

选项	含义	默认值
`default`	为字段指定默认值，仅用于不可变类型，例如 `default=0`	`_MISSING_TYPE`
`default_factory`	一个无参工厂函数，用于生成每次实例化的默认值（适用于可变类型，如 `list`、`dict` 等）	`_MISSING_TYPE`
`init`	是否在 `__init__` 方法中包含此字段	`True`
`repr`	是否在 `__repr__` 方法中包含此字段	`True`
`compare`	是否在比较方法（如 `__eq__`, `__lt__` 等）中包含此字段	`True`
`hash`	是否在 `__hash__` 方法中包含此字段，如果 `compare=True` 则默认为包含	`None`
`metadata`	自定义元数据，供开发者使用（不会被 `@dataclass` 直接处理）	`None`

四、字段类型注解：泛型和强类型支持

1. 泛型类型注解

Python 3.9 起，内置集合类型（如 list, dict 等）支持泛型类型注解，通过方括号 [] 指定元素类型。例如：

guests: list[str] = field(default_factory=list)  # 指定这是一个字符串列表

等价于以下 Python 3.8 及更早版本的表达：

from typing import List

guests: List[str] = field(default_factory=list)  # 使用 typing 模块

2. 强类型的好处

使用泛型类型注解有助于增强代码的可读性，并提供类型检查支持（如 mypy），能有效捕获类型相关的错误。例如：

member = ClubMember('Alice')
member.guests.append(123)  # 静态类型检查工具将提示错误：123 不是 str 类型

五、更多例子

例子 1：多字段组合

@dataclass
class ClubMember:
    name: str
    is_athlete: bool = field(default=False, repr=False)  # 不显示在 repr 输出中
    guests: list[str] = field(default_factory=list)

member = ClubMember(name='Alice')
print(member)  # 输出：ClubMember(name='Alice', guests=[])

例子 2：自定义元数据

@dataclass
class Example:
    field_with_meta: int = field(default=10, metadata={'unit': 'seconds'})

# 提取字段的元数据
from dataclasses import fields
field_meta = fields(Example)[0].metadata
print(field_meta['unit'])  # 输出：seconds

六、学习重点与注意事项

避免直接使用可变对象作为默认值：始终使用 default_factory，为每个实例生成独立的默认值。
了解字段选项的用途：
- default 和 default_factory 二选一，不可同时使用。
- 通过 init=False 可以排除字段不参与 __init__ 方法。
熟悉类型注解的改进（如泛型支持）：更强的类型约束有助于代码的静态检查和质量保障。
复习元数据的应用场景：虽然在大多数情况下不常用，但在某些特定领域可以提供额外的信息支持。

Post-init Processing

一、`__post_init__` 方法的背景知识

当使用@dataclass装饰器生成数据类时，Python会自动生成__init__方法。若用户定义__post_init__方法，它会在__init__完成基础属性赋值后自动调用。

1. 数据类的默认初始化行为

当你在数据类中定义属性时，@dataclass 会自动生成一个 __init__ 方法，负责将传入实例的参数分配给对应的字段。如果字段有默认值或使用了 default_factory，那么在调用 __init__ 时也会正确初始化这些字段。

2. 初始化可能遇到的需求

有时，简单的字段赋值不足以满足初始化需求。以下是一些常见场景：

字段值的验证：确保字段符合指定的要求（如唯一、非空）。
字段间的依赖计算：某些字段的值需要根据其他字段来确定。
复杂逻辑的初始化：需要额外的业务逻辑对数据进行处理。

3. `__post_init__` 方法的作用

为了满足这些需求，@dataclass 提供了 __post_init__ 方法。

功能：如果数据类中定义了 __post_init__，@dataclass 会在生成的 __init__ 方法中自动调用 __post_init__，并在所有字段初始化完成后执行。
用途：常用于数据验证、依赖计算和其他初始化逻辑。

二、`__post_init__` 的用法

通过一个例子来引入 __post_init__ 的用法。

基类 `ClubMember`

from dataclasses import dataclass, field

@dataclass
class ClubMember:
    name: str
    guests: list = field(default_factory=list)  # 每个实例有独立的列表

子类 `HackerClubMember`

@dataclass
class HackerClubMember(ClubMember):
    all_handles = set()  # 类属性，用于存储所有 handle
    handle: str = ''      # 实例属性，默认为空字符串

    def __post_init__(self):
        cls = self.__class__  # 获取类对象
        if self.handle == '':  # 如果 handle 为空，自动生成
            self.handle = self.name.split()[0]  # 使用名字中第一个单词作为 handle
        if self.handle in cls.all_handles:  # 检查 handle 是否唯一
            raise ValueError(f'handle {self.handle!r} already exists.')
        cls.all_handles.add(self.handle)  # 将 handle 添加到类属性中

为什么XX是类属性，YY就是实例属性

在Python中，@dataclass装饰器提供了一种简洁的方式来定义类，同时简化了常见方法的实现。然而，在@dataclass中定义类属性和实例属性的方式与普通类有所不同。以下是两者的详细对比：

定义方式

普通类

类属性：直接在类作用域内赋值。

class MyClass:
    class_attr = "我是类属性"  # 类属性

实例属性：通常在__init__方法中定义。

class MyClass:
    def __init__(self):
        self.instance_attr = "我是实例属性"  # 实例属性

@dataclass类

类属性：直接在类作用域内赋值，且没有类型注解。

from dataclasses import dataclass

@dataclass
class MyDataClass:
    class_attr = "我是类属性"  # 类属性（无类型注解）

实例属性：必须使用类型注解。

@dataclass
class MyDataClass:
    instance_attr: str = "我是实例属性"  # 实例属性（有类型注解）

处理方式

普通类

类属性和实例属性都可以自由定义。
没有自动化处理（如自动生成__init__方法），需要手动编写。

@dataclass类

类属性：会被@dataclass忽略，不参与实例初始化。
实例属性：会被@dataclass自动处理，生成相应的__init__方法。

使用ClassVar可以显式声明类属性。

from typing import ClassVar

@dataclass
class MyDataClass:
    class_attr: ClassVar[int] = 0  # 类属性（有类型注解）

存储位置

普通类与@dataclass类一样

类属性：存储在类的__dict__中。
实例属性：存储在实例的__dict__中。

行为对比

普通类与@dataclass类一样

修改实例的实例属性不会影响其他实例。
修改类的类属性会影响所有实例。

示例对比

普通类

class MyClass:
    class_attr = "我是类属性"

    def __init__(self):
        self.instance_attr = "我是实例属性"

obj1 = MyClass()
obj2 = MyClass()

obj1.instance_attr = "修改后的实例属性"
MyClass.class_attr = "修改后的类属性"

print(obj1.instance_attr)       # 输出: "修改后的实例属性"
print(obj2.instance_attr)       # 输出: "我是实例属性"
print(obj1.class_attr)          # 输出: "修改后的类属性"
print(obj2.class_attr)          # 输出: "修改后的类属性"

@dataclass类

from dataclasses import dataclass

@dataclass
class MyDataClass:
    class_attr = "我是类属性"
    instance_attr: str = "我是实例属性"

obj1 = MyDataClass()
obj2 = MyDataClass()

obj1.instance_attr = "修改后的实例属性"
MyDataClass.class_attr = "修改后的类属性"

print(obj1.instance_attr)       # 输出: "修改后的实例属性"
print(obj2.instance_attr)       # 输出: "我是实例属性"
print(obj1.class_attr)          # 输出: "修改后的类属性"
print(obj2.class_attr)          # 输出: "修改后的类属性"

注意事项

普通类

需要手动管理__init__方法。
没有自动化处理。

@dataclass类

需要注意类型注解的使用。
默认值为可变对象时，需使用field(default_factory=...)避免共享问题。

总结

特性	普通类	`@dataclass`类
定义方式	类属性：直接赋值实例属性：`__init__`	类属性：直接赋值（无类型注解）实例属性：类型注解
处理方式	手动管理	自动化处理（生成`__init__`等）
存储位置	类：`__dict__` 实例：`__dict__`	类：`__dict__` 实例：`__dict__`
行为	类属性共享实例属性独立	类属性共享实例属性独立
默认值处理	需手动处理	使用`field(default_factory=...)`

深入解析：为什么通过实例修改“类属性”不会影响其他实例（上面的例子）

为了彻底理解这一现象，我们需要从 Python 的对象模型和属性查找机制的底层原理出发，结合命名空间字典和动态赋值的特性进行详细分析。

Python 的对象模型：命名空间字典

在 Python 中，类和实例都是对象，它们的属性存储在各自的命名空间字典（__dict__）中：

类的命名空间：存储在类的 __dict__ 中，包含类的所有类属性。
实例的命名空间：存储在实例的 __dict__ 中，包含实例的所有实例属性。

示例代码

class MyClass:
    class_attr = "我是类属性"
 
    def __init__(self):
        self.instance_attr = "我是实例属性"
 
obj1 = MyClass()
obj2 = MyClass()

命名空间内容

类的 __dict__：

{'__module__': '__main__', 'class_attr': '我是类属性', '__init__': <function MyClass.__init__ at 0x102b02790>, '__dict__': <attribute '__dict__' of 'MyClass' objects>, '__weakref__': <attribute '__weakref__' of 'MyClass' objects>, '__doc__': None}

实例 obj1 的 __dict__：

{'instance_attr': '我是实例属性'}

实例 obj2 的 __dict__：

{'instance_attr': '我是实例属性'}

属性查找机制

当通过实例访问一个属性时（例如 obj1.class_attr），Python 会按照以下顺序查找：

实例的 __dict__：首先在实例的命名空间中查找。
类的 __dict__：如果在实例中未找到，则在类的命名空间中查找。
父类的 __dict__：如果仍未找到，则继续向上查找父类的命名空间。
描述符协议：如果上述步骤均未找到，则尝试使用描述符协议（如 @property）。

示例分析

print(obj1.class_attr)  # 输出：我是类属性

Python 首先检查 obj1.__dict__，发现没有 class_attr。
然后检查 MyClass.__dict__，找到 class_attr 并返回其值。

赋值操作的底层机制

当通过实例对一个属性进行赋值时（例如 obj1.class_attr = "修改后的类属性"），Python 的行为如下：

检查实例的 __dict__：
- 如果实例的 __dict__ 中存在该属性，则直接更新其值。
- 如果实例的 __dict__ 中不存在该属性，则在实例的 __dict__ 中创建一个新条目。
不会修改类的 __dict__：
- 赋值操作仅影响实例的命名空间，不会触碰类的命名空间。

示例代码

class MyClass:
    class_attr = "我是类属性"

    def __init__(self):
        self.instance_attr = "我是实例属性"


obj1 = MyClass()
obj2 = MyClass()

print(obj1.class_attr)
print(MyClass.__dict__)
print(obj1.__dict__)

obj1.class_attr = "修改后的类属性"
print(MyClass.__dict__)
print(obj1.__dict__)

# 我是类属性
# {'__module__': '__main__', 'class_attr': '我是类属性', '__init__': <function MyClass.__init__ at 0x102d6a790>, '__dict__': <attribute '__dict__' of 'MyClass' objects>, '__weakref__': <attribute '__weakref__' of 'MyClass' objects>, '__doc__': None}
# {'instance_attr': '我是实例属性'}
# {'__module__': '__main__', 'class_attr': '我是类属性', '__init__': <function MyClass.__init__ at 0x102d6a790>, '__dict__': <attribute '__dict__' of 'MyClass' objects>, '__weakref__': <attribute '__weakref__' of 'MyClass' objects>, '__doc__': None}
# {'instance_attr': '我是实例属性', 'class_attr': '修改后的类属性'}

结果

obj1.class_attr 现在指向实例自己的 class_attr。
obj2.class_attr 和 MyClass.class_attr 仍然指向原始值。

动态赋值的影响

Python 的动态语言特性允许在运行时动态添加或修改属性。这种灵活性带来了极大的便利，但也需要注意潜在的副作用：

如果通过实例动态添加了一个与类属性同名的属性，这个实例属性会“遮蔽”类属性。
其他实例仍然通过类的 __dict__ 访问原始的类属性。

示例代码

print(obj1.class_attr)  # 输出：修改后的类属性（实例属性）
print(obj2.class_attr)  # 输出：我是类属性（类属性）
print(MyClass.class_attr)  # 输出：我是类属性（类属性）

分析

obj1.class_attr 现在是实例属性。
obj2.class_attr 和 MyClass.class_attr 仍然是原始的类属性。

如何真正修改类属性

如果需要通过实例修改类属性，则需要显式地通过类名或描述符协议进行操作：

通过类名修改：

MyClass.class_attr = "修改后的类属性"

通过描述符协议：
如果需要通过实例修改类属性，可以使用描述符协议（如 @classmethod 或自定义描述符）。

示例代码

方法 1：通过类名直接修改 
MyClass.class_attr = "修改后的类属性"
 
方法 2：通过描述符协议（示例）
class MyClass:
    _class_attr = "我是类属性"
 
    @classmethod 
    def set_class_attr(cls, value):
        cls._class_attr = value 
 
obj1 = MyClass()
obj1.set_class_attr("修改后的类属性")

总结

通过上述分析可以看出：

类和实例分别拥有独立的命名空间（__dict__）。
属性查找顺序决定了通过实例访问类属性的行为。
赋值操作默认只影响实例的命名空间。
如果需要通过实例修改类属性，则需要显式地通过类名或描述符协议进行操作。

三、具体例子的分析与验证

1. 初始阶段的需求

过程：

创建 HackerClubMember 实例。
如果未传递 handle，自动从 name 生成默认值。
确保 handle 唯一，否则抛出错误。

示例验证：

# 创建带 handle 参数的实例
anna = HackerClubMember('Anna Ravenscroft', handle='AnnaRaven')
print(anna)  
# 输出：HackerClubMember(name='Anna Ravenscroft', guests=[], handle='AnnaRaven')

# 创建不带 handle 的实例，会根据名字生成默认 handle
leo = HackerClubMember('Leo Rochael')
print(leo)
# 输出：HackerClubMember(name='Leo Rochael', guests=[], handle='Leo')

# handle 不唯一，尝试创建时抛出错误
try:
    leo2 = HackerClubMember('Leo DaVinci')
except ValueError as e:
    print(e)
# 输出：handle 'Leo' already exists.

# 强制指定唯一 handle
leo2 = HackerClubMember('Leo DaVinci', handle='Neo')
print(leo2)
# 输出：HackerClubMember(name='Leo DaVinci', guests=[], handle='Neo')

四、深入剖析代码逻辑

`__post_init__` 的详细操作步骤

获取类的引用：cls = self.__class__。
- 允许对类属性（如 all_handles）进行操作。
- 这个cls有点迷惑性，就是个普通变量哈。

@dataclass
class HackerClubMember(ClubMember):
    all_handles = set() # 类属性，用于存储所有 handle
    handle: str = '' # 实例属性，默认为空字符串

    def __post_init__(self):
        a = self.__class__ # 获取类对象 <class '__main__.HackerClubMember'>
        if self.handle == '': # 如果 handle 为空，自动生成
            self.handle = self.name.split()[0] # 使用名字中第一个单词作为 handle
        if self.handle in a.all_handles: # 检查 handle 是否唯一
            raise ValueError(f'handle {self.handle!r} already exists.')
        a.all_handles.add(self.handle) # 将 handle 添加到类属性中

member1 = HackerClubMember("Alice Wonderland")
print(member1.handle)   # 输出: Alice

try:
    member2 = HackerClubMember("Alice Smith")  # 尝试创建同名handle
except ValueError as e:
    print(e)  # 输出: handle 'Alice' already exists.

生成默认值：self.handle = self.name.split()[0]。
- 如果调用时未提供 handle，则以 name 中的第一个单词作为默认值。
进行校验：if self.handle in cls.all_handles。
- 若 handle 已存在，则抛出 ValueError 表明冲突。
添加新值到类属性：cls.all_handles.add(self.handle)。
- 将当前实例的 handle 添加到所有已存在的 handle 集合中，确保唯一性。

五、潜在难点与注意事项

1. 类属性 vs 实例属性

HackerClubMember.all_handles 是一个类属性，它用于存储所有实例的 handle。类属性对于所有类实例是共享的。

2. 默认值处理

定义为 handle: str = '' 是一种常见的方式，表示该字段有默认值（空字符串），并且是可选的。
注意：handle 默认值为空字符串，不能直接用于唯一校验。因此在 __post_init__ 中需要调整逻辑。

3. 继承中的字段顺序

子类中的字段和父类中的字段会合并在一起，最终由 @dataclass 分配顺序。
若需要指定子类字段的行为（如默认值），建议检查字段的重载顺序对 __init__ 的影响。

4. 静态类型检查

上述代码未明确指定 all_handles 的类型，可能会引发静态类型检查警告。可以改为：

class HackerClubMember(ClubMember):
    all_handles: set[str] = set()  # 显式声明类型

六、补充例子：`__post_init__` 的更多应用

1. 依赖计算场景

假设需要根据多个字段的值生成额外的字段：

@dataclass
class Rectangle:
    width: float
    height: float
    area: float = 0  # area 需要依赖其他字段计算

    def __post_init__(self):
        self.area = self.width * self.height  # 自动计算面积

rect = Rectangle(3, 4)
print(rect)  # 输出：Rectangle(width=3, height=4, area=12)

2. 数据验证场景

在初始化时确保字段符合某些约束条件：

@dataclass
class Person:
    name: str
    age: int

    def __post_init__(self):
        if self.age < 0:
            raise ValueError("Age cannot be negative")

# 验证
john = Person("John", 30)    # 正常
invalid = Person("Invalid", -5)  # 抛出：ValueError: Age cannot be negative

七、总结

背景知识：
- 数据类自动生成的 __init__ 方法仅赋值字段。如果需要初始化更多逻辑（如验证和依赖计算），可以使用 __post_init__。
__post_init__ 的用途：
- 字段间依赖计算。
- 数据验证。
- 自定义初始化逻辑。
重点知识点：
- __post_init__ 在 __init__ 完成后自动调用。
- 类属性（如 all_handles）在所有实例间共享，适合用作全局存储。
- 注意字段定义与初始化顺序，避免冲突。

Typed Class Attributes

问题背景
当你在使用 @dataclass 装饰器时，可能会遇到类型检查工具（如 Mypy）提示需要为某些类变量添加类型注解。然而，直接为类变量添加类型注解可能会导致 @dataclass 将其误认为是实例属性，而不是类变量。
问题分析
假设我们有以下代码：

from dataclasses import dataclass

@dataclass
class Example:
    all_handles = set()

运行 Mypy 时会得到以下错误：

error: Need type annotation for "all_handles"
(hint: "all_handles: Set[<type>] = ...")

根据 Mypy 的提示，我们可能会尝试添加类型注解：

all_handles: set[str] = set()

然而，这样做会导致 @dataclass 将 all_handles 视为实例属性，而不是类变量。

解决方案：使用 ClassVar
为了同时满足类型检查工具和 @dataclass 的要求，我们需要使用 typing.ClassVar。ClassVar 是一个伪类型，用于明确表示某个变量是类级别的变量，而不是实例级别的变量。

示例代码

from dataclasses import dataclass
from typing import ClassVar

@dataclass
class Example:
    all_handles: ClassVar[set[str]] = set()

解释

ClassVar[set[str]] 告诉类型检查工具 all_handles 是一个类级别的变量，类型为 set[str]。
@dataclass 会识别 ClassVar 并知道不为该变量生成实例属性。

关键点总结

ClassVar 的作用：明确变量是类级别的，防止 @dataclass 生成实例属性。
类型注解格式：VariableName: ClassVar[Type] = DefaultValue
导入需求：需要从 typing 模块导入 ClassVar。

常见问题与解答

Q：为什么不能直接使用 set[str] 而不使用 ClassVar？
- A：因为 @dataclass 会将任何带有类型注解的变量视为实例属性。使用 ClassVar 可以明确告诉 @dataclass 这是一个类变量。
Q：如果不使用 ClassVar 会有什么后果？
- A：@dataclass 会为该变量生成实例属性，导致类变量变成实例变量，这通常不是预期行为。

实战演练
假设我们有一个类 Config，其中有一个类变量 default_settings，我们需要对其进行类型注解：

from dataclasses import dataclass
from typing import ClassVar, Dict

@dataclass
class Config:
    default_settings: ClassVar[Dict[str, int]] = {'theme': 0, 'volume': 50}

这样，default_settings 就会被正确识别为一个类级别的字典变量。

Initialization Variables That Are Not Fields

背景知识
在 Python 的 @dataclass 装饰器中，默认情况下所有传递给 __init__ 方法的参数都会成为实例字段（即对象的属性）。但在某些情况下，我们可能需要传递一些参数用于初始化过程，但不需要将它们保存为实例字段。这些参数被称为初始化仅变量（init-only variables）。

核心概念

什么是 InitVar？
- InitVar 是 typing 模块中的一个伪类型（pseudotype），用于声明初始化仅变量。
- 它告诉 @dataclass 不要将该参数作为实例字段处理。
- 使用 InitVar 声明的变量不会出现在生成的 __init__ 方法的参数列表中（除了 __init__ 本身接受它），也不会出现在 dataclasses.fields() 的结果中。
为什么要使用 InitVar？
- 当我们需要在初始化过程中使用某个变量（例如从数据库获取数据），但不需要将其保存为对象属性时。
- 例如：从数据库查询初始值、从配置文件读取参数等。
如何使用 InitVar？
- 在类属性中使用 InitVar 声明变量。
- 在 __post_init__ 方法中使用该变量（如果需要）。
- 注意：__post_init__ 方法必须显式地接受该参数。

示例分析
示例 5-18 解释

from dataclasses import dataclass, InitVar
from typing import Any  # 假设 DatabaseType 是自定义类型

@dataclass
class C:
    i: int
    j: int = None
    database: InitVar[Any] = None  # 初始化仅变量

    def __post_init__(self, database):
        if self.j is None and database is not None:
            self.j = database.lookup('j')

c = C(10, database=my_database)

关键点解释：
- database 是一个初始化仅变量，不会成为 C 实例的属性。
- __post_init__ 方法接收 database 参数，并在其中使用它来设置 j 的值。
- 创建实例时可以通过关键字参数传递 database。

但是这个例子本身是有点问题感觉。。。
请看下文：

补充示例：从配置文件读取初始值

案例 1：

@dataclass
class SettingsWithInitVar:
    host: str
    port: int
    config: InitVar[Dict] = None  # 初始化仅变量

    def __post_init__(self, config):
        if config is not None:
            self.host = config.get('host', self.host)
            self.port = config.get('port', self.port)


# 创建实例
settings = SettingsWithInitVar('localhost', 8000, config={'host': '127.0.0.1', 'port': 8080})

# 查看实例的属性
print(settings.__dict__)
print(SettingsWithInitVar.__dict__)
print(hasattr(settings, 'config'))


# {'host': '127.0.0.1', 'port': 8080}
# {'__module__': '__main__', '__annotations__': {'host': <class 'str'>, 'port': <class 'int'>, 'config': dataclasses.InitVar[typing.Dict]}, 'config': None, '__post_init__': <function SettingsWithInitVar.__post_init__ at 0x1044f4e50>, '__dict__': <attribute '__dict__' of 'SettingsWithInitVar' objects>, '__weakref__': <attribute '__weakref__' of 'SettingsWithInitVar' objects>, '__doc__': 'SettingsWithInitVar(host: str, port: int, config: dataclasses.InitVar[typing.Dict] = None)', '__dataclass_params__': _DataclassParams(init=True,repr=True,eq=True,order=False,unsafe_hash=False,frozen=False), '__dataclass_fields__': {'host': Field(name='host',type=<class 'str'>,default=<dataclasses._MISSING_TYPE object at 0x1043259a0>,default_factory=<dataclasses._MISSING_TYPE object at 0x1043259a0>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),_field_type=_FIELD), 'port': Field(name='port',type=<class 'int'>,default=<dataclasses._MISSING_TYPE object at 0x1043259a0>,default_factory=<dataclasses._MISSING_TYPE object at 0x1043259a0>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),_field_type=_FIELD), 'config': Field(name='config',type=dataclasses.InitVar[typing.Dict],default=None,default_factory=<dataclasses._MISSING_TYPE object at 0x1043259a0>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),_field_type=_FIELD_INITVAR)}, '__init__': <function __create_fn__.<locals>.__init__ at 0x1045319d0>, '__repr__': <function __create_fn__.<locals>.__repr__ at 0x104529940>, '__eq__': <function __create_fn__.<locals>.__eq__ at 0x104531a60>, '__hash__': None}
# True

诶，等下，怎么输出的是True???

在Python的数据类（dataclass）中使用 InitVar 时，默认值的存在会影响 hasattr() 的结果。

核心原因

默认值的影响：
- 当 InitVar 字段设置了一个默认值（如 None），这个字段会在 类级别 上创建一个变量。
- 因此，在检查 hasattr(instance, 'field_name') 时会返回 True，因为该字段存在于类级别上。
无默认值的情况：
- 如果 InitVar 字段没有设置默认值，则该字段不会成为类级别的变量。
- 此时 hasattr(instance, 'field_name') 返回 False。

示例分析

第一个示例（带默认值）

就是上面的例子

原因：由于 config: InitVar[Dict] = None 设置了默认值 None，类 SettingsWithInitVar 在其自身（类级别）上有了一个名为 config 的变量。
结果：调用 hasattr(settings, 'config') 检查到类级别上有 config 变量，因此返回 True.

第二个示例（无默认值）

rom dataclasses import dataclass, InitVar
from typing import Dict


@dataclass
class SettingsWithInitVar:
    host: str
    port: int
    config: InitVar[Dict]  # 初始化仅变量

    def __post_init__(self, config):
        if config is not None:
            self.host = config.get('host', self.host)
            self.port = config.get('port', self.port)


# 创建实例
settings = SettingsWithInitVar('localhost', 8000, config={'host': '127.0.0.1', 'port': 8080})

# 查看实例的属性
print(settings.__dict__)
print(SettingsWithInitVar.__dict__)
print(hasattr(settings, 'config'))


# {'host': '127.0.0.1', 'port': 8080}
# {'__module__': '__main__', '__annotations__': {'host': <class 'str'>, 'port': <class 'int'>, 'config': dataclasses.InitVar[typing.Dict]}, '__post_init__': <function SettingsWithInitVar.__post_init__ at 0x102778e50>, '__dict__': <attribute '__dict__' of 'SettingsWithInitVar' objects>, '__weakref__': <attribute '__weakref__' of 'SettingsWithInitVar' objects>, '__doc__': 'SettingsWithInitVar(host: str, port: int, config: dataclasses.InitVar[typing.Dict])', '__dataclass_params__': _DataclassParams(init=True,repr=True,eq=True,order=False,unsafe_hash=False,frozen=False), '__dataclass_fields__': {'host': Field(name='host',type=<class 'str'>,default=<dataclasses._MISSING_TYPE object at 0x1025a99a0>,default_factory=<dataclasses._MISSING_TYPE object at 0x1025a99a0>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),_field_type=_FIELD), 'port': Field(name='port',type=<class 'int'>,default=<dataclasses._MISSING_TYPE object at 0x1025a99a0>,default_factory=<dataclasses._MISSING_TYPE object at 0x1025a99a0>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),_field_type=_FIELD), 'config': Field(name='config',type=dataclasses.InitVar[typing.Dict],default=<dataclasses._MISSING_TYPE object at 0x1025a99a0>,default_factory=<dataclasses._MISSING_TYPE object at 0x1025a99a0>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),_field_type=_FIELD_INITVAR)}, '__init__': <function __create_fn__.<locals>.__init__ at 0x1027b5a60>, '__repr__': <function __create_fn__.<locals>.__repr__ at 0x1027ae940>, '__eq__': <function __create_fn__.<locals>.__eq__ at 0x1027b59d0>, '__hash__': None}
# False

原因：未设置默认值意味着 config 不会在类级别上创建变量。
结果：调用 hasattr(settings, 'config') 无法找到该变量（既不在实例也不在类级别），因此返回 False.

解决方案

为了确保 InitVar 字段不干扰 hasattr() 的检查，并遵循最佳实践：

避免为 InitVar 设置默认值：
- 如果必须提供默认行为，请在 __post_init__() 方法内处理逻辑。
明确区分初始化和持久化字段：
- 使用普通字段来存储需要持久化的数据。
- 使用 InitVar 来处理仅用于初始化阶段的参数。

案例2：工程例子

from dataclasses import dataclass, InitVar, field


@dataclass
class DatabaseService:
    # 初始化参数（仅用于构建过程）
    config_name: InitVar[str]

    # 持久化字段
    connection: str = field(init=False, default="未连接")
    is_connected: bool = field(init=False, default=False)

    def __post_init__(self, config_name):
        """模拟配置加载与连接过程"""
        print(f"📡 正在加载 [{config_name}] 配置...")

        # 模拟配置映射
        if config_name == "dev":
            self.connection = "开发环境连接(127.0.0.1)"
            self.is_connected = True
        elif config_name == "prod":
            self.connection = "生产环境连接(db.prod.com)"
            self.is_connected = True
        else:
            self.connection = f"错误配置: {config_name}"
            self.is_connected = False

        print(f"🔌 连接状态: {self.connection}")

    # --------------- 使用演示 ---------------


if __name__ == "__main__":
    print("\n=== 开发环境用例 ===")
    DatabaseService("dev")  # 输出带状态提示的初始化过程

    print("\n=== 生产环境用例 ===")
    DatabaseService("prod")

    print("\n=== 错误配置用例 ===")
    DatabaseService("test")

@dataclass Example: Dublin Core Resource Record

1. Dublin Core 与示例背景

Dublin Core 是一个广泛使用的元数据标准，用于描述各种资源，如数字内容（视频、图片、网页）及实体资源（书籍、光盘等）。标准定义了 15 个可选字段，用以结构化地表示资源的描述信息。

在原文的示例中，我们使用 @dataclass 定义了一个 Resource 类，来表示一类基于 Dublin Core 的资源记录。

2. 代码解析及关键点

以下是原文中带有注释的 Resource 类代码：

from dataclasses import dataclass, field
from typing import Optional
from enum import Enum, auto
from datetime import date


# 定义枚举类型，用于资源的分类
class ResourceType(Enum):
	# 用于自动为枚举成员分配值。auto() 会从 1 开始为每个枚举成员分配一个唯一的整数值（在这个例子中），如果没有指定值，auto() 会依次递增。
    BOOK = auto()
    EBOOK = auto()
    VIDEO = auto()


# 使用 @dataclass 定义 Resource 类
@dataclass
class Resource:
    """媒体资源描述"""
    identifier: str  # 唯一标识符（必填字段）
    title: str = '<untitled>'  # 标题，默认值为 '<untitled>'
    creators: list[str] = field(default_factory=list)  # 作者列表，默认为空列表
    date: Optional[date] = None  # 日期，可选字段，默认值为 None
    type: ResourceType = ResourceType.BOOK  # 类型，默认为 ResourceType.BOOK
    description: str = ''  # 描述，默认为空字符串
    language: str = ''  # 语言，默认为空字符串
    subjects: list[str] = field(default_factory=list)  # 主题关键词，默认为空列表

字段解析

identifier: str
- 唯一标识符，属于必填字段。
- 没有默认值，因此创建对象时必须传递此参数。
title: str
- 标题字段，设有默认值 <untitled>。
- 有默认值的字段必须排在无默认值的字段之后，遵循 PEP 8 的规则。
creators: list[str]
- 作者列表，支持多个作者。
- 使用 field(default_factory=list) 设置默认空列表，避免共享对象引用问题（常见坑，详见补充示例1）。
date: Optional[date]
- 表示资源的创建日期，使用 Optional 指定可以为 None。
- 默认值为 None，支持省略字段时无错误。
type: ResourceType
- 资源类型字段，枚举类型，默认为 ResourceType.BOOK。
- 使用枚举（Enum）可提高代码的可读性和安全性。
description, language, subjects
- 这些字段均有默认值（空字符串或空列表），用于描述资源的其他信息。

3. 创建对象与输出

以下演示如何实例化 Resource 对象，并查看其默认的字符串表示效果。

from datetime import date

# 示例：创建资源对象
description = "Improving the design of existing code"
book = Resource(
    identifier='978-0-13-475759-9',
    title='Refactoring, 2nd Edition',
    creators=['Martin Fowler', 'Kent Beck'],
    date=date(2018, 11, 19),
    type=ResourceType.BOOK,
    description=description,
    language='EN',
    subjects=['computer programming', 'OOP']
)

# 打印对象
print(book)

输出结果：

Resource(identifier='978-0-13-475759-9', title='Refactoring, 2nd Edition',
creators=['Martin Fowler', 'Kent Beck'], date=datetime.date(2018, 11, 19),
type=<ResourceType.BOOK: 1>, description='Improving the design of existing code',
language='EN', subjects=['computer programming', 'OOP'])

4. 自定义 `repr` 输出（更具可读性）

默认的 repr 表示效果较为紧凑，但当字段多时可能会不方便阅读。以下代码定义自定义的 __repr__ 方法，优化输出格式：

from dataclasses import fields

def __repr__(self):
    cls = self.__class__  # 获取类
    cls_name = cls.__name__  # 获取类名
    indent = ' ' * 4  # 缩进
    res = [f'{cls_name}(']  # 输出的起始部分

    # 遍历所有字段
    for f in fields(cls):
        value = getattr(self, f.name)  # 获取字段值
        res.append(f'{indent}{f.name} = {value!r},')  # 添加字段名和值

    res.append(')')  # 结尾部分
    return '\n'.join(res)  # 构造换行的字符串

让 Resource 使用自定义 __repr__，输出如下格式：

Resource(
    identifier = '978-0-13-475759-9',
    title = 'Refactoring, 2nd Edition',
    creators = ['Martin Fowler', 'Kent Beck'],
    date = datetime.date(2018, 11, 19),
    type = <ResourceType.BOOK: 1>,
    description = 'Improving the design of existing code',
    language = 'EN',
    subjects = ['computer programming', 'OOP'],
)

5. 重要注意事项与补充示例

1) `field(default_factory=...)` 的安全使用

如果字段的默认值是可变对象（如列表或字典），推荐使用 field(default_factory=...)，以避免多个实例共享同一个默认对象的问题。例如：

@dataclass
class Example:
    data: list[int] = field(default_factory=list)  # 正确用法

a = Example()
b = Example()
a.data.append(1)

# 两个实例不共享同一个列表
print(a.data)  # [1]
print(b.data)  # []

2) 使用枚举的好处

用枚举表示资源类型，比直接用字符串更安全，避免了拼写错误，代码更清晰：

# 错误示例（字符串容易拼写错）
book = Resource(identifier="1", type="bookk")  # 无法在程序中校验此错误

# 正确示例（枚举类型强制约束）
book = Resource(identifier="1", type=ResourceType.BOOK)

7、Data Class as a Code Smell

什么是 Data Class？

Data Class，顾名思义，是一种主要保存数据的类。这类类的主要特征是：
- 它们通常有字段（fields，用于存储数据）。
- 它们拥有访问字段的 getters 和 setters 等方法。
- 它们 缺少行为（逻辑功能，如对自身数据的操作方法）。
行为和数据分离 的设计导致这些类显得很“无能”（anemic，贫血的）。

什么是 Code Smell？

Code Smell（代码异味） 是指在代码中存在的一种浅表现象，可能暗示代码设计存在更深层次的问题。
- 举例：如果看到一个方法过长，或者看到没有行为的数据类时，这些可能是在提醒你代码设计不够优雅，需要重构。
- 注意：Code Smell 本身并不一定是错误，但它是一种提示，鼓励你去检查代码以找到潜在问题。

为什么 Data Class 是一种 Code Smell？

数据类的问题：
- 数据类（只有字段、getter 和 setter）不包含行为。这意味着使用它的数据操作逻辑会散落在其他类或函数中。
- 这种分布式的逻辑设计会导致：
  - 代码维护困难：逻辑分散，可能重复，难以调试。
  - 整体设计违背了**面向对象编程（OOP）**的思想，即行为和数据应结合在类中，而非分离处理。

如何处理 Data Class 的 Code Smell？
Martin Fowler 关于解决 Data Class 的建议是：

把行为加回类中：
- 考虑与类相关的所有行为，逐步将这些行为迁移到该类中。
- 类的实例操作应该由该类自身的方法完成，而不是外部函数。
简单入手：
从观察开始，思考**“哪些行为应该属于这个类？”**，并通过重构将逻辑移入类中。

Data Class 的合理使用场景
尽管 Data Class 被视作一种 Code Smell，但在某些场景下，它是合理且有用的：

Data Class 作为临时代码（Scaffolding）

临时结构：项目初期，为快速实现功能，可以暂时保留 Data Class。
随着项目完善，这些类可以逐步改进，将相关的行为转移到类中。

例如，用于初始化一个类的雏形：

from dataclasses import dataclass

@dataclass
class User:
    name: str
    age: int

后续可以逐步为该类添加行为，而不再只是简单的“数据容器”：

class User:
    def __init__(self, name: str, age: int):
        self.name = name
        self.age = age

    def is_adult(self):
        return self.age >= 18

Data Class 作为中间表示（Intermediate Representation）

用于在系统间传输或转换数据。
典型用例：生成 JSON 或其他格式的中间数据。
- Data Class 通常以一种不可变的形式存在。
- 不建议直接修改这些中间数据；需要时，可以实现转换函数或构造函数。

示例：

from dataclasses import dataclass, asdict

@dataclass
class ExportData:
    id: int
    name: str
    value: float
    
data = ExportData(1, "example", 100.0)

# 转换为字典，方便导出为 JSON
json_data = asdict(data)
print(json_data)

注意：如果需要修改数据，在转换为 JSON 之前，应通过定义方法规范转换行为，而非直接操作字段：

class ExportData:
    def __init__(self, id, name, value):
        self.id = id
        self.name = name
        self.value = value

    def to_json_ready(self):  # 定义一个清晰的转化方法
        return {"id": self.id, "name": self.name, "value": f"{self.value:.2f}"}

Data Class 的简单定义 & 在 Python 中的工具支持
Python 提供了一些工具简化 Data Class 的定义：

使用 @dataclass 装饰器可以快速定义数据类，减少样板代码。

示例：

from dataclasses import dataclass

@dataclass
class Point:
    x: int
    y: int

转化为字典：

p = Point(10, 20)
print(asdict(p))  # {'x': 10, 'y': 20}

注意：虽然工具便捷，但要谨慎使用仅有数据无行为的类（这种设计容易导致 Code Smell）。

总结

Code Smell代表一种潜在设计缺陷的提示。
Data Class 在大多数场景下是有问题的，因为它分离了行为和数据，但在某些情况下，例如原型开发和数据中间表示，它是有用的工具。
关键在于：
1. 持续重构：特定行为应归属到对应的类中。
2. 不要滥用数据类，将其停留在“贫血”状态。
3. 对于临时性的或特定用途的 Data Class，可放心使用，但应明确其边界。

8、Pattern Matching Class Instances

1. 什么是类模式匹配？

类模式匹配是一种通过类类型和类属性对类实例进行模式匹配的方式。支持的类不仅限于 dataclasses，可以匹配任何类的实例。以下是系统支持的类模式：

简单类模式 (Simple Class Patterns)
关键字类模式 (Keyword Class Patterns)
位置类模式 (Positional Class Patterns)

2. 简单类模式 (Simple Class Patterns)

定义：

简单类模式是匹配一个类实例的类型，通常结合内置类型进行匹配。

示例代码：

以下代码匹配一个 float 类型并处理：

x = 3.14
match x:
    case float():  # 匹配 float 类型的实例
        print("Matched a float:", x)

注意，case float(): 的语法类似调用构造函数，但其实并不是调用，而是在检查 x 是否是 float 类型。

易错点：

简单类模式的形式如果写为 case float:（省略括号），会导致 Python 将 float 作为普通变量绑定到 x：

match x:
    case float:  # DANGER!!! 不会匹配 float 类型，而是把 float 作为变量绑定
        print("Matched anything, not only float!")

此写法导致 case float: 匹配任何对象，因为 float 被当作一个变量。应始终写作 case float()。

提示：

简单类模式仅支持以下 9 个“被祝福”的内置类型：

bytes, dict, float, frozenset, int, list, set, str, tuple

补充示例：
以 str 和 tuple 类型作为匹配：

x = ("latitude", 52.5167, "N")
match x:
    case (str(name), float(lat), str(direction)):  # 匹配 tuple，第一个字符是 str 第二个是 float
        print(f"Matched a tuple. Name: {name}, Latitude: {lat}, Direction: {direction}")

3. 关键字类模式 (Keyword Class Patterns)

定义：

在关键字类模式中，可以通过类的具体属性进行匹配。这要求类有可访问的公共实例属性。

示例代码：

以下示例考虑 City 类及其实例：

from typing import NamedTuple

class City(NamedTuple):
    continent: str
    name: str
    country: str
    
cities = [
    City('Asia', 'Tokyo', 'JP'),
    City('Asia', 'Delhi', 'IN'),
    City('North America', 'Mexico City', 'MX'),
    City('North America', 'New York', 'US'),
    City('South America', 'São Paulo', 'BR'),
]

def match_asian_cities():
    results = []
    for city in cities:
        match city:
            case City(continent='Asia'):  # 仅检查 continent 属性
                results.append(city)
    return results

print(match_asian_cities())  
# 输出：[City(continent='Asia', name='Tokyo', country='JP'), City(continent='Asia', name='Delhi', country='IN')]

关键点：

模式 City(continent='Asia') 检查 continent 属性是否等于 'Asia'。
其他属性（如 name 和 country）被忽略。

捕获属性值：

如果要捕获某个属性值到变量，可使用如下方式：

def match_asian_countries():
    results = []
    for city in cities:
        match city:
            case City(continent='Asia', country=cc):  # 捕获 country 属性值到变量 cc
                results.append(cc)
    return results

print(match_asian_countries())  
# 输出：['JP', 'IN']

补充示例：
将多个属性捕获为变量：

def detailed_match():
    results = []
    for city in cities:
        match city:
            case City(continent='Asia', name=name, country=cc):  # 捕获多个属性
                results.append((name, cc))
    return results

print(detailed_match())  
# 输出：[('Tokyo', 'JP'), ('Delhi', 'IN')]

易错点：

避免拼写错误
匹配属性时需确保属性名正确，如在示例中 continent 拼错为 continett 会导致匹配失败。
只能匹配存在的公共属性
如果类的属性是私有的或动态生成的（例如通过 @property），将无法使用关键字模式匹配。

4. 位置类模式 (Positional Class Patterns)

定义：

通过类的属性顺序进行匹配，其顺序由类的特殊属性 __match_args__ 定义。

示例代码：

同样使用 City 类：

def match_asian_cities_pos():
    results = []
    for city in cities:
        match city:
            case City('Asia'):  # 匹配第一个属性（__match_args__[0]）为 'Asia'
                results.append(city)
    return results

print(match_asian_cities_pos())  
# 输出：[City(continent='Asia', name='Tokyo', country='JP'), City(continent='Asia', name='Delhi', country='IN')]

捕获属性值：

通过位置模式直接捕获指定属性：

def match_asian_countries_pos():
    results = []
    for city in cities:
        match city:
            case City('Asia', _, country):  # 捕获第三个属性（__match_args__[2]）
                results.append(country)
    return results

print(match_asian_countries_pos())  
# 输出：['JP', 'IN']

关键点：

属性的匹配顺序由 __match_args__ 决定：

print(City.__match_args__)  
# 输出：('continent', 'name', 'country')

这里的顺序是 continent -> name -> country。

结合关键字与位置匹配：

def mix_position_and_keyword():
    results = []
    for city in cities:
        match city:
            case City('Asia', name=name):  # 第一个属性按位置匹配，name 按关键字匹配
                results.append(name)
    return results

print(mix_position_and_keyword())  
# 输出：['Tokyo', 'Delhi']

易错点：

了解位置依赖
位置模式取决于 __match_args__ 的定义顺序。如果类没有正确定义 __match_args__，位置匹配会失败。
动态生成的类
如果类不支持 __match_args__（例如常规手动定义的类），可能需要额外设置才能使用位置匹配。

9、Chapter Summary

本章的主要内容是数据类构建器，包括collections.namedtuple、typing.NamedTuple和dataclasses.dataclass。我们了解到，每个构建器都能从作为工厂函数参数提供的描述中生成数据类，后两者还能从带有类型提示的类语句中生成数据类。特别要指出的是，两种具名元组变体都生成元组子类，仅增加了按名称访问字段的能力，并提供了一个_fields类属性，将字段名以字符串元组的形式列出。

接下来，我们并排研究了这三种类构建器的主要特性，包括如何将实例数据提取为字典、如何获取字段的名称和默认值，以及如何从现有实例创建新实例。

这促使我们首次深入研究类型提示，尤其是那些在类语句中用于注释属性的类型提示，它们使用了Python 3.6中通过PEP 526（变量注释语法）引入的表示法。一般来说，类型提示最令人惊讶的一点是，它们在运行时根本没有任何作用。Python仍然是一门动态语言。需要像Mypy这样的外部工具，通过对源代码进行静态分析来利用类型信息检测错误。在对PEP 526中的语法进行基本概述后，我们研究了注释在普通类以及由typing.NamedTuple和@dataclass构建的类中的作用。

接下来，我们介绍了@dataclass提供的最常用特性，以及dataclasses.field函数的default_factory选项。我们还探讨了在数据类上下文中很重要的特殊伪类型提示typing.ClassVar和dataclasses.InitVar。在这个主要内容的最后，我们给出了一个基于都柏林核心元数据标准（Dublin Core Schema）的示例，展示了如何在自定义的__repr__方法中使用dataclasses.fields来遍历Resource实例的属性。

然后，我们警告了可能存在的数据类滥用问题，这种滥用违背了面向对象编程的一个基本原则：数据和操作数据的函数应该放在同一个类中。没有逻辑的类可能是逻辑放置不当的一个信号。

在最后一节中，我们了解了模式匹配如何作用于任何类的实例，而不仅仅是本章介绍的类构建器所构建的类的实例。

查看全文

http://www.kler.cn/a/572912.html

MWC 2025 | 移远通信大模型解决方案加速落地，引领服务机器人创新变革

Tripo3D使用体验

C语言_图书管理系统_借阅系统管理

E22-xxxT22D lora模块配置

OpenFeign 学习笔记

并查集—数组实现

【Linux】进程间通信续

美颜SDK架构揭秘：人脸美型API的底层实现与优化策略

立体仓WMS同MES制造的协同

upload-labs Pass5-18 文件上传

观察者模式的C++实现示例

从零开始的kafka学习（一）| 概念，Java API

从vue源码解析Vue.set()和this.$set()

深入浅出：UniApp 从入门到精通全指南

360图片搜索爬虫|批量爬取搜索图片

关于在vue3中的动态组件component标签上给ref属性动态赋值的问题

Java进阶-SpringCloud设计模式-工厂模式的设计与详解

原型链与继承

【RAG 篇】万字长文：向量数据库选型指南 —— Milvus 与 FAISS/Pinecone/Weaviate 等工具深度对比

软考架构师笔记-进程管理

序

1、 本章新增内容

2、Overview of Data Class Builders

一、背景与痛点分析

1.1 传统类实现的缺陷

1.2 数据类的核心需求

二、三种数据类构建方案对比

2.1 collections.namedtuple

2.2 typing.NamedTuple

2.3 dataclass装饰器

三、关键选择指南

四、最佳实践建议

五、常见错误防范

六、综合应用示例

（针对上文）dataclass order参数深度解析

（针对上文的）Python 类型

（针对上文）Python不可变数据类陷阱

详解

默认参数的隐蔽共享

Main Features

3、Classic Named Tuples

1. 什么是 namedtuple？

2. 创建和访问 namedtuple

3. 常见功能和进阶操作

(1) _fields 属性

(2) _make(iterable) 方法

(3) _asdict() 方法

(4) 默认字段值

4. 如何扩展 namedtuple

(1) 添加方法

(2) 使用 typing.NamedTuple

5. 注意事项与易错点

6. 总结与对比

4、Typed Named Tuples

背景介绍

示例代码讲解

示例代码

示例说明

深入解析和补充示例

关键知识点

示例 1：字段顺序规则

示例 2：实例化过程

示例 3：类型检查和 IDE 支持

使用 Typed NamedTuple 的注意事项

总结

5、Type Hints 101

一. 类型提示的背景及目的

1. 什么是类型提示（Type Hints）？

2. 类型提示的特点

二. 类型提示的基础语法

1. 基本语法

三. 类型提示在 Python 三种数据类构建器中的作用

1. 普通类的行为

为什么a不是类属性呢

2. NamedTuple 的行为

3. DataClass 的行为

四. 关键点与常见问题总结

五. 补充学习与实践

1. 针对不同场景的扩展例子

2. 常见问题

6、More About @dataclass

基本介绍

1. 什么是 @dataclass？

2. @dataclass 的关键参数

3. 常见问题与注意事项

（1）字段排除和自定义

（2）深度不可变问题

（3）动态性限制

Field Options

一、可变默认值的重要性和陷阱

1. 为什么避免可变默认值？

解释

2. 解决方案：使用 default_factory

3. 示例对比

三、字段选项总结

四、字段类型注解：泛型和强类型支持

1. 泛型类型注解

2. 强类型的好处

五、更多例子

例子 1：多字段组合

1、本章新增内容

1. 什么是 `namedtuple`？

2. 创建和访问 `namedtuple`

(1) `_fields` 属性

(2) `_make(iterable)` 方法

(3) `_asdict()` 方法

4. 如何扩展 `namedtuple`

(2) 使用 `typing.NamedTuple`

2. 解决方案：使用 `default_factory`

一、`__post_init__` 方法的背景知识

3. `__post_init__` 方法的作用

二、`__post_init__` 的用法

基类 `ClubMember`

子类 `HackerClubMember`

`__post_init__` 的详细操作步骤

六、补充例子：`__post_init__` 的更多应用

4. 自定义 `repr` 输出（更具可读性）

1) `field(default_factory=...)` 的安全使用