что такое динамическая типизация питон

Проверка типов данных и «утиная» типизация в Python

В этой статье мы вам расскажем о проверке типов, о различных типах данных в разных языках, а также о неявной типизации и подсказках.

В Python проверка типов выполняется в интерпретаторе. Так как Python — язык с динамической типизацией, он не заставляет пользователя принудительно указывать тип объектов. Это потенциально может привести к ошибкам, причем их будет трудно найти. Чтобы избежать этого, Python можно использовать вместе с другими инструментами и реализовывать проверки типов вместе с собственным алгоритмом неявной типизации.

Существует два метода типизации, за каждым из которых стоят определенные языки программирования:

Языки со статической типизацией

Проверка типа переменной выполняется во время компиляции. Кроме того, система типов языка заставляет явно объявлять «тип данных» переменной перед ее использованием.

Вот ряд языков программирования со статической типизацией: Scala, Java, C++ и так далее. Например, объявление переменной строкового типа в языке Scala выглядит следующим образом:

Языки с динамической типизацией

В этих языках проверка типа переменной выполняется во время выполнения. Кроме того, система типизации языка не требует явного объявления типа данных переменной перед ее использованием. К языкам программирования с динамической типизацией относятся Python, JavaScript, Ruby и так далее.

Например, переменная строкового типа в языке Python определяется следующим образом:

Здесь мы видим, что переменную myCar не нужно явно объявлять.

Функции type() и ‘isinstance() в Python

Приведенный выше код выдает в качестве результата ‘int’. Тип данных переменной my_var является целочисленным, и функция type() определяет его именно таким образом.

При помощи функции isinstance(‘ obj ‘,’ class ‘) в языке Python можно определить, является ли данный объект ( ‘obj’ ) экземпляром класса ( ‘class’ ). Возвращается булево значение ( True или False ).

Неявная («утиная») типизация в Python

В Python действует популярный принцип: «Если это выглядит как утка, плавает как утка и крякает как утка, то это, вероятно, и есть утка». Попросту говоря, тип объекта или класса не имеет значения, но объект должен содержать аналогичные методы и свойства, тогда объект может использоваться для определенной цели.
Давайте разберем это на конкретном примере.

Результат выполнения данного кода будет следующим:

Подсказки типов и модуль mypy

У динамически типизированных языков, таких как Python, есть свои мощные преимущества, но есть и некоторые недостатки. Одним из недостатков является возникновение ошибок выполнения (runtime error) когда Python не производит принудительного преобразования типов. В результате могут возникать баги, которые с увеличением длины кода становится все трудней найти.

Подсказки типов реализованы в Python начиная с версии 3.5. А более старые версии могут не поддерживать данный функционал.

Давайте посмотрим простой пример без подсказок типов и модуля mypy.

Данная функция предназначена для вычитания целочисленных значений. Она принимает на вход два целых числа и возвращает их разность.

mypy — это модуль Python, который помогает в проверке статических типов. Он использует собственную динамическую проверку Python или неявную («утиную») типизацию с подсказкой самого типа.

Для начала вам нужно установить сам модуль mypy:

Далее вам нужно создать файл с именем mypy_example.py на своем локальном компьютере и сохранить туда следующий код:

Это простая программа, которая принимает два целых числа в качестве входных данных в параметре, а после ‘->’ показывает тип возвращаемых данных, который также является целочисленным (‘int’). Но хотя функция должна возвращать целочисленное значение (int), возвращается строка ‘Subtracted two integers’.

Запустите указанный выше код в терминале следующим образом:

После этого будет показана ошибка, указывающая на несоответствие типов (должен быть ‘int», а выдается ‘str’).

Давайте теперь изменим тип возвращаемого значения. Заменим строковое значение на разницу двух целых чисел. Таким образом, будет возвращаться целочисленное значение.

Мы видим, что программа выполняется успешно, никаких проблем не обнаружено.

Поздравляем!

Источник

Ликбез по типизации в языках программирования

Эта статья содержит необходимый минимум тех вещей, которые просто необходимо знать о типизации, чтобы не называть динамическую типизацию злом, Lisp — бестиповым языком, а C — языком со строгой типизацией.

В полной версии находится подробное описание всех видов типизации, приправленное примерами кода, ссылками на популярные языки программирования и показательными картинками.

