Введите аннотации для * args и ** kwargs

Я пытаюсь использовать аннотации типа Python с абстрактными базовыми классами для написания некоторых интерфейсов. Есть ли способ аннотировать возможные типы *args и **kwargs?

Например, как я могу выразить, что разумные аргументы функции являются либо int, либо двумя int s? type(args) дает Tuple, поэтому я предполагал, что аннотировать этот тип как 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 doesn't like this
print(foo(1))
print(foo(1, 2))

Сообщения об ошибках от mypy:

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]]"

Имеет смысл, что mypy не нравится это для вызова функции, потому что он ожидает, что в самом вызове будет Tuple. Добавление после распаковки также дает ошибку ввода, которую я не понимаю.

Как аннотировать понятные типы для *args и **kwargs?

Ответ 1

Для переменных позиционных аргументов (*args) и переменных ключевых слов (**kw) вам нужно только указать ожидаемое значение для одного такого аргумента.

Из Списки произвольных аргументов и значения аргументов по умолчанию в типе 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 или более и не может быть ограничено подсказками типа для более конкретного диапазона.

Ответ 2

В качестве краткого дополнения к предыдущему ответу, если вы пытаетесь использовать mypy на файлах Python 2 и вам нужно использовать комментарии для добавления типов вместо аннотаций, вам необходимо префикс типов для 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

Ответ 3

Правильный способ сделать это - @overload

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 или добавляете аннотации к фактической реализации, которая должна быть последней.

Вам понадобится новая версия typing и mypy, чтобы получить поддержку @overload вне файлов-заглушек.

Вы также можете использовать это, чтобы изменить возвращаемый результат таким образом, чтобы явные типы аргументов соответствовали типу возвращаемого типа. например:.

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))