Kommentieren von Funktionen in Python

Ich habe erst kürzlich einen Blog über das Kommentieren von Funktionen in Typescript gepostet. Ich habe gerade eine kleine Studie abgeschlossen und mehr darüber verstanden, wie man Funktionen in Python mit Anmerkungen versehen kann. In diesem Blog dreht sich alles um die Annotation von Python-Funktionen mit ähnlichen Beispielen wie im letzten Blog.

Sie können Ihre Typanmerkungen in Visual Studio Code validieren, indem Sie python.analysis.typeCheckingMode auf einen von „Basic“, „Standard“ oder „Strict“ festlegen. Bei einfachen und standardmäßigen Optionen wird nicht unbedingt sichergestellt, dass Sie Ihre Funktionen und Variablen mit Anmerkungen versehen, bei strikt ist dies jedoch der Fall.

Funktionswerte

Das könnte Sie schockieren, aber Sie können in Python Funktionen zurückgeben und Funktionen als Werte übergeben. Rückruffunktionen werden tatsächlich mit dem Callable-Typ annotiert, der wie folgt geschrieben ist:

Callable[[argtype1, argtype2, argtype3], returnType]

Zum Beispiel eine Funktion length(text: str) -> int wird als Callable[[str], int]

kommentiert

Zum Beispiel;

Diese Funktion in JavaScript

function multiplier(factor){
    return value => factor * value
}

const n = multiplier(6)
n(8) // 48

kann so in Python geschrieben werden

def multiplier(factor):
    def inner(value):
        return value * factor
    return inner     

n = multiplier(6)
n(8) #48

Wir können einen TypeAlias ​​namens number erstellen, der eine Union (im wahrsten Sinne des Wortes) sowohl eines int als auch eines float ist, wie;

from typing import TypeAlias, Union

number: TypeAlias = Union[int, float]

Zur Annäherung an die Parameter als JavaScript-Zahlen.

Also um diese Funktion zu kommentieren, haben wir:

def multiplier(factor: number) -> Callable[[number], number]:
    def inner(value: number) -> inner:
        return value * factor
    return inner

a = multiplier(4.5)
a(3) #13.5

Generische Funktionen

Das klassische generische Funktionsbeispiel ist

def pick(array, index):
    return array[index]

pick([1,2,3], 2) #3

Mit TypeVar können wir jetzt generische ausführliche Texte erstellen (ausführlicher als Typoskript).

from typing import TypeVar

T = TypeVar("T") # the argument and the name of the variable should be the same

damit wir
haben

from typing import TypeVar, Sequence

def pick(array: Sequence[T], index: int) -> T:
    return array[index]

print(pick([1,2,3,4], 2))

Wie wäre es also mit einer benutzerdefinierten myMap-Funktion, die sich wie eine Karte in JavaScript verhält? so dass wir;

Denken Sie daran: map() in Python gibt einen iterierbaren Typ und keinen Listentyp zurück

def myMap(array, fn):
    return map(fn, array)

def twice(n): return n * 2
print(myMap([1,2,3], twice))

Wir können eine Mischung aus Callable- und TypeVar-Typen verwenden, um diese Funktion mit Anmerkungen zu versehen. Beobachten...

from typing import TypeVar, Iterable, Callable

Input = TypeVar("Input")  # Input and "Input" must be the same
Output = TypeVar("Output")

def myMap(array: Iterable[Input], fn: Callable[[Input], Output]) -> Iterable[Output]:
    return map(fn, array)

def twice(n: int) -> int: return n * 2
print(myMap([1,2,3], twice))

oder wir können die Callable-Funktion aliasen

from typing import TypeVar, Iterable, Callable

Input = TypeVar("Input")
Output = TypeVar("Output")

MappableFunction = Callable[[Input], Output]

def myMap(array: Iterable[Input], fn: MappableFunction[Input, Output]) -> Iterable[Output]:
    return map(fn, array)

Beachten Sie, dass MappableFunction diese generischen Typen Input und Output übernimmt und sie auf den Kontext von Callable[[Input], Output] anwendet.

Nehmen Sie sich eine Minute Zeit, um darüber nachzudenken, wie die myFilter-Funktion mit Anmerkungen versehen wird?

Nun, wenn Sie daran gedacht haben

from typing import Iterable, TypeVar, Callable

Input = TypeVar("Input")

def myFilter(array: Iterable[Input], fn: Callable[[Input], bool]) -> Iterable[Input]:
    return filter(fn, array)

Du hast recht

Generische Klassen

Ich weiß, ich sollte nicht über Klassenanmerkungen sprechen, aber geben Sie mir etwas Zeit, um generische Klassen zu erklären.

Wenn Sie aus dem Typescript-Vers stammen würden, würden Sie sie so definieren

class GenericStore<Type>{
    stores: Array<Type> = []

    constructor(){
        this.stores = []
    }

    add(item: Type){
        this.stores.push(item)
    }
}

const g1 = new GenericStore<string>(); //g1.stores: Array<string>
g1.add("Hello") //only string are allowed

Aber in Python sind sie etwas anders und umständlich.

• Zuerst importieren wir den Generic-Typ, dann machen wir sie zum untergeordneten Element der Generic-Klasse

Um diese GenericStore-Klasse in Python neu zu erstellen

Callable[[argtype1, argtype2, argtype3], returnType]

Warum sollte ich lernen, Funktionen in Python mit Anmerkungen zu versehen?

Wie ich im vorherigen Blog bereits gesagt habe, hilft es beim Aufbau eines viel intelligenteren Typsystems, was wiederum das Risiko von Fehlern verringert (insbesondere bei der Verwendung statischer Dateiprüfer wie mypy). Auch beim Schreiben von Bibliotheken (oder SDKs) kann die Verwendung eines robusten Typsystems die Produktivität des Entwicklers, der die Bibliothek verwendet, deutlich steigern (hauptsächlich aufgrund von Editor-Vorschlägen)

Wenn Sie Fragen haben oder Fehler in diesem Text enthalten sind, teilen Sie diese gerne in den Kommentaren unten mit ⭐

Das obige ist der detaillierte Inhalt vonKommentieren von Funktionen in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!