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

159

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

Например, как можно выразить, что разумными аргументами функции являются intили два или два int? 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в вызове будет a . Добавление после распаковки также дает ошибку при печати, которую я не понимаю.

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

Praxeolitic
источник

Ответы:

168

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

Из Списков произвольных аргументов и раздела значений аргументов по умолчанию в PEP Type Hints :

Списки произвольных аргументов также могут быть аннотированы типом, так что определение:

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

Мартейн Питерс
источник
1
Просто любопытно, зачем добавлять Optional? Что-то изменилось в Python или ты передумал? Это все еще не является строго необходимым из-за Noneдефолта?
Праксеолит
10
@Praxeolitic Да, на практике автоматическая, подразумеваемая Optionalаннотация при использовании Noneв качестве значения по умолчанию усложняла некоторые варианты использования, и теперь она удаляется из PEP.
Мартин Питерс
5
Вот ссылка, обсуждающая это для интересующихся. Это, безусловно, звучит так, будто Optionalв будущем потребуется явное .
Рик поддерживает Монику
Это на самом деле не поддерживается для Callable: github.com/python/mypy/issues/5876
Shital Shah
1
@ShitalShah: это не совсем то, о чем эта проблема. Callableне поддерживает какие - либо упоминания о типа намек на *argsили **kwargs полной остановки . Эта конкретная проблема связана с разметкой вызываемых элементов, которые принимают конкретные аргументы плюс произвольное число других , и, таким образом, используют *args: Any, **kwargs: Anyочень специфическую подсказку типа для двух универсальных элементов. Для случаев, когда вы устанавливаете *argsи / или **kwargsчто-то более конкретное, вы можете использовать Protocol.
Мартин Питерс
26

Правильный способ сделать это с помощью @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))
chadrik
источник
2
Мне нравится этот ответ, потому что он касается более общего случая. Оглядываясь назад, я не должен был использовать (type1)против (type1, type1)вызовов функций , как мой пример. Может быть, (type1)vs (type2, type1)был бы лучшим примером и показывает, почему мне нравится этот ответ. Это также позволяет разные типы возврата. Однако в особом случае, когда у вас есть только один возвращаемый тип и ваш *argsи *kwargsвсе они одного типа, методика ответа Мартжина имеет больше смысла, поэтому оба ответа полезны.
Праксеолит
4
Однако использование *argsтам, где есть максимальное количество аргументов (2 здесь), все еще неправильно .
Мартин Питерс
1
@MartijnPieters Почему здесь *argsобязательно что-то не так? Если ожидаемые вызовы были (type1)vs (type2, type1), то число аргументов является переменным, и нет подходящего значения по умолчанию для конечного аргумента. Почему так важно, чтобы был максимум?
Праксеолит
1
*argsдействительно существует для нуля или более , неограниченных, однородных аргументов или для «передачи их нетронутым» всеобъемлющим. У вас есть один обязательный аргумент и один необязательный. Это совершенно другое и обычно обрабатывается, давая второму аргументу значение по умолчанию для дозорного, чтобы определить, что было опущено.
Мартин Питерс
3
Посмотрев на PEP, это явно не предназначенное использование @overload. Хотя этот ответ демонстрирует интересный способ индивидуальной аннотации типов *args, еще лучший ответ на вопрос заключается в том, что это совсем не то, что следует делать.
Праксеолит
20

В качестве краткого дополнения к предыдущему ответу, если вы пытаетесь использовать 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
Michael0x2a
источник