Python动态类型提示

Question

我希望能够提供一个具有类型元组的函数，然后将其用于反序列化从事务返回的数据。如果事务成功，该函数将返回这些类型的实例。 例如：

T = TypeVar('T')

class Base:
    @classmethod
    def deserialize(cls: Type[T], bts: bytes) -> T:
        return cls(**json.loads(bts))

    @classmethod
    def transaction(cls, *types):
        items = self.db.transact([t.generate_load_operation() for t in types])
        items = [t.deserialize(item) for item in items]

        # how do I type-hint transaction, so that it would imply that
        # it will always return a tuple (or a list) of instances of classes 
        # contained in variable types?
        return items

class A(Base):
    pass

class B(Base):
    pass

a_inst, b_inst = Base.transaction(A, B)

我应该如何注释事务，以便类型检查器可以正确推断从它返回的值的类型？

Answer 1

没有通用的方法可以做到这一点：就静态类型检查而言，诸如*types 之类的可变参数不会保持顺序。 Variadic generics cover this behaviour but are only proposals so far.

可以对可变参数使用单个注释，这会降级为通用基本类型，也可以使用多个注释来枚举最常见的情况。

---

将可变参数注释为类型变量（可能通过Base 绑定）。这会将 所有 类型推断为相同的、最常见的基本类型。

class Base:
    @classmethod
    def transaction(cls, *types: Type[T]) -> List[T]: ...

class A(Base): ...

class B(Base): ...

reveal_type(Base.transaction(A, A))  # builtins.list[mt.A*]
reveal_type(Base.transaction(A, B))  # builtins.list[mt.Base*]

这在使用类似类型（例如仅A 或A 的子类）并且仅期望一般功能（例如仅A）时就足够了。这在使用混合类型（例如A 和B）时是不够的，因为它会退化为通用的基本类型（例如Base）。

---

为合理数量的参数提供multiple @overload 签名，并为大量参数使用可变参数包罗万象。这将为指定的情况推断出正确的类型，否则使用最常见的基本类型。

class Base:
    # explicitly enumerated types
    @overload
    @classmethod
    def transaction(cls, t1: Type[T1], /) -> Tuple[T1]: ...
    @overload
    @classmethod
    def transaction(cls, t1: Type[T1], t2: Type[T2], /) -> Tuple[T1, T2]: ...
    # catch all number of types
    @overload
    @classmethod
    def transaction(cls, *ts: Type[T]) -> Tuple[T, ...]: ...

    # implementation
    @classmethod
    def transaction(cls, *types: Type[T]) -> Tuple[T, ...]: ...

class A(Base): ...

class B(Base): ...

reveal_type(Base.transaction(A))        # Revealed type is 'Tuple[mt.A*]'
reveal_type(Base.transaction(A, A))     # Revealed type is 'Tuple[mt.A*, mt.A*]'
reveal_type(Base.transaction(A, B))     # Revealed type is 'Tuple[mt.A*, mt.B*]'
reveal_type(Base.transaction(A, B, A))  # Revealed type is 'builtins.tuple[mt.Base*]'

这里的限制只是一个人认为相关的案例数量。 This mechanism is also used for the standard library.