Рекомендую прочитать сначала краткую версию статьи, а затем при наличии желания и полную.

Краткая версия

Языки программирования по типизации принято делить на два больших лагеря — типизированные и нетипизированные (бестиповые). К первому например относятся C, Python, Scala, PHP и Lua, а ко второму — язык ассемблера, Forth и Brainfuck.

Так как «бестиповая типизация» по своей сути — проста как пробка, дальше она ни на какие другие виды не делится. А вот типизированные языки разделяются еще на несколько пересекающихся категорий:

Примеры:
Статическая: C, Java, C#;
Динамическая: Python, JavaScript, Ruby.

Примеры:
Сильная: Java, Python, Haskell, Lisp;
Слабая: C, JavaScript, Visual Basic, PHP.

Примеры:
Явная: C++, D, C#
Неявная: PHP, Lua, JavaScript

Также нужно заметить, что все эти категории пересекаются, например язык C имеет статическую слабую явную типизацию, а язык Python — динамическую сильную неявную.

Тем-не менее не бывает языков со статической и динамической типизаций одновременно. Хотя забегая вперед скажу, что тут я вру — они действительно существуют, но об этом позже.

Подробная версия

Если краткой версии Вам показалось недостаточно, хорошо. Не зря же я писал подробную? Главное, что в краткой версии просто невозможно было уместить всю полезную и интересную информацию, а подробная будет возможно слишком длинной, чтобы каждый смог ее прочесть, не напрягаясь.

Бестиповая типизация

В бестиповых языках программирования — все сущности считаются просто последовательностями бит, различной длины.

Бестиповая типизация обычно присуща низкоуровневым (язык ассемблера, Forth) и эзотерическим (Brainfuck, HQ9, Piet) языкам. Однако и у нее, наряду с недостатками, есть некоторые преимущества.

Преимущества

Недостатки

Сильная безтиповая типизация?

Да, такое существует. Например в языке ассемблера (для архитектуры х86/х86-64, других не знаю) нельзя ассемблировать программу, если вы попытаетесь загрузить в регистр cx (16 бит) данные из регистра rax (64 бита).

mov cx, eax ; ошибка времени ассемблирования

Так получается, что в ассемлере все-таки есть типизация? Я считаю, что этих проверок недостаточно. А Ваше мнение, конечно, зависит только от Вас.

Статическая и динамическая типизации

Главное, что отличает статическую (static) типизацию от динамической (dynamic) то, что все проверки типов выполняются на этапе компиляции, а не этапе выполнения.

Некоторым людям может показаться, что статическая типизация слишком ограничена (на самом деле так и есть, но от этого давно избавились с помощью некоторых методик). Некоторым же, что динамически типизированные языки — это игра с огнем, но какие же черты их выделяют? Неужели оба вида имеют шансы на существование? Если нет, то почему много как статически, так и динамически типизированных языков?

Преимущества статической типизации

Преимущества динамической типизации

Обобщенное программирование

Хорошо, самый важный аргумент за динамическую типизацию — удобство описания обобщенных алгоритмов. Давайте представим себе проблему — нам нужна функция поиска по нескольким массивам (или спискам) — по массиву целых чисел, по массиву вещественных и массиву символов.

Как же мы будем ее решать? Решим ее на 3-ех разных языках: одном с динамической типизацией и двух со статической.

Алгоритм поиска я возьму один из простейших — перебор. Функция будет получать искомый элемент, сам массив (или список) и возвращать индекс элемента, или, если элемент не найден — (-1).

Динамическое решение (Python):

Как видите, все просто и никаких проблем с тем, что список может содержать хоть числа, хоть списки, хоть другие массивы нет. Очень хорошо. Давайте пойдем дальше — решим эту-же задачу на Си!

Статическое решение (Си):

Ну, каждая функция в отдельности похожа на версию из Python, но почему их три? Неужели статическое программирование проиграло?

И да, и нет. Есть несколько методик программирования, одну из которых мы сейчас рассмотрим. Она называется обобщенное программирование и язык C++ ее неплохо поддерживает. Давайте посмотрим на новую версию:

Статическое решение (обобщенное программирование, C++):

Хорошо! Это выглядит не сильно сложнее чем версия на Python и при этом не пришлось много писать. Вдобавок мы получили реализацию для всех массивов, а не только для 3-ех, необходимых для решения задачи!

