Python Language
Skriv tips

Syntax

• att skriva.Kallabar [[int, str], Ingen] -> def func (a: int, b: str) -> Ingen
• att skriva.Mappning av [str, int] -> {"a": 1, "b": 2, "c": 3}
• att skriva.Lista [int] -> [1, 2, 3]
• att skriva.Set [int] -> {1, 2, 3}
• att skriva. Valfritt [int] -> Inget eller int
• att skriva.Sekvens [int] -> [1, 2, 3] eller (1, 2, 3)
• att skriva.Any -> Vilken typ som helst
• att skriva.Union [int, str] -> 1 eller "1"
• T = typ.TypeVar ('T') -> Generisk typ

Anmärkningar

Generiska typer

typing.TypeVar är en generisk fabrik. Det huvudsakliga målet är att fungera som en parameter / platshållare för generiska funktion / klass / metodanteckningar:

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]

Lägga till typer till en funktion

Låt oss ta ett exempel på en funktion som får två argument och returnerar ett värde som anger deras summa:

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

Genom att titta på den här koden kan man inte säkert och utan tvekan ange typen av argument för funktion two_sum . Det fungerar båda när det levereras med int värden:

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

och med strängar:

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

och med andra värden, såsom list s, tuple s et cetera.

På grund av denna dynamiska karaktär av pytontyper, där många är tillämpliga för en given operation, skulle alla typkontroller inte kunna rimligt säga om ett samtal för denna funktion ska tillåtas eller inte.

För att hjälpa vår typkontroll kan vi nu tillhandahålla typtips för den i funktionsdefinitionen som anger vilken typ vi tillåter.

För att indikera att vi bara vill tillåta int typer kan vi ändra vår funktionsdefinition så att den ser ut:

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

Anteckningar följer argumentets namn och separeras med ett : -tecken.

På samma sätt, för att ange endast str typer är tillåtna, skulle vi ändra vår funktion för att ange den:

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

Förutom att ange typen av argument kan man också ange returvärdet för ett funktionssamtal. Detta görs genom att lägga till tecknet -> följt av typen efter den avslutande parentesen i argumentlistan men före : i slutet av funktionsdeklarationen:

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

Nu har vi angett att returvärdet när du ringer two_sum borde vara av typen int . På liknande sätt kan vi definiera lämpliga värden för str , float , list , set och andra.

Även om typtips oftast används av typkontroller och IDE: er, kan du ibland behöva hämta dem. Detta kan göras med hjälp av specialattributet __annotations__ :

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

Klassmedlemmar och metoder

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

Framåtreferens av den aktuella klassen behövs eftersom anteckningar utvärderas när funktionen definieras. Framåtreferenser kan också användas när man hänvisar till en klass som kan orsaka en cirkulär import om den importeras.

Variabler och attribut

Variabler kommenteras med hjälp av kommentarer:

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

Skapa en namedtuple med typ tips sker med funktions NamedTuple från typing

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

Observera att namnet på den resulterande typen är det första argumentet till funktionen, men det bör tilldelas en variabel med samma namn för att underlätta arbetet med typkontroller.

Skriv tips för sökordsargument

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

Notera mellanrummen runt lika tecknet i motsats till hur sökordsargument vanligtvis utformas.