Geben Sie Anmerkungen für * args und ** kwargs ein

Ich probiere Pythons Typanmerkungen mit abstrakten Basisklassen aus, um einige Schnittstellen zu schreiben. Gibt es eine Möglichkeit, die möglichen Arten von *argsund mit Anmerkungen zu versehen **kwargs?

Wie würde man zum Beispiel ausdrücken, dass die sinnvollen Argumente für eine Funktion entweder ein intoder zwei ints sind? type(args)gibt Tupleso meine Vermutung , die Art , wie mit Anmerkungen versehen war Union[Tuple[int, int], Tuple[int]]nicht, aber das funktioniert nicht.

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

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

Es ist sinnvoll, dass mypy dies für den Funktionsaufruf nicht mag, da erwartet wird, dass tupleim Aufruf selbst ein a vorhanden ist. Das Hinzufügen nach dem Auspacken führt auch zu einem Tippfehler, den ich nicht verstehe.

Wie kommentiert man die sinnvollen Typen für *argsund **kwargs?

Für variable Positionsargumente ( *args) und variable Schlüsselwortargumente ( **kw) müssen Sie nur den erwarteten Wert für ein solches Argument angeben .

Aus dem Abschnitt Beliebige Argumentlisten und Standardargumentwerte des Typhinweises PEP:

Beliebige Argumentlisten können ebenfalls mit Typanmerkungen versehen werden, so dass die Definition:

def foo(*args: str, **kwds: int): ...

ist akzeptabel und bedeutet, dass z. B. alle folgenden Funktionen Funktionsaufrufe mit gültigen Argumenttypen darstellen:

foo('a', 'b', 'c')
foo(x=1, y=2)
foo('', z=0)

Sie möchten Ihre Methode also folgendermaßen angeben:

def foo(*args: int):

Wenn Ihre Funktion jedoch nur einen oder zwei ganzzahlige Werte akzeptieren kann, sollten Sie keinesfalls *argsein explizites Positionsargument und ein zweites Schlüsselwortargument verwenden:

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

Jetzt ist Ihre Funktion tatsächlich auf ein oder zwei Argumente beschränkt, und beide müssen Ganzzahlen sein, falls angegeben. bedeutet *args immer 0 oder mehr und kann nicht durch Typhinweise auf einen spezifischeren Bereich beschränkt werden.

Der richtige Weg, dies zu tun, ist die Verwendung von @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))

Beachten Sie, dass Sie @overloadder tatsächlichen Implementierung keine Anmerkungen hinzufügen oder eingeben, die zuletzt erfolgen müssen.

Sie benötigen eine neue Version von beiden typingund mypy, um Unterstützung für @overload außerhalb von Stub-Dateien zu erhalten .

Sie können dies auch verwenden, um das zurückgegebene Ergebnis so zu variieren, dass explizit angegeben wird, welche Argumenttypen welchem ​​Rückgabetyp entsprechen. z.B:

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

Als kurz neben der vorherigen Antwort, wenn Sie versuchen , mypy auf Python 2 - Dateien und verwenden müssen , um Kommentare zu verwenden Typen anstelle von Anmerkungen hinzufügen möchten , müssen Sie die Typen für Präfix argsund kwargsmit *und **jeweils:

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

Dies wird von mypy als dasselbe behandelt wie die folgende Python 3.5-Version von foo:

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