Fungsi Anotasi dalam Python

Saya baru-baru ini menyiarkan blog tentang fungsi Anotasi dalam Typescript. Saya baru sahaja selesai membuat sedikit kajian dan memahami lebih lanjut tentang cara menganotasi fungsi dalam Python dan blog ini akan menjadi semua tentang menganotasi fungsi Python dengan contoh yang serupa dengan blog terakhir.

Anda boleh mengesahkan anotasi jenis anda dalam Visual Studio Code dengan menetapkan python.analysis.typeCheckingMode kepada salah satu asas, standard, ketat,. pilihan asas dan standard tidak semestinya memastikan anda menganotasi fungsi dan pembolehubah anda tetapi ketat melakukannya.

Nilai Fungsi

Ini mungkin mengejutkan anda tetapi anda boleh mengembalikan fungsi dan menghantar fungsi sebagai nilai dalam Python. Fungsi panggil balik sebenarnya diberi anotasi menggunakan jenis Boleh Panggil yang ditulis seperti ini;

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

Sebagai contoh, panjang fungsi(teks: str) -> int akan diberi anotasi sebagai Boleh Dipanggil[[str], int]

Contohnya;

Fungsi ini dalam JavaScript

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

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

boleh ditulis seperti ini dalam Python

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

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

Kita boleh mencipta nombor TypeAlias ​​yang dipanggil iaitu Kesatuan (secara literal) bagi kedua-dua int dan apungan seperti;

from typing import TypeAlias, Union

number: TypeAlias = Union[int, float]

Untuk mendekati parameter sebagai nombor JavaScript.

Oleh itu, untuk menganotasi fungsi ini, kami ada;

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

Fungsi generik

Contoh fungsi generik klasik ialah

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

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

Menggunakan TypeVar kini kita boleh mencipta kata kerja generik (lebih bertele-tele daripada skrip taip).

from typing import TypeVar

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

supaya kita mempunyai

from typing import TypeVar, Sequence

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

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

Jadi bagaimana pula dengan fungsi myMap tersuai yang bertindak seperti peta dalam JavaScript. yang kita ada;

Ingat: map() dalam Python mengembalikan jenis Iterable bukan jenis Senarai

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

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

Kami boleh menggunakan campuran jenis Boleh Panggil dan TypeVar untuk menganotasi fungsi ini. Perhatikan...

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

atau kita boleh alias fungsi Boleh Panggil

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)

Perhatikan bahawa MappableFunction mengambil Input dan Output jenis generik tersebut dan menggunakannya pada konteks Callable[[Input], Output].

Luangkan sedikit masa untuk memikirkan bagaimana fungsi myFilter akan diberi anotasi?

Baiklah jika anda memikirkan perkara ini

from typing import Iterable, TypeVar, Callable

Input = TypeVar("Input")

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

Anda betul

Kelas Generik

Saya tahu saya tidak sepatutnya bercakap tentang anotasi kelas tetapi beri saya sedikit masa untuk menerangkan kelas generik.

Jika anda datang daripada Typescript-ayat, beginilah cara anda mentakrifkannya

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

Tetapi dalam Python ia agak berbeza dan janggal.

• Mula-mula kita mengimport jenis Generik, kemudian kita menjadikan mereka anak kelas Generik

Jadi untuk mencipta semula kelas GenericStore ini dalam Python

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

Mengapa saya perlu belajar cara menganotasi fungsi dalam Python?

Seperti yang telah saya katakan dalam blog dahulu, Ia membantu dalam membina sistem jenis yang lebih bijak yang seterusnya mengurangkan peluang pepijat anda (terutamanya apabila menggunakan penyemak fail statik seperti mypy). Juga apabila menulis perpustakaan (atau SDK) menggunakan sistem jenis yang mantap boleh meningkatkan produktiviti pembangun menggunakan perpustakaan dengan margin (kebanyakannya disebabkan cadangan editor)

Sekiranya anda mempunyai sebarang soalan atau terdapat kesilapan dalam penulisan ini, sila kongsikan di ruangan komen di bawah ⭐

Atas ialah kandungan terperinci Fungsi Anotasi dalam Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!