使用与另一个通用类绑定的类型var通用类

Question

如果foo在t中是通用存储一个foo的实例，然后为了避免写作，

class Bar(Generic[T, U, V]): 
    def __init__(self, foo: Foo[T, U], v: V): 
        ...

我们可以定义foot = typevar（“ foot”，foo [any，any]） 然后写入

class Bar(Generic[FooT, V]): 
    def __init__(self, foo: FooT, v: V): 
         pass

然后实例化bar变为bar [foo [int，str]，bool]例如bar [int，str，bool]。对我来说，这是代码清晰度和可维护性方面的改进。但是，即使有一个更简单的玩具示例，我也遇到了这种模式的问题：

from typing import Generic, TypeVar, Union, TYPE_CHECKING

ResultT = TypeVar("ResultT")

class Query(Generic[ResultT]):
    def __init__(self, r: ResultT) -> None:
        self.r = r

QueryT = TypeVar("QueryT", bound=Query[Any])

class Client(Generic[QueryT]):
    def __init__(self, q: QueryT) -> None:
        self.q = q
        self.r = q.r

c = Client[Query[int]](Query[int](2))
if TYPE_CHECKING:
    reveal_type(c.q)
    reveal_type(c.q.r)
    reveal_type(c.r)
print(id(c.r) == id(c.q.r))  # true

----
mypytest.py:17: note: Revealed type is "mypytest.Query[builtins.int]"
mypytest.py:18: note: Revealed type is "builtins.int"
mypytest.py:19: note: Revealed type is "Any"
Success: no issues found in 1 source file

我很惊讶Mypy在这种情况下推断cqr和cr 。 >是相同的。基本上，它假设cr是resultt的上限，在这种情况下是任何，而不是通过实例化的实例化所隐含类型查询[int]。但是令我困扰的是，该类型是根据访问模式正确解决的……

其他一些有趣的修改（这可能与我相对较新的方式与Python的仿制药一起工作有关），请根据我是否更改了queryt定义并运行mypy带有- strict：

QueryT = TypeVar("QueryT", bound=Query[Union[int, str]])

---
mypytest.py:22: error: Value of type variable "QueryT" of "Client" cannot be "Query[int]"
mypytest.py:24: note: Revealed type is "mypytest.Query[builtins.int]"
mypytest.py:25: note: Revealed type is "builtins.int"
mypytest.py:26: note: Revealed type is "Union[builtins.int, builtins.str]"

这基本上是与上述相同的行为，但是现在上限是union [int，str] 正如预期的那样（但是，为什么现在的类型现在缩小到int？）。我在严格的模式下也会遇到错误 - 我认为允许此任务？

QueryT = TypeVar("QueryT", bound=Union[Query[int], Query[str]])

---
mypytest.py:18: note: Revealed type is "mypytest.Query[builtins.int]"
mypytest.py:19: note: Revealed type is "builtins.int"
mypytest.py:20: note: Revealed type is "Union[builtins.int, builtins.str]"

通过考虑Union来解决错误。我敢肯定，说明很明显，只需要考虑一下即可。

QueryT = TypeVar("QueryT", Query[int], Query[str])

---
mypytest.py:24: error: Need type annotation for "q"
mypytest.py:25: error: Need type annotation for "r"
mypytest.py:29: note: Revealed type is "Any"
mypytest.py:30: note: Revealed type is "Any"
mypytest.py:31: note: Revealed type is "Any"

将TypeVar限制为两种类型的简单案例似乎是最简单的建议，但是它给了类型的检查器最大的问题。为什么在这里需要明确的注释以避免推断 ？

通过仅跳过中间queryt 类型，一切都在严格的情况下起作用：没有任何错误：

class Client(Generic[ResultT]):
    def __init__(self, q: Query[ResultT]) -> None:
        ...
c = Client[int](Query[int](2))
...

---
mypytest.py:39: note: Revealed type is "mypytest.Query[builtins.int]"
mypytest.py:40: note: Revealed type is "builtins.int"
mypytest.py:41: note: Revealed type is "builtins.int"

缺乏对最佳实践的进展/建议，我可能只会收集并重复所有原始通用类型用于课程； Mypy已经迫使您为继承而这样做，因此对于构图来说可能没什么大不了的。