Эта версия похоже именно то, что нужно — мы получаем одновременно плюсы статической типизации и некоторые плюсы динамической.

Здорово, что это вообще возможно, но может быть еще лучше. Во-первых обобщенное программирование может быть удобнее и красивее (например в языке Haskell). Во-вторых помимо обобщенного программирования также можно применить полиморфизм (результат будет хуже), перегрузку функций (аналогично) или макросы.

Статика в динамике

Также нужно упомянуть, что многие статические языки позволяют использовать динамическую типизацию, например:

Сильная и слабая типизации

Языки с сильной типизацией не позволяют смешивать сущности разных типов в выражениях и не выполняют никаких автоматических преобразований. Также их называют «языки с строгой типизацией». Английский термин для этого — strong typing.

Слабо типизированные языки, наоборот всячески способствуют, чтобы программист смешивал разные типы в одном выражении, причем компилятор сам приведет все к единому типу. Также их называют «языки с нестрогой типизацией». Английский термин для этого — weak typing.

Слабую типизацию часто путают с динамической, что совершенно неверно. Динамически типизированный язык может быть и слабо и сильно типизирован.

Однако мало, кто придает значение строгости типизации. Часто заявляют, что если язык статически типизирован, то Вы сможете отловить множество потенциальных ошибок при компиляции. Они Вам врут!

Язык при этом должен иметь еще и сильную типизацию. И правда, если компилятор вместо сообщения об ошибке будет просто прибавлять строку к числу, или что еще хуже, вычтет из одного массива другой, какой нам толк, что все «проверки» типов будут на этапе компиляции? Правильно — слабая статическая типизация еще хуже, чем сильная динамическая! (Ну, это мое мнение)

Так что-же у слабой типизации вообще нет плюсов? Возможно так выглядит, однако несмотря на то, что я ярый сторонник сильной типизации, должен согласиться, что у слабой тоже есть преимущества.

Хотите узнать какие?

Преимущества сильной типизации

Преимущества слабой типизации

Оказывается есть и даже два.

Неявное приведение типов, в однозначных ситуациях и без потерь данных

Ух… Довольно длинный пункт. Давайте я буду дальше сокращать его до «ограниченное неявное преобразование» Так что же значит однозначная ситуация и потери данных?

Однозначная ситуация, это преобразование или операция в которой сущность сразу понятна. Вот например сложение двух чисел — однозначная ситуация. А преобразование числа в массив — нет (возможно создастся массив из одного элемента, возможно массив, с такой длинной, заполненный элементами по-умолчанию, а возможно число преобразуется в строку, а затем в массив символов).

Потеря данных это еще проще. Если мы преобразуем вещественное число 3.5 в целое — мы потеряем часть данных (на самом деле эта операция еще и неоднозначная — как будет производиться округление? В большую сторону? В меньшую? Отбрасывание дробной части?).

Преобразования в неоднозначных ситуациях и преобразования с потерей данных — это очень, очень плохо. Ничего хуже этого в программировании нет.

Если вы мне не верите, изучите язык PL/I или даже просто поищите его спецификацию. В нем есть правила преобразования между ВСЕМИ типами данных! Это просто ад!

Ладно, давайте вспомним про ограниченное неявное преобразование. Есть ли такие языки? Да, например в Pascal Вы можете преобразовать целое число в вещественное, но не наоборот. Также похожие механизмы есть в C#, Groovy и Common Lisp.

Ладно, я говорил, что есть еще способ получить пару плюсов слабой типизации в сильном языке. И да, он есть и называется полиморфизм конструкторов.

Я поясню его на примере замечательного языка Haskell.

Полиморфные конструкторы появились в результате наблюдения, что чаще всего безопасные неявные преобразования нужны при использовании числовых литералов.

И это сделано в Haskell, благодаря тому, что у литерала 1 нет конкретного типа. Это ни целое, ни вещественное, ни комплексное. Это же просто число!

Конечно спасает этот прием только при использовании смешанных выражений с числовыми литералами, а это лишь верхушка айсберга.

Таким образом можно сказать, что лучшим выходом будет балансирование на грани, между сильной и слабой типизацией. Но пока идеальный баланс не держит ни один язык, поэтому я больше склоняюсь к сильно типизированным языкам (таким как Haskell, Java, C#, Python), а не к слабо типизированным (таким как C, JavaScript, Lua, PHP).

Ладно, пойдем дальше?

Явная и неявная типизации

Язык с явной типизацией предполагает, что программист должен указывать типы всех переменных и функций, которые объявляет. Английский термин для этого — explicit typing.

Язык с неявной типизацией, напротив, предлагает Вам забыть о типах и переложить задачу вывода типов на компилятор или интерпретатор. Английски термин для этого — implicit typing.

По-началу можно решить, что неявная типизация равносильна динамической, а явная — статической, но дальше мы увидим, что это не так.

Есть ли плюсы у каждого вида, и опять же, есть ли их комбинации и есть ли языки с поддержкой обоих методов?

Преимущества явной типизации

Преимущества неявной типизации

Явная типизация по-выбору

Есть языки, с неявной типизацией по-умолчанию и возможностью указать тип значений при необходимости. Настоящий тип выражения транслятор выведет автоматически. Один из таких языков — Haskell, давайте я приведу простой пример, для наглядности:

* Спасибо int_index за нахождение ошибки.

Хм. Как мы видим, это очень красиво и коротко. Запись функции занимает всего 18 символов на одной строчке, включая пробелы!

Однако автоматический вывод типов довольно сложная вещь, и даже в таком крутом языке как Haskell, он иногда не справляется. (как пример можно привести ограничение мономорфизма)

Есть ли языки с явной типизацией по-умолчанию и неявной по-необходимости? Кон
ечно.

Неявная типизация по-выбору

В новом стандарте языка C++, названном C++11 (ранее назывался C++0x), было введено ключевое слово auto, благодаря которому можно заставить компилятор вывести тип, исходя из контекста:

Неплохо. Но запись сократилась не сильно. Давайте посмотрим пример с итераторами (если не понимаете, не бойтесь, главное заметьте, что запись благодаря автоматическому выводу очень сильно сокращается):

Ух ты! Вот это сокращение. Ладно, но можно ли сделать что-нибудь в духе Haskell, где тип возвращаемого значения будет зависеть от типов аргументов?

И опять ответ да, благодаря ключевому слову decltype в комбинации с auto:

Может показаться, что эта форма записи не сильно хороша, но в комбинации с обобщенным программированием (templates / generics) неявная типизация или автоматический вывод типов творят чудеса.

Некоторые языки программирования по данной классификации

Я приведу небольшой список из популярных языков и напишу как они подразделяются по каждой категории “типизаций”.

Возможно я где-то ошибся, особенно с CL, PHP и Obj-C, если по какому-то языку у Вас другое мнение — напишите в комментариях.

Заключение

Окей. Уже скоро будет светло и я чувствую, что про типизацию больше нечего сказать. Ой как? Тема бездонная? Очень много осталось недосказано? Прошу в комментарии, поделитесь полезной информацией.

Источник

Как работать с типизацией в Python

Авторизуйтесь

Как работать с типизацией в Python

Первые упоминания о подсказках типов в языке программирования Python появились в базе Python Enhancement Proposals (PEP-483). Такие подсказки нужны для улучшения статического анализа кода и автодополнения редакторами, что помогает снизить риски появления багов в коде.

В этой статье мы рассмотрим основы типизации кода Python и ее роль в динамически-типизированном языке, эта информация будет наиболее полезна для начинающих Python-разработчиков.

Типизация в Python

Для обозначения базовых типов переменных используются сами типы:

Пример использования базовых типов в python-функции:

25–27 ноября, Онлайн, Беcплатно

Также есть более абстрактные типы, например:

На первом месте стоит массив типов входных параметров, на втором — тип возвращаемого значения.

Про остальные абстрактные типы контейнеров можно прочитать в документации Python.

Также Python позволяет определять свои Generic-типы.

В данном примере TypeVar означает переменную любого типа, которую можно подставить при указании. Например:

На месте KeyType или ValueType могут быть конкретные типы.

Зачем это нужно

Цель — указать разработчику на ожидаемый тип данных при получении или возврате данных из функции или метода. В свою очередь, это позволяет сократить количество багов, ускорить написание кода и улучшить его качество.

Конечно, можно написать и проще:

Однако, в обоих случаях может возникнуть ошибка, если ключ age будет присутствовать и при этом иметь строковый тип. Валидация типов добавляет не очень много строк кода, но при большом количестве моделей может занимать немало места в проекте.

Использование Pydantic помогает корректно валидировать данные, при этом тип автоматически поменяется на требуемый.

Как можно заметить, более строгая типизация кода помогает сделать его проще и безопаснее. Однако, использование некоторых возможностей Pydantic может нежелательно повлиять на код. Так, мутация данных при валидации способна привести к тому, что тип значения модели будет непонятен. Например:

В данном примере созданный User после валидации будет иметь отличный от того, который был указан в модели. Это ведет к возможным крупным багам, которые лучше всегда избегать.

Также сейчас набирает большую популярность фреймворк FastAPI, который, благодаря Pydantic, позволяет быстро писать веб-приложения с автоматической валидацией данных.

В данном примере эндпоинт /item автоматически валидирует входящий json и передает его в функцию как требуемую модель.

Также для уменьшения количества багов используют mypy, который позволяет проводить статический анализ кода на соответствие типов. За счет этого зачастую можно избежать очевидных багов или несоответствий типов в функциях.

И как бонус для тех, кто ленится вручную поддерживать типизацию. MonkeyType дает возможность автоматически проставить типы во всех функциях, хотя после запуска этой программы обычно требуется пройтись по коду и поправить некоторые значения, которые оказались распознаны не так, как предполагалось.

Нововведения Python 3.9.0

Заключение

В этой статье мы рассмотрели некоторые типы в языке Python. В заключение отметим, что типизированный код в Python становится намного более читаемым и очевидным, что помогает проводить ревью в команде и не допускать глупых ошибок. Хорошее описание типов также позволяет разработчикам быстрее влиться в проект, понять, что происходит, и погрузиться в задачи. Также при использовании определенных библиотек удается в несколько раз сократить количество строк кода, которые ранее требовались только для валидации типов и значений.

Источник

Типы данных Python

Введение в тему

Данные не однородны. Информация, записанная на естественном языке, к примеру, это предложение, сильно отличается от данных, состоящих из чисел. Слова можно склонять, а числа – умножать. Для того, чтобы удобнее было работать с такими разными данными, создатели языков программирования разделяют их на различные типы. Типы данных Python не исключение. О них мы и поговорим в этом уроке.

Что такое динамическая типизация

Python, как уже говорилось, является типизированным языком программирования. Естественно, у такого языка должен быть механизм определения типа данных. Если бы этого не было, возникали бы ситуации, когда логика программы будет нарушена, а код выполнится некорректно.

Этим механизмом является типизация.

В процессе её выполнения выполняется определение используемых. Типизация бывает статической и динамической. При статической проверка выполняется во время компиляции программы, а при динамической — непосредственно во время выполнения программного кода.

У Пайтона типизация динамическая. Благодаря этому одну и ту же переменную можно использовать много раз с данными разных типов, и она при этом будет каждый раз менять свой тип чтобы код исполнялся корректно:

Но, увлекаться этим не стоит – для улучшения читаемости кода, в большинстве случаев, лучше ввести дополнительные переменные для данных с другими типами. Это полезно ещё и тем, что переменные с хорошо выбранными названиями являются альтернативой комментариям и объясняют, что за данные они хранят.

Существует давний спор между сторонниками разных языков о том, какая типизация лучше: статическая или динамическая. Так как у обоих подходов есть и минусы, и плюсы, то правильным ответом будет: лучше, та типизация, которая больше подходит под Ваши задачи. В среднем, программы, написанные на языках со статической типизацией, более надёжны, но разработка на языках с динамической типизацией происходит быстрее. Часто встречается комбинированный подход, когда на динамическом языке пишут прототип программы, а потом, критически важные места переписывают на статический язык.

В последнее время набирает популярность «смешанная типизация». Самым ярким примером этого подхода является язык Rust: статическая типизация при входе и выходе из блока кода, но динамическая внутри этого блока. В последних версиях Питон тоже делает шаг в эту сторону: появился такой инструмент, как аннотирование типов или type hinting, но это тема отдельной статьи.

К основным плюсам динамической типизации относятся:

К основным минусам динамической типизации относятся:

Разница между атомарными и структурными типы данных

Все типы данных в Python можно разделить на атомарные и ссылочные.

Разница между этими типами в том, что атомарные объекты, при их присваивании переменным, передаются по значению, а ссылочные передаются по ссылке.

Источник

Статическая и динамическая типизация

Эта статья рассказывает о разнице между статически типизированными и динамически типизированными языками, рассматривает понятия «сильной» и «слабой» типизации, и сравнивает мощность систем типизации в разных языках. В последнее время наблюдается четкое движение в сторону более строгих и мощных систем типизации в программировании, поэтому важно понимать о чем идет речь когда говорят о типах и типизации.

Тип — это коллекция возможных значений. Целое число может обладать значениями 0, 1, 2, 3 и так далее. Булево может быть истиной или ложью. Можно придумать свой тип, например, тип «ДайПять», в котором возможны значения «дай» и «5», и больше ничего. Это не строка и не число, это новый, отдельный тип.

Динамически типизированные языки помечают значения типами: язык знает, что 1 это integer, 2 это integer, но он не может знать, что переменная x всегда содержит integer.

Среда выполнения языка проверяет эти метки в разные моменты времени. Если мы попробуем сложить два значения, то она может проверить, являются ли они числами, строками или массивами. Потом она сложит эти значения, склеит их или выдаст ошибку, в зависимости от типа.

Статически типизированные языки

Статические языки проверяют типы в программе во время компиляции, еще до запуска программы. Любая программа, в которой типы нарушают правила языка, считается некорректной. Например, большинство статических языков отклонит выражение «a» + 1 (язык Си — это исключение из этого правила). Компилятор знает, что «a» — это строка, а 1 — это целое число, и что + работает только когда левая и правая часть относятся к одному типу. Так что ему не нужно запускать программу чтобы понять, что существует проблема. Каждое выражение в статически типизированном языке относится к определенному типу, который можно определить без запуска кода.

Это не уменьшает «статичность» системы типов. Система типов в Haskell знаменита своей статичностью, строгостью и мощностью, и в по всем этим фронтам Haskell опережает Java.

Динамически типизированные языки

Динамически типизированные языки не требуют указывать тип, но и не определяют его сами. Типы переменных неизвестны до того момента, когда у них есть конкретные значения при запуске. Например, функция в Python

может складывать два целых числа, склеивать строки, списки и так далее, и мы не можем понять, что именно происходит, пока не запустим программу. Возможно, в какой-то момент функцию f вызовут с двумя строками, и с двумя числами в другой момент. В таком случае x и y будут содержать значения разных типов в разное время. Поэтому говорят, что значения в динамических языках обладают типом, но переменные и функции — нет. Значение 1 это определенно integer, но x и y могут быть чем угодно.

Сравнение

Большинство динамических языков выдадут ошибку, если типы используются некорректно (JavaScript — известное исключение; он пытается вернуть значение для любого выражения, даже когда оно не имеет смысла). При использовании динамически типизированных языков даже простая ошибка вида «a» + 1 может возникнуть в боевом окружении. Статические языки предотвращают такие ошибки, но, конечно, степень предотвращения зависит от мощности системы типов.

Сильная и слабая типизация

Понятия «сильный» и «слабый» — очень неоднозначные. Вот некоторые примеры их использования:

Иногда «сильный» означает «статический».
Тут все просто, но лучше использовать термин «статический», потому что большинство используют и понимают его.

Иногда «сильный» означает, что невозможно обойти строгие правила типизации в языке.

Давайте остановимся. Вот как некоторые языки отвечают этим определениям. Как можно заметить, только Haskell последовательно «сильный» по всем параметрам. Большинство языков не такие четкие.

(«Когда как» в колонке «Неявные преобразования» означает, что разделение между сильным и слабым зависит от того, какие преобразования мы считаем приемлемыми).

Зачастую термины «сильный» и «слабый» относятся к неопределенной комбинации разных определений выше, и других, не показанных здесь определений. Весь этот беспорядок делает слова «сильный» и «слабый» практически бессмысленными. Когда хочется использовать эти термины, то лучше описать, что конкретно имеется ввиду. Например, можно сказать, что «JavaScript возвращает значение, когда складывается строка с числом, но Python возвращает ошибку». В таком случае мы не будем тратить свои силы на попытки прийти к соглашению о множестве значений слова «сильный». Или, еще хуже: придем к неразрешенному непониманию из-за терминологии.

В большинстве случаев термины «сильный» и «слабый» в интернете являются неясными и плохо определенными мнениями конкретных людей. Они используются, чтобы назвать язык «плохим» или «хорошим», и это мнение оборачивается в технический жаргон.

Сильная типизация: Система типов, которую я люблю и с которой мне комфортно.

Слабая типизация: Система типов, которая беспокоит меня или с которой мне не комфортно.

Постепенная типизация (gradual typing)

Неудовлетворительное решение на практике — это задать выражению eval() тип Any, что напоминает Object в некоторых объектно-ориентированных языках программирования или интерфейс interface <> в Go: это тип, которому удовлетворяет любое значение.

В некоторых языках есть опциональная или постепенная типизация (gradual typing): они динамические по умолчанию, но позволяют добавлять некоторые статические аннотации. В Python недавно добавили опциональные типы; TypeScript — это надстройка над JavaScript, в котором есть опциональные типы; Flow производит статический анализ старого доброго кода на JavaScript.

Эти языки предоставляют некоторые преимущества статической типизации, но они никогда не дадут абсолютной гарантии, как по-настоящему статические языки. Некоторые функции будут статически типизированными, а некоторые будут динамически типизированными. Программисту всегда нужно знать и опасаться разницы.

Компиляция статически типизированного кода

Когда происходит компиляция статически типизированного кода, сначала проверяется синтаксис, как в любом компиляторе. Потом проверяются типы. Это означает, что статический язык сначала может пожаловаться на одну синтаксическую ошибку, а после ее исправления пожаловаться на 100 ошибок типизации. Исправление синтаксической ошибки не создало эти 100 ошибок типизации. Компилятор просто не имел возможности обнаружить ошибки типов, пока не был исправлен синтаксис.

Компиляторы статических языков обычно могут генерировать более быстрый код, чем компиляторы динамических. Например, если компилятор знает, что функция add принимает целые числа, то он может использовать нативную инструкцию ADD центрального процессора. Динамический язык будет проверять тип при выполнении, выбирая один из множества функций add в зависимости от типов (складываем integers или floats или склеиваем строки или, может быть, списки?) Или нужно решить, что возникла ошибка и типы не соответствуют друг другу. Все эти проверки занимают время. В динамических языках используются разные трюки для оптимизации, например JIT-компиляция (just-in-time), где код перекомпилируется при выполнении после получения всей необходимой о типах информации. Однако, никакой динамический язык не может сравниться по скоростью с аккуратно написанным статическим кодом на языке вроде Rust.

Аргументы в пользу статических и динамических типов

Сторонники статической системы типов указывают на то, что без системы типов простые ошибки могут привести к проблемам в продакшене. Это, конечно же, правда. Любой, кто использовал динамический язык, испытал это на себе.

Плюсы и минусы статических и динамических систем типизации все еще плохо изучены, но они определенно зависят от языка и конкретной решаемой задачи.

Существуют разные подходы с разными уровнями безопасности, но Python и JavaScript оба являются динамически типизированными языками.

Си с радостью позволит программисту считать данные из любого места в памяти, или представить, что значение одного типа обладает другим типом, даже если это не имеет никакого смысла и приведет к падению программы.

Haskell же не позволит сложить integer и float без явного преобразования перед этим. Си и Haskell оба являются статически типизированными, не смотря на такие большие отличия.

Есть множество вариаций динамических и статических языков. Любое безоговорочное высказывание вида «статические языки лучше, чем динамические, когда дело касается Х» — это почти гарантированно ерунда. Это может быть правдой в случае конкретных языков, но тогда лучше сказать «Haskell лучше, чем Python когда дело касается Х».

Разнообразие статических систем типизации

Давайте взглянем на два знаменитых примера статически типизированных языков: Go и Haskell. В системе типизации Go нет обобщенных типов, типов с «параметрами» от других типов. Например, можно создать свой тип для списков MyList, который может хранить любые нужные нам данные. Мы хотим иметь возможность создавать MyList целых чисел, MyList строк и так далее, не меняя исходный код MyList. Компилятор должен следить за типизацией: если есть MyList целых чисел, и мы случайно добавляем туда строку, то компилятор должен отклонить программу.

Go специально был спроектирован таким образом, чтобы невозможно было задавать типы вроде MyList. Лучшее, что возможно сделать, это создать MyList «пустых интерфейсов»: MyList может содержать объекты, но компилятор просто не знает их тип. Когда мы достаем объекты из MyList, нам нужно сообщить компилятору их тип. Если мы говорим «Я достаю строку», но в реальности значение — это число, то будет ошибка исполнения, как в случае с динамическими языками.

В Go также нет множества других возможностей, которые присутствуют в современных статически типизированных языках (или даже в некоторых системах 1970-х годов). У создателей Go были свои причины для этих решений, но мнение людей со стороны по этому поводу иногда может звучать резко.

Haskell может выражать намного более сложные идеи напрямую типами. Например, Num a => MyList a означает «MyList значений, которые относятся к одному типу чисел». Это может быть список integer’ов, float’ов или десятичных чисел с фиксированной точностью, но это определенно никогда не будет списком строк, что проверяется при компиляции.

Если у функции в типе нет IO, то мы знаем, что она не совершает никаких операций ввода/вывода. В веб-приложении, к примеру, можно понять, изменяет ли функция базу данных, просто взглянув на ее тип. Никакие динамические и почти никакие статические языки не способы на такое. Это особенность языков с самой мощной системой типизации.

В большинстве языков нам пришлось бы разбираться с функцией и всеми функциями, которые оттуда вызываются, и так далее, в попытках найти что-то, изменяющее базу данных. Это утомительный процесс, в котором легко допустить ошибку. А система типов Haskell может ответить на этот вопрос просто и гарантированно.

Сравните эту мощность с Go, который не способен выразить простую идею MyList, не говоря уже о «функции, которая принимает два аргумента, и они оба численные и одного типа, и которая делает ввод/вывод».

Подход Go упрощает написание инструментов для программирования на Go (в частности, реализация компилятора может быть простой). К тому же, требуется изучить меньше концепций. Как эти преимущества сравнимы со значительными ограничениями — субъективный вопрос. Однако, нельзя поспорить, что Haskell сложнее изучить, чем Go, и что система типов в Haskell намного мощнее, и что Haskell может предотвратить намного больше типов багов при компиляции.

Go и Haskell настолько разные языки, что их группировка в один класс «статических языков» может вводить в заблуждение, не смотря на то, что термин используется корректно. Если сравнивать практические преимущества безопасности, то Go ближе к динамических языкам, нежели к Haskell’у.

С другой стороны, некоторые динамические языки безопаснее, чем некоторые статические языки. (Python в целом считается намного безопаснее, чем Си). Когда хочется делать обобщения о статических или динамических языках как группах, то не забывайте об огромном количестве отличий между языками.

Конкретные примеры отличия в возможностях систем типизации

В более мощных системах типизации можно указать ограничения на более мелких уровнях. Вот несколько примеров, но не зацикливайтесь на них, если синтаксис непонятный.

В Go можно сказать «функция add принимает два integer’а и возвращает integer»:

В Haskell можно сказать «функция принимает любой численный тип и возвращает число того же типа»:

В Idris можно сказать «функция принимает два integer’а и возвращает integer, но первый аргумент должен быть меньше второго аргумента»:

В Haskell нет эквивалента такому типу как в примере с Idris выше, а в Go нет эквивалента ни примеру с Haskell, ни примеру с Idris. В итоге, Idris может предотвратить множество багов, которые не сможет предотвратить Haskell, а Haskell сможет предотвратить множество багов, которые не заметит Go. В обоих случаях необходимы дополнительные возможности системы типизации, которые сделают язык более сложным.

Системы типизации некоторых статических языков

Вот грубый список систем типизации некоторых языков в порядке возрастания мощности. Этот список даст вам общее представление о мощности систем, не нужно относиться к нему как к абсолютной правде. Собранные в одну группу языки могут сильно отличаться друг от друга. В каждой системе типизации есть свои заморочки, и большинство из них очень сложны.

Наблюдается явное движение в сторону более мощных систем типизации, особенно если судить по популярности языков, а не по простому факту существования языков. Известное исключение — это Go, который объясняет, почему многие сторонники статических языков считают его шагом назад.

Группа два (Java и C#) — это мэйнстримовые языки, зрелые и широко используемые.

Группа три находится на пороге входа в мэйнстрим, с большой поддержкой со стороны Mozilla (Rust) и Apple (Swift).

Группа четыре (Idris and Agda) далеки от мэйнстрима, но это может измениться со временем. Языки группы три были далеко от мэйнстрима еще десять лет назад.

Источник