Типизация в программировании

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

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

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

Такие языки программирования, как C, C++ или Java, являются статически типизированными языками. Это означает, что тип данных переменной должен быть объявлен до того, как он может быть фактически использован в программе. Объявлять тип данных в переменной можно и в момент первого присваивания. Ниже представлен пример объявления переменной a на языке C++

int a;
a = 100;

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

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

Обычно при описании системы типов языка программирования задаются три вопроса:

1. Выполняет ли язык неявные автоматические преобразования типов?

2. На каком этапе определяется тип переменной?

3. Необходимо ли явно указывать тип переменных?

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

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

Строгая типизация в Python

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

Когда мы говорим о «строгой типизации» в контексте программирования, мы имеем в виду строгий подход языка к обработке переменных разных типов. В языке программирования Python, который характеризуется строгой типизацией, разные типы данных не смешиваются автоматически.

Например, выражение:

a = "some string" - 3

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

Аналогично, попытка сложить список [2, 1, 0] и набор set([2, 23, 2]) также приведет к ошибке, поскольку Python не будет искать способы автоматического преобразования одной структуры данных в другую для выполнения операции. 

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

3 + '1' // Results in the string: '31'.

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

# Повторение последовательности: 
# Вы можете "умножить" строку или список на число, 
# получив в результате повторяющуюся последовательность. 
print ( "word" * 3 )   # wordwordword 
print ([ 1 , 2 ] * 3 )   # [1, 2, 1, 2, 1, 2] 

# float и int 
print ( 5 + 0.1 )   # 5.1 

# bool и number 
print ( 2.2 + True )   # 3.2 

# Примечание: тип bool наследуется от int, 
# поэтому здесь операция сложения проста. 

# и другие...

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

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

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

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

х = 5

Позже в вашей программе вы можете переназначить переменную x строковому значению:

х = "привет"

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

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

Ниже приведен пример фрагмента кода, демонстрирующего динамическую природу Python путем объявления двух функций с одинаковыми именами.

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

# Объявление двух функций с одинаковым именем 'greet' 

def greet(): 
    print ("Привет от первой функции greet!") 

def greet(): 
    print("Привет от второй функции greet!") 

# Вызов функции greet
greet() 

# Какая функция greet будет вызвана?

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

Во время выполнения, когда мы вызываем greet(), Python выполнит самое последнее определение функции. В этом случае он выведет: "Привет из второй функции greet!"

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

Рассмотрим функцию find, которая ищет элемент required_elementв последовательности sequence. В языке C для реализации той же логики пришлось бы написать несколько версий функции для разных типов данных, тогда как в Python достаточно одной:

def find(required_element, sequence):
    """Выполняет поиск элемента в последовательности."""
    for index, element in enumerate(sequence):
        if element == required_element:
            return index
    return - 1


print(find(2, [1, 2, 3]))  # Выведет: 1 
print(find("c", ("a", "b", "c", "d")))  # Выведет: 2 

print(find(1, 1))  # Вызывает исключение TypeError

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

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

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

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

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

Утиная типизация в Python

Динамическая типизация Python тесно связана с концепцией утиной типизации. Утиная типизация подчеркивает поведение объекта, а не его класс или тип. Другими словами, пригодность объекта для определенной операции определяется тем, поддерживает ли он требуемые методы или атрибуты, а не проверкой его явного типа.

Например, если объект крякает как утка (имеет метод quack) и ходит как утка (имеет метод walk), Python рассматривает его как утку, независимо от его класса или иерархии наследования.

Утиная типизация способствует повторному использованию кода и гибкости, позволяя использовать взаимозаменяемо объекты разных классов, если они демонстрируют необходимое поведение. Это делает возможным полиморфное программирование, где несколько типов могут беспрепятственно использоваться в одном и том же контексте.

Заключение

Динамическая типизация Python — это фундаментальная функция, которая позволяет разработчикам писать гибкий, адаптируемый и лаконичный код. Устраняя необходимость в явных объявлениях типов, Python обеспечивает быстрое прототипирование, повторное использование кода и фокусировку на логических аспектах программирования. Понимание динамической типизации и ее связи с утиной типизацией дает разработчикам ценные инструменты для эффективной разработки на Python. Примите динамическую природу Python и раскройте истинный потенциал этого замечательного языка.