Question

有一个函数（ f ）消耗了一个已知的函数签名（ g ）第一组参数和任意数量的关键字参数**kwargs。是否有办法将**kwargs包含在（ f ）中描述的（ g ）的类型签名中）？

例如：

from typing import Callable, Any
from functools import wraps
import math


def comparator(f: Callable[[Any, Any], bool]) -> Callable[[str], bool]:
    @wraps(f)
    def wrapper(input_string: str, **kwargs) -> bool:
        a, b, *_ = input_string.split(" ")
        return f(eval(a), eval(b), **kwargs)

    return wrapper


@comparator
def equal(a, b):
    return a == b


@comparator
def equal_within(a, b, rel_tol=1e-09, abs_tol=0.0):
    return math.isclose(a, b, rel_tol=rel_tol, abs_tol=abs_tol)


# All following statements should print `True`
print(equal("1 1") == True)
print(equal("1 2") == False)
print(equal_within("5.0 4.99998", rel_tol=1e-5) == True)
print(equal_within("5.0 4.99998") == False)

函数comparator用f包装其参数wrapper，该函数将f的输入作为字符串使用，对其进行解析并使用f对其求值。在这种情况下，Pycharm发出警告，return f(eval(a), eval(b), **kwargs)用意外的参数f调用**kwargs，该参数与预期的签名不匹配。

This post on Reddit建议将Any或...添加到f的类型签名中，例如

f: Callable[[Any, Any, ...], bool]
f: Callable[[Any, Any, Any], bool]

前者会导致TypeError [1]，而后者会引起误解，因为f至少接受 2个参数，而不是3。

另一种解决方法是使Callable的args定义像...一样用f: Callable[..., bool]打开，但是我想知道是否有更合适的解决方案。

TypeError: Callable[[arg, ...], result]: each arg must be a type. Got Ellipsis.

Answer 1

tl; dr：Protocol可能是已实现的最接近的功能，但仍不足以满足您的需求。有关详细信息，请参见this issue。

完整答案：

我认为与您要求的功能最接近的功能是Protocol，它是Python 3.7中引入的（并通过typing_extensions反向移植到3.6）。它允许您定义一个描述该类型的行为的Protocol子类，非常类似于其他语言中的“接口”或“特征”。对于函数，支持类似的语法：

from typing import Protocol
# from typing_extensions import Protocol  # if you're using Python 3.6

class MyFunction(Protocol):
    def __call__(self, a: Any, b: Any, **kwargs) -> bool: ...

def decorator(func: MyFunction):
    ...

@decorator  # this type-checks
def my_function(a, b, **kwargs) -> bool:
    return a == b

在这种情况下，具有匹配签名的任何函数都可以匹配MyFunction类型。

但是，这不足以满足您的要求。为了使函数签名匹配，函数必须能够接受任意数量的关键字参数（即，具有**kwargs参数）。到目前为止，仍然没有办法指定该函数可以（可选）采用任何关键字参数。 This GitHub issue讨论了当前限制下的一些可能的解决方案（尽管冗长或复杂）。

就目前而言，我建议仅使用Callable[..., bool]作为f的类型注释。不过，可以使用Protocol来优化包装器的返回类型：

class ReturnFunc(Protocol):
    def __call__(self, s: str, **kwargs) -> bool: ...

def comparator(f: Callable[..., bool]) -> ReturnFunc:
    ....

这消除了equal_within("5.0 4.99998", rel_tol=1e-5)处的“意外关键字参数”错误。

Answer 2

使用 Python 3.10 中的 PEP 612，您可以尝试以下解决方案：

from typing import Callable, Any, ParamSpec, Concatenate
from functools import wraps

P = ParamSpec("P")


def comparator(f: Callable[Concatenate[Any, Any, P], bool]) -> Callable[Concatenate[str, P], bool]:
    @wraps(f)
    def wrapper(input_string: str, *args: P.args, **kwargs: P.kwargs) -> bool:
        a, b, *_ = input_string.split(" ")
        return f(eval(a), eval(b), *args, **kwargs)

    return wrapper

但是，您似乎无法摆脱 *args: P.args（您实际上不需要），因为 PEP 612 要求将 P.args 和 P.kwargs 一起使用。如果您可以确保您的修饰函数（例如 equal 和 equal_within）不接受额外的位置参数，则类型检查器应拒绝任何使用额外位置参数调用函数的尝试。

带有** kwargs的Callable的类型注释

2 个答案: