Python: Сильная (или Строгая) типизация

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

Что это значит на практике?

Допустим, вы складываете два числа:

print(1 + 7)  # => 8

Все отлично. Операция сложения допустима для чисел, поэтому программа отработает и выведет на экран 8. А что будет, если попробовать сложить число и строку?

print(1 + '7')
# TypeError: unsupported operand type(s) for +: 'int' and 'str'

Python сообщает, что не может сложить int и str. Это ошибка типов: значения принадлежат к разным категориям, и программа отказывается продолжать.

'2' + 1

  str + int → TypeError!

  Нужно преобразование:
  int('2') + 1 → 3
  '2' + str(1) → '21'

Почему так строго?

Python защищает вас от неочевидных и опасных ошибок. Он требует, чтобы вы явно указали, как вы хотите преобразовать данные:

• либо сделать строку числом (int('7'));
• либо число строкой (str(1)).

Мы научимся делать это чуть позже.

Когда Python приводит типы сам

Если в одном выражении встречаются целое число и вещественное, Python приводит целое к вещественному автоматически.

print(1 + 1.5)  # => 2.5

Целое 1 превращается в 1.0, результат получается 2.5. Это работает потому что любое целое число точно представимо как вещественное, данные не теряются. Python знает об этом и приводит тип сам (как и большинство других языков).

А как в других языках?

Не все языки такие. Например, PHP и JavaScript используют слабую типизацию. Они автоматически преобразуют типы, когда считают это "разумным".

1 + '7';  // => '17'

В этом примере число 1 неявно превращается в строку '1', и результатом становится '17'.

Такое поведение появилось по вполне объективным причинам. Во многих языках, особенно тех, которые часто используются в веб-разработке, программе постоянно приходится работать с данными, пришедшими извне. Например, значения из HTML-форм, параметров URL или HTTP-запросов часто приходят как строки, даже если по смыслу это числа. Например, в PHP, строка с числом может автоматически участвовать в арифметике как число:

'7' + 1; // 8

Есть и другие языки со своими правилами. Например, в Ruby поведение в этом месте ближе к Python: выражение 1 + '7' не считается допустимым. А в C язык тоже допускает некоторые неявные преобразования, но уже по своим, более низкоуровневым правилам. Но на практике это приводит к таким проблемам и современные языки отказались от таких вольностей. Такие ошибки особенно сложно поймать, потому что поведение программы зависит от типа данных, которые в нее попали. Иногда все работает, а иногда нет.

При этом языки не делятся ровно на два лагеря: "строгие" и "слабые". Корректнее говорить, что у разных языков разная степень строгости. Где-то неявных преобразований почти нет, а где-то их заметно больше.

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

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

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

Вывод

Python является языком со строгой типизацией. Он не позволяет выполнять операции между несовместимыми типами без явного преобразования. Это делает программы надежнее и понятнее. Мы еще научимся преобразовывать данные из одного типа в другой и делать это всегда сознательно.

Выведите на экран результат выражения: 7 - (-8 - -2).

Попробуйте сделать число 7 не числом, а строкой: '7' - (-8 - -2). Сработает ли такой код? Поэкспериментируйте с другими числами тоже.