Някои убедителни причини, поради които може да има смисъл да се предоставят типове аргументи в Python
Аргументи за въвеждане
В сравнение с много други езици за програмиране, когато пишете функция в Python, наистина изобщо не е необходимо да вземате предвид типовете. Разбира се, типовете все още се разглеждат за всички извиквания на функции или извиквания на свойства, които се правят в тялото на функцията, но независимо от това е доста лесно да се мисли за тези неща, без да е необходимо да се поставят в кода. Например, следната функция, която просто отпечатва стойност:
def printer(x):
print(x)
Можем да извикаме печат на всеки тип данни, така че тази функция ще работи с всеки тип данни. Наистина дори не е нужно да мислим какъв тип е предоставен изобщо. Ако искаме да уточним, че x трябва да бъде от определен тип, правим това с двоеточие, последвано от тип, например
def printer(x : int):
print(x)
Синтактично това няма да направи нищо с нашия код. По всякакъв начин по отношение на изпълнението, тези две функции ще направят точното нещо. Ако трябваше да предадем float или низ през тази функция, нямаше да получим грешка. Мисля, че Python със сигурност може да се възползва от Julian MethodError, за да бъда честен, защото макар че може да не се очаква многократно изпращане, със сигурност има много смисъл да се ограничават типовете. MethodErrors може просто да предложи много информация за предоставените аргументи и да направи нещата много по-лесни за проверка или „отгатване“ без документация.
Нещо, което харесвам в Джулия, за да не правя това сравнение твърде много, е, че грешките в метода на Джулия осигуряват контекст за това какво правите грешно. Python има само ArgumentErrors, което предполагам може да се счита за нещо подобно, но само си представете, ако имате нещо подобно
ArgumentError No method matching printer(x : int) closest candidates are printer(x : float)
Или може би просто искам Python да бъде Джулия, не знам.
И в двата случая ArgumentError е семантично различен от MethodError, въпреки че в тези случаи мисля, че името може да бъде сменено, тъй като и аргументът, и методът биха били фактори, които създават грешката.
Защо да въвеждате аргументи?
Сега, след като разгледахме как да въведете аргумент и установихме, че той наистина не прави много по отношение на това как езикът взаимодейства с данните, вероятно трябва да зададем въпроса защо. Искам да кажа, че ако задаването на тип за нашите аргументи не прави нищо, освен да заема бяло пространство, тогава защо изобщо трябва да си правим труда да отделяме време да въвеждаме тези неща?
Важно нещо, което трябва да имате предвид е, че повечето проекти ще бъдат прочетени от повече от един човек. В примера на функцията printer() по-горе има класове, които не могат да бъдат отпечатани от тази функция. Като се има предвид това, тези видове стойности, които се предоставят, вероятно ще доведат до объркваща грешка, когато друго извикване вътре във функцията се извиква с грешен тип. Освен това, ако не въвеждаме нашите аргументи и някой друг чете тази функция, наистина няма да е очевидно какъв тип очакваме, освен именуването на този аргумент и извикванията на функции, които се използват за него. Като се има предвид това, с някои типове, които биха могли да причинят много проблеми, като се има предвид, че не всички обекти на Python са включени в Python благодарение на конструкторите.
Друга причина да въведете вашите аргументи е, че това ще предостави документацията с тази информация. Python има много автоматизирани инструменти за документиране и повечето използват това. Едно от най-важните неща, които някой ще трябва да знае, за да използва функция, ще бъдат аргументите и какъв тип трябва да бъдат аргументите. Като се има предвид това, вероятно е много важно документацията да указва какви типове трябва да бъдат предоставени за кои аргументи.
Последната причина, поради която въвеждам аргументите си, е, че това прави функцията много по-метапрограмируема чрез декоратори на функции. Чудесен пример за това къде това влиза в действие е с модула за множество изпращания, който всъщност е доста страхотен модул. Ако искате да научите повече за този модул, всъщност написах цяла статия за него, така че ето връзката:
Нищо не ме прави по-щастлив от полиморфизма.
Заключителни мисли
От гледна точка на синтаксиса, смятам, че е странно, идвайки от други езици, че типът аргументи е грубо игнориран. Чувствам, че би било доста хубаво интерпретаторът на Python да взаимодейства малко повече с типовете аргументи, както се случва с модула за множествено изпращане, но мисля, че това е донякъде субективно, тъй като това се изразява от програмист на Julia. Като се има предвид това, независимо какво всъщност прави с вашия код на Python, мисля, че е добра идея да въведете аргументите на вашите функции.
Въвеждането на вашите аргументи предоставя много контекст на функция. Казвал съм тази фраза и преди, но сега ще я повторя, най-важните части на една функция са входът и изходът. Винаги, когато искам да разбия дадена функция, винаги отивам там - какво отнема, какво дава и след това как да стигнем от необходимото до това, което дава - концепцията е доста проста на пръв поглед. Чудесно е да имаме повече контекст за подобни неща, особено в случай, че споделяме този код с други. Това се отнася и за документацията, което е още по-голяма причина да въведете вашите аргументи. Благодаря ви, че ме прочетохте и се надявам, че сега с тази разработка функциите ви в крайна сметка получават известно подобрение!
