Question

我具有以下功能：

#!/usr/bin/env python3
from typing import Union

def foo(b: Union[str, int]) -> int:
    def bar(a: int = b) -> int: # Incompatible default for argument "a" (default has type "Union[str, int]", argument has type "int")
        return a + 1

    if isinstance(b, str):
        return bar(0)
    else:
        return bar()

print(foo(3)) # 4
print(foo("hello")) # 1

在我定义bar的那一行中，Mypy说将b设置为默认值是行不通的。

但是，由于程序的工作方式，使用默认b的唯一方法是b是整数。因此，这应该可以正常工作。

但是Mypy没有意识到这一点。

我怎么

让Mypy认识到int是a的正确类型或
修复此问题，不会导致过多的代码重复。

（例如，我知道我可以编写两个具有不同签名的foo函数，但这将导致过多的代码重复。）

下面的TL; DR只是我的实际用例，因为至少有一个答案取决于上面的我的MCVE多么简单。

这是一个需要字典的函数。该函数返回一个修饰符，该修饰符在使用时会将修饰后的函数（修饰后的函数为TypeChecker）添加到字典中。装饰器允许使用一个参数，该参数指定装饰函数（TypeChecker）在字典中的名称/键。如果未指定名称，则它将使用其他函数（StringHelper.str_function）从函数本身的属性中找出名称。

由于装饰器参数的工作方式，装饰器创建者需要使用名称（或不输入）或函数。如果仅接受函数，则未指定名称，并且应从函数中获取名称。如果仅使用名称，则将在函数上再次调用它，并应使用名称。如果什么都不做，那么它将在函数上再次被调用，并且应该从函数中获取一个名称。

def get_type_checker_decorator(type_checkers: Dict[str, TypeChecker]) -> Callable[[Union[Optional[str], TypeChecker]], Union[Callable[[TypeChecker], TypeChecker], TypeChecker]]:
    @overload
    def type_checker_decorator(name: Optional[str]) -> Callable[[TypeChecker], TypeChecker]:
        pass
    @overload
    def type_checker_decorator(name: TypeChecker) -> TypeChecker:
        pass
    def type_checker_decorator(name: Union[Optional[str], TypeChecker] = None) -> Union[Callable[[TypeChecker], TypeChecker], TypeChecker]:
        # if name is a function, then the default will never be used
        def inner_decorator(function: TypeChecker, name: Optional[str] = name) -> TypeChecker: # this gives the Mypy error
            if name is None:
                name = StringHelper.str_function(function)
            type_checkers[name] = function
            def wrapper(string: str) -> bool:
                return function(string)
            return wrapper

        if callable(name):
            # they just gave us the function right away without a name
            function = name
            name = None
            return inner_decorator(function, name)
        else:
            assert isinstance(name, str) or name is None
            # should be called with just the function as a parameter
            # the name will default to the given name (which may be None)
            return inner_decorator

    return type_checker_decorator

Answer 1

如果不是函数真正期望的那样，强制类型签名会很尴尬。您的bar函数显然需要一个int，并在类型提示上强行使用Union只是为了以后断言您实际上只接受int才是不必要的使mypy静音。

由于您接受b作为bar中的默认设置，因此您应该注意str内部的bar情况，因为b的类型签名已经已在foo中指定。我认为较适合当前问题的两种替代解决方案：

def foo(b: Union[str, int]) -> int:

    # bar takes care of the str case. Type of b already documented
    def bar(a=b) -> int:
        if isinstance(b, str):
            return bar(0)
        return a + 1

    return bar()

在定义bar之前定义默认值：

def foo(b: Union[str, int]) -> int:

    x: int = 0 if isinstance(b, str) else b

    # bar does not take a default type it won't use.
    def bar(a: int = x) -> int:
        return a + 1

    return bar()

Answer 2

在写这个问题时，我想我自己回答了，所以我不妨分享一下。

该解决方案有点尴尬，但这是我能想到的最好的解决方案，而且似乎可行。首先，将a输入为整数或字符串。然后，作为函数的第一行，断言a是int。

看起来像

#!/usr/bin/env python3
from typing import Union

def foo(b: Union[str, int]) -> int:
    def bar(a: Union[int, str] = b) -> int: # Incompatible default for argument "a" (default has type "Union[str, int]", argument has type "int")
        assert isinstance(a, int)
        return a + 1

    if isinstance(b, str):
        return bar(0)
    else:
        return bar()

print(foo(3)) # 4
print(foo("hello")) # 1

但是，此解决方案并不是完美的，因为如果您遵循函数签名并将其传递给字符串，它将失败（由于assert）。因此，需要对函数本身进行一些自省，以确定可以实际传递的内容。

Answer 3

该默认值甚至不应该存在。编写此代码的安全方法是

def foo(b: Union[str, int]) -> int:
    def bar(a) -> int:
        return a + 1

    if isinstance(b, str):
        return bar(0)
    else:
        return bar(b)

我不知道是什么情况促使您提出这个问题，但是无论您真正想编写什么程序，您也都不应具有默认参数值。

您的代码与尝试执行非常相似

def f(x: Union[int, str]) -> int:
    y: int = x
    if isinstance(x, str):
        return 1
    else:
        return y + 1

这样写，显然y是错误的。除非我们在赋值点实际上知道它是整数，否则我们不应该向静态类型int的变量赋值。期望类型检查器检查所有可能导致使用y来确定这是安全的代码路径是不合理的。默认参数值类型检查遵循类似的原则；会根据设置默认值时可用的信息进行检查，而不是根据可能使用的代码路径进行检查。

举一个更极端的例子，请考虑

def f(x: Union[int, str]) -> int:
    def g(y: int = x):
        pass
    return 4

y将从不使用。类型检查器仍会报告类型不匹配，如果类型检查器未报告类型不匹配，则会有错误报告。

如何让Mypy意识到在某些情况下不会使用默认值

3 个答案: