Типы данных в Python

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

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

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

В языках со статической типизацией сначала нужно определить тип переменной, и только потом присвоить значение. В Python тип переменной определяется в момент присваивания, то есть её не нужно отдельно объявлять, достаточно написать: name = "Джон", тогда переменная name будет иметь строковый тип.

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

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

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

Как узнать тип переменной

Тип переменной определяется с помощью встроенной функции type(). Её используют, чтобы понять, как работают типы в Python, и чтобы избежать необходимости отлавливать и обрабатывать исключения, например, когда интерпретатор ожидает число, а пользователь вводит строку. Пример:

a = 10
b = "Строка"
c = [1,2,3,4]
d = True
print(str(type(a)) +  str(type(b)) +  
        str(type(c)) + str(type(d)))

# Вывод
<class 'int'><class 'str'><class 'list'><class 'bool'>

Числовые типы

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

В Python есть такие типы чисел, как целые, вещественные и комплексные. Они определены ключевыми словами int, float и complex.

  • Целые числа — числа, значения которых представлены типом Это могут быть как отрицательные, так и положительные числа любой длины, интерпретатор Python не накладывает на неё ограничений.
  • Вещественные числа представлены типом Они могут отображаться в обычном виде или с использованием “е”: 1.252e+5. Из-за того что невозможно точно представить некоторые десятичные числа с плавающей точкой в двоичной системе счисления, при вычислениях могут возникать ошибки.
  • Комплексные числа представлены типом Это сложные числа вида 3 + 8j, где “3” — это действительная часть, а “8j” — мнимая.

Системы счисления

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

  • int(число, основание системы) — преобразовывает число в целое в нужной системе счисления. По умолчанию используется десятичная система счисления.
  • bin(число) — преобразует число в двоичное.
  • hex(число) — преобразует число в шестнадцатеричное.
  • oct(x) – преобразует число в восьмеричное.

Пример:

print(oct(10)) # Выведет '0o12'
print(hex(11)) # Выведет '0xb'
print(bin(11)) # Выведет '0b1011'
Описанные встроенные функции позволяют работать только с целыми числами, при попытке передать в функцию вещественное число вызовется исключение.

Сложные вычисления модуль math

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

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

import math
print(math.sqrt(math.pi))
# Результат выполнения:
1.7724538509055159

Последовательности

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

Строка

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

Создание строки

Чтобы создать строку, нужно присвоить переменной последовательность символов, заключённую в одинарные, двойные или тройные кавычки. Когда необходимо использовать внутри строки сами кавычки, применяется символ “\”, который называется escape-последовательностью и позволяет использовать специальные символы внутри строки.

Доступ к элементам строки

Программист может получить доступ к одному или нескольким символам строки, обращаясь к ней по индексам, как к массиву –

string  = "Строка"
print(string[0]) #Выведет "С"
Если попытаться получить доступ к строке по индексу, выходящему за диапазон длины строки, возбудится исключение IndexError, а попытка обратиться к строке по вещественному индексу вызовет исключение TypeError.

Удаление и изменение элементов строки

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

Список

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

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

Создание списка

Списки в Python 3 создаются с помощью квадратных скобок “[]”. Интерпретатор не требует от программиста использовать встроенную функцию, а также позволяет вкладывать списки друг в друга:

a = [1, 10,100] # Список с элементами 1, 10, 100
b = [1, 2, [3, 4], 5] # Список [3, 4] вложен в список b

Добавление элементов

Существует несколько методов, которые позволяют добавить в список новый элемент:

  • append() – метод, добавляющий один элемент в конец списка.
  • insert() – метод, который добавляет один элемент в нужную позицию списка.
  • extend() – метод, позволяющий добавить несколько элементов в конец списка.

Пример:

a = [1, 2]
a.append(5) # a = [1, 2, 5]
a.insert(0, 3) # a = [3, 1, 2, 5]
a.extend([3, 4]) # a = [3, 1, 2, 5, 3, 4]
Одним элементом может быть не только строка или число, но и другой список.

