Аннотации типов для * args и ** kwargs

Question

Я пытаюсь аннотации типов 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 does not 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?

Answer 1

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

Из Arbitrary argument lists and default argument values section из Типа подсказка 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 или более и не может быть ограничен подсказками типа для более конкретного диапазона.

Answer 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 

Answer 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 outside of stub files.

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

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