如何在字典中正确使用TypeVar实现键值类型绑定？

问题背景 #

想要构建一个字典，其中键是类的元组，值是可接受这些类实例的可调用对象，但多次尝试类型标注都触发MyPy错误，具体尝试及报错如下：

尝试1：直接使用TypeVar定义字典 #

from typing import Callable, Dict, Tuple, TypeVar
from typing import Type

T = TypeVar("T")

A: Dict[
        Tuple[Type[T],...], Callable[[T], str]
    ] = {
        (bool, str, int, float): lambda d: str(d)
    }

报错：Type variable T is unbound

尝试2：结合Generic容器类 #

from typing import Callable, Dict, Tuple, TypeVar
from typing import Generic, Type

T = TypeVar("T")
class Test(Generic[T]):
    A: Dict[
            Tuple[Type[T],...], Callable[[T], str]
        ] = {
            (bool, str, int, float): lambda d: str(d)
        }

报错：error: Dict entry 0 has incompatible type "Tuple[Type[bool], Type[str], Type[int], Type[float]]": "Callable[[T], str]"; expected "Tuple[Type[T], ...]"

尝试3：简化为单个类型键 #

class Test(Generic[T]):
    A: Dict[Type[T], Callable[[T], str]] = {
        bool: lambda d: str(d)
    }

报错：error: Dict entry 0 has incompatible type "Type[bool]": "Callable[[T], str]"; expected "Type[T]": "Callable[[T], str]"

尝试4：进一步简化为Dict[T, T] #

T = TypeVar("T")

class Test(Generic[T]):
    A: Dict[T, T] = {bool: bool}

报错：Dict entry 0 has incompatible type "Type[bool]": "Type[bool]"; expected "T": "T"

解决方案 #

核心问题 #

TypeVar[T]代表单一具体类型，但你的字典键包含多种不同类型（bool、str等），T无法同时绑定到多个类型。MyPy要求类型变量必须明确绑定到某个具体类型，异构字典需要用Union或Protocol来定义约束。

方案1：明确支持的类型集合（推荐） #

用Union指定所有支持的类型，直接标注字典的键值类型：

from typing import Callable, Mapping, Tuple, Type, Union

# 定义所有支持的类型
SupportedTypes = Union[bool, str, int, float]

# 标注字典：键是这些类型的元组，值是接受该类型实例的可调用
A: Mapping[Tuple[Type[SupportedTypes], ...], Callable[[SupportedTypes], str]] = {
    (bool, str, int, float): lambda d: str(d),
    (int, float): lambda d: f"数值: {d}"
}

这种方式既能让MyPy正确检查类型，又保留了业务逻辑的约束。

方案2：用Generic类处理单类型条目 #

如果需要按类型分类管理，让Generic类的实例绑定到具体类型，而非在类级别定义异构字典：

from typing import Callable, Dict, Generic, Type, TypeVar

T = TypeVar("T")

class TypeHandler(Generic[T]):
    def __init__(self, handler_map: Dict[Type[T], Callable[[T], str]]):
        self.handlers = handler_map

# 创建针对bool类型的处理器实例
bool_handler = TypeHandler({bool: lambda d: f"布尔值: {d}"})
# 创建针对int类型的处理器实例
int_handler = TypeHandler({int: lambda d: f"整数: {d}"})

每个实例仅处理一种类型，MyPy可以完全校验类型正确性。

方案3：用Protocol定义灵活约束（复杂场景） #

如果需要更灵活的类型约束，可通过Protocol定义键值对的行为：

from typing import Callable, Mapping, Protocol, Tuple, Type, TypeVar

T = TypeVar("T")

class TypeCallablePair(Protocol[T]):
    def __getitem__(self, key: Tuple[Type[T], ...]) -> Callable[[T], str]: ...

# 结合Union使用，适配异构场景
from typing import Union
SupportedTypes = Union[bool, str, int, float]
A: TypeCallablePair[SupportedTypes] = {
    (bool, str): lambda d: str(d)
}

这种方式适合需要自定义类型行为的复杂场景。

方案4：临时绕过检查（不推荐） #

如果暂时不需要严格类型校验，可使用Any：

from typing import Any, Callable, Dict, Tuple, Type

A: Dict[Tuple[Type[Any], ...], Callable[[Any], str]] = {
    (bool, str, int, float): lambda d: str(d)
}

但会丢失类型检查的优势，仅建议应急使用。

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