Доступ к элементам

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

Пример:

a = [4, 3, 2, 1]
print(a[0]) # Выведет 4
print([a[-1]) # Выведет 1
print(a[2:4]) # Выведет [2, 1]

Удаление элементов

Для удаления элементов используются два метода:

  • remove(элемент) — ищет и удаляет элемент списка, если в списке содержится несколько одинаковых, то метод удалит первый.
  • pop() – удаляет последний элемент списка или с определенным индексом, переданным в качестве аргумента.

Кортеж

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

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

Создание кортежа

Для создания кортежа используются круглые скобки “()”. Кортеж может быть пустым “()”, а может состоять из одного элемента, чтобы создать кортеж из одного элемента, нужно обязательно добавить после этого элемента запятую.

Пример:

a = (1, 2, 3)
b = (1,) # Кортеж из одного элемента
c = (1, 3, (2, 4), 4) # Вложенный кортеж

Доступ к элементам

Доступ к кортежу осуществляется по индексу к квадратных скобках, как и списки, кортежи поддерживают доступ по отрицательным индексам:

print(a[0]) # Выведет 1
print(a[-1]) # Выведет 3

Множества

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

Создание множества

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

a = set([1, 2, 3, 3])
print(a) # Выведет 1, 2, 3
b = {1, 3, "data"}
print(b) # Выведет {1, 3, 'data'}
print(type(b)) # Выведет <class 'set'>
Порядок элементов нельзя определить или изменить, элементы могут быть как одинаковых, так и разных типов.

Добавление элементов

Элементы добавляются с помощью методов: add() и update(). Функция add() может добавить только один элемент за вызов, а update() — несколько. Пример:

a = {1, 2, 3}
a.add(4) 
print(a) # {1, 2, 3, 4}
a.update([5, 5, 6]) 
print(a) # {1, 2, 3, 4, 5, 6}

Доступ к элементам

Получить доступ к элементу по индексу нельзя, потому что множества — неупорядоченные последовательности. Можно перебирать множество циклом for, или искать в нём нужное значение, используя ключевое слово in.

a = {1, 2, 3}
if 2 in a:
    print('in set')

Удаление элементов

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

Чтобы удалить последний элемент, используют pop(), для удаления всех элементов множества применяется clear().

Словари

Словари — это неупорядоченные коллекции, которые используются для хранения данных вида “ключ : значение” –

Создание словаря

Чтобы создать словарь, используют фигурные скобки “{}”, внутри которых размещаются элементы вида “ключ : значение”, разделенные запятыми. Значения могут иметь любой тип данных и дублироваться, а ключи в пределах одного словаря должны быть уникальны.

Функции dict() также позволяет создать словарь, который может как хранить элементы, так и быть пустым. Пример:

d = {"имя" : "Сергей", "фамилия" : "Сергеев"}
print(d["имя"]) # Выведет "Сергей"
c = {};
print(c) # Выведет {}
print(type(c)) # Выведет <class 'dict'>

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

Добавление элементов

Чтобы добавить новый элемент в словарь, нужно создать новый ключ и присвоить ему значение:

Dict["Ключ"] = "Значение"
Если использовать ключ, который уже существует, его значение обновится.

Доступ к элементам

Чтобы получить доступ к элементу словаря, нужно обратиться к его ключу, используя “Имя_словаря[ключ]”.

Удаление элементов

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

a = {"Один" : "1", "Два" : "2"}
del(a["Один"])
print(a) #Выведет {"Два" : "2"}

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

Логический тип данных

Этот тип данных содержит только два значения: True или False. True – это истина, а False – ложь.

Любой объект может рассматриваться в булевом контексте. Например, 1 — True, а 0 — False. В программировании булева алгебра применяется в условиях, циклах. Результатом любой операции сравнения будет “True” или “False”.