Python Language
Typ Hinweise

Syntax

• typ.Callable [[int, str], Keine] -> def func (a: int, b: str) -> Keine
• typing.Mapping [str, int] -> {"a": 1, "b": 2, "c": 3}
• typing.List [int] -> [1, 2, 3]
• typing.Set [int] -> {1, 2, 3}
• Eingabe.Optional [int] -> Keine oder int
• typ..Sequence [int] -> [1, 2, 3] oder (1, 2, 3)
• Typ.Any -> Beliebiger Typ
• tippen.Union [int, str] -> 1 oder "1"
• T = typing.TypeVar ('T') -> Generischer Typ

Bemerkungen

Generische Typen

Die typing.TypeVar ist eine generische typing.TypeVar . Sein Hauptziel ist es, als Parameter / Platzhalter für generische Funktions- / Klassen- / Methodenanmerkungen zu dienen:

import typing

T = typing.TypeVar("T")

def get_first_element(l: typing.Sequence[T]) -> T:
    """Gets the first element of a sequence."""
    return l[0]

Hinzufügen von Typen zu einer Funktion

Nehmen wir ein Beispiel für eine Funktion, die zwei Argumente empfängt und einen Wert zurückgibt, der ihre Summe angibt:

def two_sum(a, b):
    return a + b

Wenn Sie sich diesen Code two_sum , können Sie nicht sicher und ohne Zweifel den Typ der Argumente für die Funktion two_sum . Es funktioniert beides, wenn es mit int Werten versorgt wird:

print(two_sum(2, 1))  # result: 3

und mit strings:

print(two_sum("a", "b"))  # result: "ab"

und mit anderen Werten, wie list s, tuple s et cetera.

Aufgrund dieser dynamischen Natur von Python-Typen, bei denen viele für eine bestimmte Operation anwendbar sind, kann ein Typprüfer nicht vernünftigerweise feststellen, ob ein Aufruf dieser Funktion zulässig ist oder nicht.

Zur Unterstützung unseres Typprüfers können wir jetzt in der Funktionsdefinition Typhinweise dazu angeben, die den zulässigen Typ angeben.

Um anzuzeigen, dass wir nur int Typen zulassen möchten, können wir unsere Funktionsdefinition folgendermaßen ändern:

def two_sum(a: int, b: int):
    return a + b

Anmerkungen folgen dem Argumentnamen und werden durch ein Zeichen : getrennt.

Um anzugeben, dass nur str Typen zulässig sind, ändern wir unsere Funktion, um sie anzugeben:

def two_sum(a: str, b: str): 
    return a + b

Neben der Angabe des Typs der Argumente könnte auch der Rückgabewert eines Funktionsaufrufs angegeben werden. Dazu fügen Sie das Zeichen -> gefolgt von dem Typ nach der schließenden Klammer in der Argumentliste, aber vor dem : am Ende der Funktionsdeklaration ein:

def two_sum(a: int, b: int) -> int: 
    return a + b

Nun haben wir angegeben, dass der Rückgabewert beim Aufruf von two_sum vom Typ int . Ähnlich können wir geeignete Werte für str , float , list , set und andere definieren.

Obwohl Typhinweise hauptsächlich von Typenprüfern und IDEs verwendet werden, müssen Sie sie manchmal abrufen. Dies kann mit dem Spezialattribut __annotations__ :

two_sum.__annotations__
# {'a': <class 'int'>, 'b': <class 'int'>, 'return': <class 'int'>}

Klassenmitglieder und Methoden

class A:
    x = None  # type: float
    def __init__(self, x: float) -> None:
        """
        self should not be annotated
        init should be annotated to return None
        """
        self.x = x
    
    @classmethod
    def from_int(cls, x: int) -> 'A': 
        """
        cls should not be annotated
        Use forward reference to refer to current class with string literal 'A'
        """
        return cls(float(x))

Die Vorwärtsreferenz der aktuellen Klasse ist erforderlich, da die Anmerkungen bei der Definition der Funktion ausgewertet werden. Weiterleitungsreferenzen können auch verwendet werden, wenn auf eine Klasse verwiesen wird, die beim Import einen zirkulären Import verursachen würde.

Variablen und Attribute

Variablen werden mit Kommentaren versehen:

x = 3  # type: int
x = negate(x)
x = 'a type-checker might catch this error'

x: int = 3

y: int

class Foo:
    x: int
    y: str = 'abc'

print(typing.get_type_hints(Foo))
# ChainMap({'x': <class 'int'>, 'y': <class 'str'>}, {})

x: int
print(__annotations__)
# {'x': <class 'int'>}

class C:
    s: str
print(C.__annotations__)
# {'s': <class 'str'>}

NamedTuple

Das Erstellen eines namedtuple mit Typhinweisen erfolgt mit der Funktion NamedTuple aus dem typing :

import typing
Point = typing.NamedTuple('Point', [('x', int), ('y', int)])

Beachten Sie, dass der Name des resultierenden Typs das erste Argument der Funktion ist. Sie sollte jedoch einer Variablen mit demselben Namen zugewiesen werden, um die Arbeit der Typprüfer zu erleichtern.

Geben Sie Hinweise für Schlüsselwortargumente ein

def hello_world(greeting: str = 'Hello'):
    print(greeting + ' world!')

Beachten Sie die Leerzeichen um das Gleichheitszeichen und nicht wie die Schlüsselwortargumente normalerweise gestaltet werden.