Python dataclass 进阶：post_init、field 与序列化陷阱

1
from dataclasses import dataclass
2

3
@dataclass
4
class Person:
5
    first_name: str
6
    last_name: str
7
    age: int
8

9
    def __post_init__(self):
10
        # 此时 self.first_name, self.last_name, self.age 已赋值
11
        self.full_name = f"{self.first_name} {self.last_name}"
12
        if self.age < 0:
13
            raise ValueError(f"年龄不能为负: {self.age}")
14

15
p = Person("张", "三", 28)
16
print(p.full_name)  # 张三

1
from dataclasses import dataclass, field
2

3
@dataclass
4
class CachedData:
5
    key: str
6
    value: str
7
    _cache: dict = field(default_factory=dict, init=False)
8
    _hit_count: int = field(default=0, init=False)
9

10
    def get(self, sub_key: str):
11
        if sub_key in self._cache:
12
            self._hit_count += 1
13
            return self._cache[sub_key]
14
        result = self.value  # 模拟计算
15
        self._cache[sub_key] = result
16
        return result
17

18
c = CachedData("config", "default_value")
19
print(c._cache)         # {}
20
print(c.get("theme"))   # default_value
21
print(c._hit_count)     # 0（首次未命中）
22
print(c.get("theme"))   # default_value
23
print(c._hit_count)     # 1（命中缓存）

1
from dataclasses import dataclass
2

3
@dataclass
4
class Animal:
5
    name: str
6
    legs: int
7

8
    def __post_init__(self):
9
        print(f"Animal.__post_init__: {self.name}")
10

11
@dataclass
12
class Dog(Animal):
13
    breed: str
14

15
    def __post_init__(self):
16
        print(f"Dog.__post_init__: {self.breed}")
17

18
d = Dog("旺财", 4, "金毛")
19
# 只打印: Dog.__post_init__: 金毛
20
# Animal.__post_init__ 没有被调用！

1
from dataclasses import dataclass, field, InitVar
2
import math
3

4
@dataclass
5
class Circle:
6
    radius: float
7
    # 这个参数只在 __init__ 和 __post_init__ 中出现，不作为实例属性
8
    use_cache: InitVar[bool] = True
9

10
    _cached_area: float = field(default=0.0, init=False)
11

12
    def __post_init__(self, use_cache: bool):
13
        if use_cache:
14
            self._cached_area = math.pi * self.radius ** 2
15
            print(f"  预计算面积: {self._cached_area:.2f}")
16
        else:
17
            print(f"  不预计算面积")
18

19
    @property
20
    def area(self) -> float:
21
        if self._cached_area:
22
            return self._cached_area
23
        return math.pi * self.radius ** 2
24

25
c1 = Circle(5.0, use_cache=True)
26
#   预计算面积: 78.54
27
print(c1.area)  # 78.5398...
28

29
c2 = Circle(5.0, use_cache=False)
30
#   不预计算面积
31

32
# InitVar 不会出现在 repr 中，也不是实例属性
33
print(hasattr(c1, "use_cache"))  # False

1
# ✅ 正确：使用 default_factory
2
from dataclasses import dataclass, field
3

4
@dataclass
5
class Team:
6
    name: str
7
    members: list = field(default_factory=list)
8
    metadata: dict = field(default_factory=dict)
9

10
t1 = Team("开发组")
11
t2 = Team("测试组")
12
t1.members.append("Alice")
13

14
print(t1.members)  # ['Alice']
15
print(t2.members)  # []  ← 独立列表，不受 t1 影响

1
# Python 3.10+
2
@dataclass
3
class ServerConfig:
4
    host: str
5
    port: int
6
    # 以下参数必须以关键字形式传递
7
    timeout: float = field(default=30.0, kw_only=True)
8
    retries: int = field(default=3, kw_only=True)
9
    debug: bool = field(default=False, kw_only=True)
10

11
# ✅ 正确
12
cfg = ServerConfig("localhost", 8080, timeout=60.0, debug=True)
13

14
# ❌ 错误：timeout 是 kw_only，不能按位置传递
15
# cfg = ServerConfig("localhost", 8080, 60.0, 3, True)

1
from dataclasses import dataclass, asdict, astuple
2

3
@dataclass
4
class Address:
5
    city: str
