如何补全含可选属性的Python Dataclass并通过静态类型检查？

我们需要实现一个Python数据类MyData，满足以下需求：

• a 是必填属性，必须提供；
• b 和 c 是可选属性，但至少要指定其中一个；
• 如果未提供b，可在初始化后通过a和c计算得到；未提供c同理，计算逻辑由外部高成本函数实现。

从运行逻辑来看，只要传入a和至少一个b/c，初始化完成后所有属性都会是float类型，但静态类型检查器（如mypy）仍会认为b/c可能为None并报错。

现有实现代码如下：

from dataclasses import dataclass
from typing import cast
from time import sleep

@dataclass
class MyData:
    a: float
    b: float | None = None
    c: float | None = None

    def __post_init__(self) -> None:
        self._complete_attributes()

    def _complete_attributes(self) -> None:
        """检查缺失属性并在可能时计算补全"""

        if self.b is None and self.c is None:
            raise ValueError("必须指定b或c中的一个！")
        elif self.b is None:
            # 这里用cast只是为了让mypy相信c不是None，运行时无作用
            self.c = cast(float, self.c)
            self.b = compute_b(self.a, self.c)
        elif self.c is None:
            self.b = cast(float, self.b)
            self.c = compute_c(self.a, self.b)


def compute_b(a: float, c: float) -> float:
    sleep(10)  # 模拟高成本计算
    return a + c

def compute_c(a: float, b: float) -> float:
    sleep(10)  # 模拟高成本计算
    return b - a

当使用MyData的b或c属性时，比如定义以下函数：

def do_stuff(data: MyData) -> float:
    return data.a * data.b

mypy会抛出错误：

error: Unsupported operand types for * ("float" and "None") [operator]
note: Right operand is of type "Optional[float]"

请问如何实现该数据类，既能满足业务需求，又能通过静态类型检查？

方法1：重写__init__并调整类级别类型注解 #

直接重写__init__方法，在初始化阶段就处理可选参数的逻辑，同时让类的类型注解明确b和c最终是float类型，无需依赖cast或断言：

from dataclasses import dataclass
from time import sleep

@dataclass
class MyData:
    a: float
    b: float
    c: float

    def __init__(self, a: float, b: float | None = None, c: float | None = None):
        self.a = a

        if b is None and c is None:
            raise ValueError("必须指定b或c中的一个！")
        elif b is None:
            # mypy可通过逻辑推断c不为None
            self.c = c
            self.b = compute_b(a, c)
        elif c is None:
            self.b = b
            self.c = compute_c(a, b)
        else:
            # 两者都提供时直接赋值
            self.b = b
            self.c = c


def compute_b(a: float, c: float) -> float:
    sleep(10)
    return a + c

def compute_c(a: float, b: float) -> float:
    sleep(10)
    return b - a

这种方法的核心是：类级别的类型注解直接声明b和c为float，告诉类型检查器实例化后的属性必然是非空浮点数；自定义__init__处理参数的可选逻辑，确保初始化完成后属性都被正确赋值。

方法2：使用assert语句辅助类型推断（Python 3.10+） #

如果不想重写__init__，可以在__post_init__和补全逻辑中加入assert语句，让mypy通过逻辑推断确认b和c最终不为None：

from dataclasses import dataclass
from time import sleep

@dataclass
class MyData:
    a: float
    b: float | None = None
    c: float | None = None

    def __post_init__(self) -> None:
        self._complete_attributes()
        # 断言属性已初始化，让mypy确认非空
        assert self.b is not None, "b属性必须完成初始化"
        assert self.c is not None, "c属性必须完成初始化"

    def _complete_attributes(self) -> None:
        if self.b is None and self.c is None:
            raise ValueError("必须指定b或c中的一个！")
        elif self.b is None:
            assert self.c is not None
            self.b = compute_b(self.a, self.c)
        elif self.c is None:
            assert self.b is not None
            self.c = compute_c(self.a, self.b)


def compute_b(a: float, c: float) -> float:
    sleep(10)
    return a + c

def compute_c(a: float, b: float) -> float:
    sleep(10)
    return b - a

assert语句不仅在运行时会执行检查（可通过-O参数关闭），还能让mypy推断出断言后的变量不为None，比cast更清晰地表达逻辑意图。

方法3：使用工厂函数封装实例创建 #

不直接暴露数据类的构造函数，而是通过工厂函数处理可选参数逻辑，数据类本身的属性全部声明为必填非空类型：

from dataclasses import dataclass
from typing import Optional
from time import sleep

@dataclass(frozen=True)  # 可选：冻结数据类防止后续属性被修改
class MyData:
    a: float
    b: float
    c: float

def create_my_data(a: float, b: Optional[float] = None, c: Optional[float] = None) -> MyData:
    if b is None and c is None:
        raise ValueError("必须指定b或c中的一个！")
    elif b is None:
        assert c is not None
        computed_b = compute_b(a, c)
        return MyData(a, computed_b, c)
    elif c is None:
        assert b is not None
        computed_c = compute_c(a, b)
        return MyData(a, b, computed_c)
    else:
        return MyData(a, b, c)


def compute_b(a: float, c: float) -> float:
    sleep(10)
    return a + c

def compute_c(a: float, b: float) -> float:
    sleep(10)
    return b - a

使用时通过工厂函数创建实例：

data = create_my_data(a=1.0, c=3.0)
print(data.b)  # mypy可正确识别data.b为float类型

这种方法的优势是数据类本身的类型定义极其清晰，所有属性都是必填非可选类型，可选逻辑完全封装在工厂函数中，类型检查器能完美推断实例的属性类型。

内容的提问来源于stack exchange，提问作者uncoordinated_noodle