本文介绍了如何使用 Python 的 typing 模块来实现泛型类型之间的依赖关系。通过使用 Protocol 和 TypeVar，我们可以更精确地定义类的类型约束，从而提高代码的可读性和健壮性。本文提供了一个具体的例子，展示了如何将 to 参数的类型与 data 参数的类型绑定在一起，并提供了详细的代码示例和使用方法。
在 Python 中，类型提示可以显著提高代码的可读性和可维护性。然而，当涉及到泛型类型时，特别是当这些类型之间存在依赖关系时，类型提示可能会变得复杂。本文将介绍如何使用 typing 模块中的 Protocol 和 TypeVar 来解决这类问题。
使用 Protocol 定义索引类型
当我们需要定义一个类型，它必须支持某种索引操作（例如，__getitem__ 和 __setitem__），但我们不关心它的具体类型是 MutableMapping 还是 MutableSequence 时，可以使用 Protocol。
以下是一个 Indexable 协议的定义，它要求类型必须支持使用键 K 进行索引，并且可以设置对应的值：
立即学习“Python免费学习笔记（深入）”；
import typing
K = typing.TypeVar('K', contravariant=True)
class Indexable(typing.Protocol[K]):
def __getitem__(self, key: K):
pass
def __setitem__(self, key: K, value: typing.Any):
pass这里，K 是一个 TypeVar，它表示键的类型。contravariant=True 表明 K 是逆变的，这意味着 Indexable[int] 可以赋值给 Indexable[typing.Hashable]。
使用 TypeVar 约束泛型类型
TypeVar 可以用来定义泛型类型变量，并可以对这些变量进行约束。例如，我们可以定义一个 TypeVar，它必须是 typing.Hashable 的子类型：
H = typing.TypeVar('H', bound=typing.Hashable)这表示 H 可以是任何可哈希的类型，例如 int、str 等。
将 to 和 data 类型绑定
现在，我们可以使用 Protocol 和 TypeVar 来定义 ApplyTo 类，并将 to 参数的类型与 data 参数的类型绑定在一起：
import typing
DispatchType = typing.Literal['separate', 'joint']
# `P` must be declared with `contravariant=True`, otherwise it errors with
# 'Invariant type variable "P" used in protocol where contravariant one is expected'
K = typing.TypeVar('K', contravariant=True)
class Indexable(typing.Protocol[K]):
def __getitem__(self, key: K):
pass
def __setitem__(self, key: K, value: typing.Any):
pass
# Accepts only hashable types (including `int`s)
H = typing.TypeVar('H', bound=typing.Hashable)
class ApplyTo(typing.Generic[H]):
_to: typing.Sequence[H]
_dispatch: DispatchType
_transform: typing.Callable[..., typing.Any] # TODO Initialize `_transform`
def __init__(self, to: typing.Sequence[H] | H, dispatch: DispatchType = 'separate') -> None:
self._dispatch = dispatch
self._to = to if isinstance(to, typing.Sequence) else [to]
def __call__(self, data: Indexable[H]) -> typing.Any:
if self._dispatch == 'separate':
for key in self._to:
data[key] = self._transform(data[key])
return data
if self._dispatch == 'joint':
args = [data[key] for key in self._to]
return self._transform(*args)
assert False在这个例子中，ApplyTo 类接受一个泛型类型 H，它必须是 typing.Hashable 的子类型。_to 属性的类型是 typing.Sequence[H]，表示它是一个包含 H 类型元素的序列。__call__ 方法接受一个 Indexable[H] 类型的参数 data，这意味着 data 必须支持使用 H 类型的键进行索引。
使用示例
以下是一些使用 ApplyTo 类的示例：
def main() -> None:
r0 = ApplyTo(to=0)([1, 2, 3])
# typechecks
r0 = ApplyTo(to=0)({1: 'a', 2: 'b', 3: 'c'})
# typechecks
r1 = ApplyTo(to='a')(['b', 'c', 'd'])
# does not typecheck: Argument 1 to "__call__" of "Applier" has incompatible type "list[str]"; expected "Indexable[str]"
r1 = ApplyTo(to='a')({'b': 1, 'c': 2, 'd': 3})
# typechecks可以看到，当 to 是 int 类型时，data 可以是 list 或 dict，但当 to 是 str 类型时，data 必须是 dict。这是因为 list 只支持使用 int 类型的索引，而 dict 支持使用 Hashable 类型的索引。
总结
通过使用 Protocol 和 TypeVar，我们可以更精确地定义泛型类型之间的依赖关系，从而提高代码的可读性和健壮性。在设计泛型类时，应该仔细考虑类型之间的约束关系，并使用 typing 模块提供的工具来表达这些约束。这有助于在编译时发现类型错误，并减少运行时错误的发生。