6
    zipcode: str
7

8
@dataclass
9
class Contact:
10
    name: str
11
    address: Address
12

13
contact = Contact("Alice", Address("北京", "100000"))
14

15
print(asdict(contact))
16
# {'name': 'Alice', 'address': {'city': '北京', 'zipcode': '100000'}}
17

18
print(astuple(contact))
19
# ('Alice', ('北京', '100000'))

1
from dataclasses import dataclass
2

3
@dataclass
4
class EventV2:
5
    title: str
6
    timestamp_str: str  # 存储为字符串
7

8
    @classmethod
9
    def from_datetime(cls, title: str, ts: datetime):
10
        return cls(title, ts.isoformat())
11

12
    @property
13
    def timestamp(self) -> datetime:
14
        return datetime.fromisoformat(self.timestamp_str)
15

16
event = EventV2.from_datetime("会议", datetime(2026, 6, 1, 14, 0))
17
print(json.dumps(asdict(event)))
18
# {"title": "会议", "timestamp_str": "2026-06-01T14:00:00"}

1
from collections import OrderedDict
2
from dataclasses import dataclass, asdict
3

4
@dataclass
5
class OrderedItem:
6
    zebra: int
7
    apple: int
8
    mango: int
9

10
item = OrderedItem(1, 2, 3)
11

12
# 默认 dict 不保证插入顺序（Python 3.7+ 实际上有序，但语义上不能依赖）
13
print(asdict(item))
14

15
# 使用 OrderedDict 显式保证顺序
16
print(asdict(item, dict_factory=OrderedDict))
17
# OrderedDict([('zebra', 1), ('apple', 2), ('mango', 3)])

1
from dataclasses import dataclass, asdict, field
2

3
def skip_none(d: list) -> dict:
4
    """过滤掉值为 None 的键"""
5
    return {k: v for k, v in d if v is not None}
6

7
@dataclass
8
class Profile:
9
    name: str
10
    age: int
11
    bio: str | None = None
12
    website: str | None = None
13

14
p1 = Profile("Alice", 30)
15
p2 = Profile("Bob", 25, bio="开发者", website="https://bob.dev")
16

17
print(asdict(p1, dict_factory=skip_none))
18
# {'name': 'Alice', 'age': 30}  ← bio 和 website 被过滤
19

20
print(asdict(p2, dict_factory=skip_none))
21
# {'name': 'Bob', 'age': 25, 'bio': '开发者', 'website': 'https://bob.dev'}

1
from dataclasses import dataclass, field
2

3
@dataclass
4
class Node:
5
    value: int
6
    parent: "Node | None" = field(default=None, repr=False)
7
    children: list = field(default_factory=list, repr=False)
8

9
root = Node(0)
10
child = Node(1, parent=root)
11
root.children.append(child)
12

13
# 如果 child 也包含 parent 引用：
14
child2 = Node(2, parent=child)
15
child.children.append(child2)
16

17
# 手动构建循环引用
18
# root.parent = child2  # 形成环
19

20
# asdict(root)  # 如果有循环引用 → RecursionError

1
from dataclasses import dataclass, asdict, is_dataclass
2
from datetime import datetime, date
3
from enum import Enum
4
import json
5

6
class DataclassEncoder(json.JSONEncoder):
7
    """支持 dataclass、datetime、Enum 的 JSON 编码器"""
8

9
    def default(self, obj):
10
        if is_dataclass(obj):
11
            return asdict(obj)
12
        if isinstance(obj, (datetime, date)):
13
            return obj.isoformat()
14
        if isinstance(obj, Enum):
15
            return obj.value
16
        if isinstance(obj, set):
17
            return list(obj)
18
        return super().default(obj)
19

20
@dataclass
21
class Order:
22
    order_id: str
23
    customer: str
24
    items: list
25
    total: float
26
    status: str
27
    created_at: datetime
28

29
class OrderStatus(Enum):
30
    PENDING = "pending"
31
    SHIPPED = "shipped"
32
    DELIVERED = "delivered"
33

34
order = Order(
35
    order_id="ORD-2026-001",
36
    customer="张三",
37
    items=["键盘", "鼠标"],
38
    total=498.0,
39
    status="pending",
40
    created_at=datetime(2026, 6, 1, 10, 30),
41
)
42

43
json_str = json.dumps(order, cls=DataclassEncoder, ensure_ascii=False, indent=2)
44
print(json_str)
45
# {
46
#   "order_id": "ORD-2026-001",
47
#   "customer": "张三",
48
#   "items": ["键盘", "鼠标"],
49
#   "total": 498.0,
50
#   "status": "pending",
51
#   "created_at": "2026-06-01T10:30:00"
52
# }

1
from dataclasses import dataclass
2
import json
3

4
@dataclass
5
class Address:
6
    city: str
7
    zipcode: str
8

9
@dataclass
10
class Person:
11
    name: str
12
    age: int
13
    address: Address
14

15
def deserialize_person(data: dict) -> Person:
16
    """将 JSON 解析的字典还原为 Person 对象"""
17
    addr_data = data.pop("address", None)
18
    if addr_data:
19
        data["address"] = Address(**addr_data)
20
    return Person(**data)
21

22
json_str = '''
23
{
24
    "name": "李四",
25
    "age": 35,
26
    "address": {
27
        "city": "上海",
28
        "zipcode": "200000"
29
    }
30
}
31
'''
32

33
data = json.loads(json_str)
34
person = deserialize_person(data)
35
print(person)
36
# Person(name='李四', age=35, address=Address(city='上海', zipcode='200000'))

1
from dataclasses import dataclass, field
2

3
@dataclass(frozen=True)
4
class Vector:
5
    x: float
6
    y: float
7
    # 必须用 init=False + field() 定义
8
    magnitude: float = field(init=False)
9

10
    def __post_init__(self):
11
        # ❌ self.magnitude = (self.x**2 + self.y**2)**0.5  # FrozenInstanceError
12
        # ✅ 使用 object.__setattr__ 绕过冻结
13
        object.__setattr__(self, "magnitude", (self.x**2 + self.y**2)**0.5)
14

15
v = Vector(3.0, 4.0)
16
print(v.magnitude)  # 5.0

1
@dataclass(frozen=True)
2
class HashablePoint:
3
    x: int
4
    y: int
5

6
p1 = HashablePoint(1, 2)
7
p2 = HashablePoint(1, 2)
8

9
# 可以作为 dict 的 key
10
d = {p1: "point_a"}
11
print(d[p2])  # "point_a" ← p1 和 p2 hash 相等
12

13
# 可以作为 set 的元素
14
s = {p1, p2}
15
print(len(s))  # 1 ← 去重

1
import sys
2
from dataclasses import dataclass
3

4
@dataclass
5
class MutablePoint:
6
    x: float
7
    y: float
8

9
@dataclass(frozen=True)
10
class FrozenPoint:
11
    x: float
12
    y: float
13

14
m = MutablePoint(1.0, 2.0)
15
f = FrozenPoint(1.0, 2.0)
16

17
print(f"可变对象: {sys.getsizeof(m)} bytes")
18
print(f"不可变对象: {sys.getsizeof(f)} bytes")

1
from dataclasses import dataclass
2
from typing import TypedDict
3

4
# dataclass：运行时有实例，支持方法
5
@dataclass
6
class User:
7
    name: str
8
    age: int
9

10
    def greeting(self) -> str:
11
        return f"Hello, {self.name}!"
12

13
# TypedDict：纯粹的类型标注，无运行时实例
14
class UserDict(TypedDict):
15
    name: str
16
    age: int
17

18
# 使用
19
user = User("Alice", 30)
20
print(user.greeting())  # Hello, Alice!
21

22
user_dict: UserDict = {"name": "Bob", "age": 25}
23
print(user_dict["name"])  # Bob

1
# frozen=True 时自动 hash
2
@dataclass(frozen=True)
3
class A:
4
    x: int
5

6
a = A(1)
7
print(hash(a))  # 可以 hash
8

9
# 默认 mutable 对象不可 hash
10
@dataclass
11
class B:
12
    x: int
13

14
b = B(1)
15
# hash(b)  # TypeError: unhashable type: 'B'
16

17
# 显式声明 unsafe_hash
18
@dataclass(unsafe_hash=True)
19
class C:
20
    x: int
21

22
c = C(1)
23
print(hash(c))  # 可以 hash（但如果 x 被修改，hash 值不变，可能导致 dict 查找失败）