您可以根据传递给构造函数的参数键入提示重载方法的返回类型吗？

Question

假设我有这样的课程：

class myclass:
    def __init__ (self, param1: Tuple[str,...], param2: bool) -> None:
        self.member1 = param1
        self.member2 = param2
        self.member3 = 10

    def gimmie(self) -> int | Tuple[str,...]:
        return self.member1 if self.member2 else self.member3

有什么方法可以确保来自 gimmie 的返回不是类型为int | Tuple[str,...]，而是int或Tuple[str,...]？ p>

编辑：

有几个答案需要大量的杂技才能做到这一点，而我真正想做的只是cast 回报。因此，这些答案中的每一个都对代码“气味”进行了评论。

问题只是我构造了一个带有标志的对象，其中一种方法根据该标志返回 2 种类型中的 1 种。如果那是糟糕的设计，那么“正确”的做法是什么？

Answer 1

这是一种使用泛型解决此问题的方法：

from __future__ import annotations
from typing import overload, Literal, Generic, TypeVar, cast

T = TypeVar('T')


class myclass(Generic[T]):
    member1: tuple[str, ...]
    member2: bool
    member3: int

    @overload
    def __init__(self: myclass[tuple[str, ...]], param1: tuple[str, ...], param2: Literal[True]) -> None:
        ...

    @overload
    def __init__(self: myclass[int], param1: tuple[str, ...], param2: Literal[False]) -> None:
        ...

    def __init__(self, param1: tuple[str, ...], param2: bool) -> None:
        self.member1 = param1
        self.member2 = param2
        self.member3 = 10

    def gimmie(self) -> T:
        return cast(T, self.member1 if self.member2 else self.member3)


reveal_type(myclass(('a', 'b'), True).gimmie())
# note: Revealed type is "builtins.tuple*[builtins.str]"

reveal_type(myclass(('a', 'b'), False).gimmie())
# note: Revealed type is "builtins.int*"

一些注意事项：

• 这种方法需要注释self 参数以赋予它不同的静态类型。通常情况下，我们不会注释self，所以请务必不要忘记这一点！
• 遗憾的是，如果不添加 cast，我无法让 a if b else c 拥有正确的类型。

我同意 Samwise 的观点，这种类型的柔道是一种代码味道，并且可能隐藏了您项目设计的问题。

Answer 2

这是使用子类和@overloaded 工厂函数来解决它的一种方法：

from typing import Literal, Tuple, Union, cast, overload


class MyClass:
    def __init__(self, param1: Tuple[str, ...], param2: bool) -> None:
        self.member1 = param1
        self.__member2 = param2
        self.member3 = 10

    def gimmie(self) -> Union[int, Tuple[str, ...]]:
        return self.member1 if self.__member2 else self.member3


class _MySubclass1(MyClass):
    def gimmie(self) -> Tuple[str, ...]:
        return cast(Tuple[str, ...], MyClass.gimmie(self))


class _MySubclass2(MyClass):
    def gimmie(self) -> int:
        return cast(int, MyClass.gimmie(self))


@overload
def myclass(param1: Tuple[str, ...], param2: Literal[True]) -> _MySubclass1:
    ...


@overload
def myclass(param1: Tuple[str, ...], param2: Literal[False]) -> _MySubclass2:
    ...


def myclass(param1: Tuple[str, ...], param2: bool) -> MyClass:
    if param2:
        return _MySubclass1(param1, param2)
    else:
        return _MySubclass2(param1, param2)


myobj1 = myclass((), True)
myobj2 = myclass((), False)
reveal_type(myobj1.gimmie())  # Revealed type is "builtins.tuple[builtins.str]"
reveal_type(myobj2.gimmie())  # Revealed type is "builtins.int"

请注意，这是一项大量工作，需要特别注意以确保 casts 与实现逻辑相匹配——我不知道您要解决的实际问题，但不得不去通过这么多的麻烦来正确排列打字通常是您建模数据的方式中的一种“气味”。