我正在尝试使用Python的类型注释和抽象基类来编写一些接口。是否有一种方法来注释*args和**kwargs的可能类型?

例如,如何表达一个函数的合理参数是一个整型或两个整型?type(args)给出元组,所以我的猜测是将类型注释为Union[Tuple[int, int], Tuple[int]],但这行不通。

from typing import Union, Tuple

def foo(*args: Union[Tuple[int, int], Tuple[int]]):
    try:
        i, j = args
        return i + j
    except ValueError:
        assert len(args) == 1
        i = args[0]
        return i

# ok
print(foo((1,)))
print(foo((1, 2)))
# mypy does not like this
print(foo(1))
print(foo(1, 2))

来自myypy的错误消息:

t.py: note: In function "foo":
t.py:6: error: Unsupported operand types for + ("tuple" and "Union[Tuple[int, int], Tuple[int]]")
t.py: note: At top level:
t.py:12: error: Argument 1 to "foo" has incompatible type "int"; expected "Union[Tuple[int, int], Tuple[int]]"
t.py:14: error: Argument 1 to "foo" has incompatible type "int"; expected "Union[Tuple[int, int], Tuple[int]]"
t.py:15: error: Argument 1 to "foo" has incompatible type "int"; expected "Union[Tuple[int, int], Tuple[int]]"
t.py:15: error: Argument 2 to "foo" has incompatible type "int"; expected "Union[Tuple[int, int], Tuple[int]]"

myypy不喜欢这个函数调用是有道理的,因为它期望在调用本身中有一个元组。unpacking后的添加也给出了一个我不理解的输入错误。

如何注释*args和**kwargs的敏感类型?


当前回答

在不改变函数签名的情况下,最简单的方法是使用@overload

首先,一些背景知识。你不能把*args的类型作为一个整体来标注,只能标注args中各项的类型。所以你不能说*args是元组[int, int],你只能说*args中的每一项的类型是int。这意味着你不能限制*args的长度,也不能为每一项使用不同的类型。

为了解决这个问题,你可以考虑改变函数的签名,给它命名参数,每个参数都有自己的类型注释,但如果想(或需要)让你的函数使用*args,你可以使用@overload让mypy工作:

from typing import overload

@overload
def foo(arg1: int, arg2: int) -> int:
    ...

@overload
def foo(arg: int) -> int:
    ...

def foo(*args):
    try:
        i, j = args
        return i + j
    except ValueError:
        assert len(args) == 1
        i = args[0]
        return i

print(foo(1))
print(foo(1, 2))

注意,您没有向实际实现添加@overload或type注释,它们必须放在最后。

您还可以使用它来改变返回的结果,使哪个参数类型与哪个返回类型相对应。例如:

from typing import Tuple, overload

@overload
def foo(arg1: int, arg2: int) -> Tuple[int, int]:
    ...

@overload
def foo(arg: int) -> int:
    ...

def foo(*args):
    try:
        i, j = args
        return j, i
    except ValueError:
        assert len(args) == 1
        i = args[0]
        return i

print(foo(1))
print(foo(1, 2))

其他回答

作为前面答案的简短补充,如果你试图在Python 2文件上使用mypy,并且需要使用注释而不是注释来添加类型,你需要分别在args和kwargs的类型前面加上*和**:

def foo(param, *args, **kwargs):
    # type: (bool, *str, **int) -> None
    pass

这被mypy视为与下面相同,Python 3.5版本的foo:

def foo(param: bool, *args: str, **kwargs: int) -> None:
    pass

对于可变位置参数(*args)和可变关键字参数(**kw),您只需要为一个这样的参数指定期望的值。

从Type Hints PEP的任意参数列表和默认参数值部分:

任意参数列表也可以被类型注释,这样定义: Def foo(*args: str, **kwds: int):… 是可接受的,这意味着,例如,所有以下表示函数调用与有效类型的参数: Foo ('a', 'b', 'c') foo (x = 1, y = 2) foo(“z = 0)

所以你要像这样指定你的方法:

def foo(*args: int):

然而,如果你的函数只能接受一个或两个整数值,你就不应该使用*args,使用一个显式的位置参数和第二个关键字参数:

def foo(first: int, second: Optional[int] = None):

现在,函数实际上被限制为一个或两个参数,如果指定的话,两个参数都必须是整数。*args总是表示0或更多,并且不能被类型提示限制到更具体的范围。

在不改变函数签名的情况下,最简单的方法是使用@overload

首先,一些背景知识。你不能把*args的类型作为一个整体来标注,只能标注args中各项的类型。所以你不能说*args是元组[int, int],你只能说*args中的每一项的类型是int。这意味着你不能限制*args的长度,也不能为每一项使用不同的类型。

为了解决这个问题,你可以考虑改变函数的签名,给它命名参数,每个参数都有自己的类型注释,但如果想(或需要)让你的函数使用*args,你可以使用@overload让mypy工作:

from typing import overload

@overload
def foo(arg1: int, arg2: int) -> int:
    ...

@overload
def foo(arg: int) -> int:
    ...

def foo(*args):
    try:
        i, j = args
        return i + j
    except ValueError:
        assert len(args) == 1
        i = args[0]
        return i

print(foo(1))
print(foo(1, 2))

注意,您没有向实际实现添加@overload或type注释,它们必须放在最后。

您还可以使用它来改变返回的结果,使哪个参数类型与哪个返回类型相对应。例如:

from typing import Tuple, overload

@overload
def foo(arg1: int, arg2: int) -> Tuple[int, int]:
    ...

@overload
def foo(arg: int) -> int:
    ...

def foo(*args):
    try:
        i, j = args
        return j, i
    except ValueError:
        assert len(args) == 1
        i = args[0]
        return i

print(foo(1))
print(foo(1, 2))

在某些情况下,** warg的内容可以是多种类型。

这似乎对我很管用:

from typing import Any

def testfunc(**kwargs: Any) -> None:
    print(kwargs)

or

from typing import Any, Optional

def testfunc(**kwargs: Optional[Any]) -> None:
    print(kwargs)

如果您觉得需要在**kwargs中约束类型,我建议创建一个类似结构的对象并在那里添加类型。这可以通过数据类或pydantic来实现。

from dataclasses import dataclass

@dataclass
class MyTypedKwargs:
   expected_variable: str
   other_expected_variable: int


def testfunc(expectedargs: MyTypedKwargs) -> None:
    pass

如果想描述kwargs中所期望的特定命名参数,则可以传入TypedDict(它定义了必需的和可选的参数)。可选参数是kwarg是什么。 注意:TypedDict在python >= 3.8中 请看这个例子:

import typing

class RequiredProps(typing.TypedDict):
    # all of these must be present
    a: int
    b: str

class OptionalProps(typing.TypedDict, total=False):
    # these can be included or they can be omitted
    c: int
    d: int

class ReqAndOptional(RequiredProps, OptionalProps):
    pass

def hi(req_and_optional: ReqAndOptional):
    print(req_and_optional)