Типы данных

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

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

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

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

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

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

Языки с сильной типизацией (например, Python, Java, C#) требуют явного преобразования типов (приведения) перед выполнением операций над несовместимыми типами данных. Попытка сложить число и строку без явного преобразования приведет в Python к ошибке TypeError (с англ. – Ошибка типа):

12 + "5"  # Ошибка сложения числа со строкой

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

Языки со слабой типизацией (например, JavaScript, PHP) более лояльны к смешению типов и часто выполняют автоматическое (неявное) преобразование типов, поэтому, например, на JavaScript мы можем сложить число со строкой:

12 + "5";  // В результате получится "125"

Здесь число 12 автоматически преобразуется в строку "12", после чего будет выполнена конкатенация (сложение) строк.

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

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

Языки с явной типизацией (C++, C#, Java) требуют явное указание типа переменной при ее объявлении. Например, в C++ следует указывать тип int для целого числа и std::string для строки:

int age = 26; // Явное указание типа (целое число)
std::string name = "Михаил"; // Явное указание типа (строка)

Языки с неявной типизацией (Python, JavaScript, PHP) позволяют создавать переменные без явного указания их типа. Так интерпретатор Python сам определяет тип переменной на основе присваиваемого значения:

age = 26  # Автоматическое определение типа как целого числа
name = "Михаил"  # Автоматическое определение типа как строки

Неявную типизацию иногда называют «утиной типизацией» – если что-то выглядит как утка, плавает как утка и крякает как утка, то, вероятно, это и есть утка. То есть, тип объекта определяется не его явным объявлением, а его поведением (набором доступных методов и свойств).

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

Эта характеристика определяет, когда происходит определение типа переменной.

В языках с динамической типизацией (Python, JavaScript, PHP) тип переменной определяется во время выполнения программы, когда ей присваивается значение. В Python одна и та же переменная может последовательно хранить значения разных типов:

length = 25  # Тип length - целое число
length = "Бесконечная"  # Теперь тип length - строка

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

В языках со статической типизацией (C/C++, C#, Java) тип переменной должен быть явно объявлен на этапе компиляции (до запуска программы) и не может быть изменен после, как например, в C:

int length = 25; // Тип length - целое число
length = "Бесконечная"; // Ошибка, так как переменная length не может содержать строку

Здесь переменная length объявлена как целое число, поэтому присваивание ей позже строкового значения приведёт к ошибке компиляции.

Аннотация типов

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

Аннотации стали частью стандарта языка начиная с версии Python 3.5 и позволяют указать тип переменной через двоеточие после её имени:

имя_переменной: тип_переменной

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

name: str = "Алексей"
age: int = 30

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

Основные встроенные типы данных

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

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

Также существует специальный тип данных NoneType, предназначенный для обозначения отсутствия какого-либо значения. Обычно он представлен единственным объектом – None. 

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

Изменяемые и неизменяемые типы данных

В зависимости от возможности изменения значения объекта после его создания, все типы данных в Python делятся на неизменяемые (англ. – immutable) и изменяемые (англ. – mutable).

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

Например, создадим переменную числового типа и прибавим к ней другое число:

n = 10
print(id(n)) 
# Вывод: 140717977647832

n += 2  # Эквивалентно n = n + 2
print(id(n)) 
# Вывод: 140717977647896

Как видите, идентификатор изменился, поскольку числа относятся к неизменяемому типу данных. После изменения значения переменной n в памяти был создан новый объект со значением 12, на который теперь указывает переменная n.

Объекты изменяемого типа (списки, множества, словари), наоборот, могут изменять своё содержимое без создания нового объекта и без изменения своего идентификатора в памяти.

Например создадим список, и добавим в него другой список:

subjects = ["Математика", "Информатика", "Физика"]
print(id(subjects)) 
# Вывод: 2076557039872

subjects += ["Русский язык"]  # Эквивалентно subjects = subjects  + ["Русский язык"]
print(id(subjects)) 
# Вывод: 2076557039872

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

Определение типа переменной

Python предоставляет две полезные встроенные функции для работы с типами данных.

1. Функция type() возвращает тип объекта.

Например, для строки возвращается <class 'str'>, а для списка – <class 'list'>:

# Целое число:
sugar = 255
print(type(sugar)) 
# Вывод: <class 'int'>

# Строка:
mouse = "Микки Маус"  
print(type(mouse)) 
# Вывод: <class 'str'>

# Список:
toys = ["Кукла", "Машинка", "Уточка"] 
print(type(toys)) 
# Вывод: <class 'list'>

Сейчас мы называем целые числа, строки или списки типами данных. Но позже вы узнаете, что на самом деле за каждым типом данных скрывается понятие «класс», поэтому функция type() возвращает именно <class 'название'>. Классы определяют структуру и поведение всех объектов этого типа, в том числе, с помощью методов, определяемых внутри класса. То есть класс – это своего рода шаблон, по которому создаются конкретные объекты. Поэтому каждый тип данных соответствует своему классу, и именно классы задают правила поведения для каждого объекта этого типа.

2. Функция isinstance() проверяет, принадлежит ли объект указанному типу.

Например, если целочисленную переменную проверять на принадлежность к типу целых чисел int, то функция вернёт True (с англ. – истина), а если к классу строки str, то False (с англ. – ложь):

x = 10
print(isinstance(x, int)) 
# Вывод: True
print(isinstance(x, str)) 
# Вывод: False

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

1. Чем отличается сильная типизация от слабой?

2. Что понимается под динамической типизацией в Python?

3. Используйте аннотации типов и создайте переменную author со значением "Сьюзен Коллинз", переменную book_titles со значением ["Голодные игры", "The Hunger Games"] и переменную year со значением 2010.

author: str = "Сьюзен Коллинз"
book_titles: list = ["Голодные игры", "The Hunger Games"]
year: int = 2010

4. При изменении значения переменной числового типа будет ли изменён её идентификатор?

5. Определите типы следующих переменных:

email  = "admin@mail.ru"
snow = False
clothes = ("Брюки", "Рубашка", "Галстук")
points = {"x", "y", "z"}
page = 125
meal = { "Завтрак", "Обед", "Ужин"}
temperature = {"01.01.2024": -25, "02.01.2024": -26, "03.01.2024": -23}

email  = "admin@mail.ru" # строка
print(type(email)) # <class 'str'>

snow = False # логический тип
print(type(snow)) # <class 'bool'>

clothes = ("Брюки", "Рубашка", "Галстук") # кортеж
print(type(clothes)) # <class 'tuple'>

points = {"x", "y", "z"} # множество
print(type(points)) # <class 'set'>

height = 12.5 # дробное число
print(type(height)) # <class 'float'>

meal = ["Завтрак", "Обед", "Ужин"] # список
print(type(meal)) # <class 'list'>

temperature = {"01.01.2024": -25, "02.01.2024": -26, "03.01.2024": -23} # словарь
print(type(temperature)) # <class 'dict'>