2.Типы данных

В конце прошлого блока была рассмотрена следующая конструкция: name = input("Как тебя зовут? ")
 Она используется, чтобы записать введённые пользователем данные в переменную name.

В программировании постоянно возникает необходимость в сохранении и использовании каких-либо данных, для этих целей и используются переменные. Создать переменную просто, для этого необходимо написать следующую конструкцию: [имя_переменной] = [значение]

Мы задаем имя переменной, можно это сделать, использую кириллицу и не только, но настоятельно рекомендуется делать это, использую только латиницу. Затем задаем переменной какое-либо значение.

Остановимся на имени переменной чуть подробнее:

  1. Имя переменной может содержать только латинские буквы, числа и символ нижнего подчеркивания;
  2. Имя переменной не должно содержать пробелов;
  3. Имя переменной не должно начинаться с цифры;
  4. Регистр переменных важен: var и Var это разные переменные.

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

Типы в Python и определенные ограничения на них защищают программы от случайных ошибок. Разберем подробнее некоторые типы.

Числа: int и float

Первые два типа - int (от слова integer) и float. int обозначает целое число (10, 256), а float - действительное (3.14, 10.591). Для их вывода в отличии от строк не нужны кавычки: print(6)
print(12.02)

Строка "10" и число 10, также как и "10.5" и 10.5 - разные вещи, хотя вывод через print() у них один: print(10) # 10
print("10") # 10

С числами можно выполнять разные операции:

  1. Сложение;
  2. Вычитание;
  3. Умножение;
  4. Деление;
  5. Возведение в степень;
  6. Целочисленное деление;
  7. Получение остатка от деления.
print(9 + 3.5) # 12.5
print(32.3 - 41.1) # -8.8
print(3.4 * 5) # 17.0
print(22 / 3) # 7.333333333333333
print(2 ** 5) # 32
print(23 // 10) # 2
print(23 % 10) # 3

У всех них есть приоритет выполнения, он такой же как в математике: print(10 + 2 * 3.5) # 17.0 У операций целочисленное деление и получение остатка от деления приоритет как у деления и умножения.

Также мы можем использовать скобки: print((10 + 2) * 3.5) # 42.0

При работе с переменными мы можем выполнять действия разными путями: # 1 способ
n = 10
n = n * 2 + 2.5
print(n) # 22.5

# 2 способ
n = 10
n *= 2
n += 2.5
print(n) # 22.5

Строки

Тип str (от слова string) является типом строк в Python. Мы можем с ними проводить некоторые операции:

  1. Сложение строк (конкатенация);
  2. Умножение строки на целое число.
print("ab" + "cd") # abcd
print("ab" * 3) # ababab

Можем обращаться к строкам по индексам, чтобы достать отдельную подстроку (индексирование в Python начинается с 0, т.е. первому символу соответствует индекс 0, второму - 1 и т.д.): greating = "Hello, World!"
print(greating[0]) # H
print(greating[5]) # , Об остальном про строки будет рассказано в отдельном блоке.

Списки

Тип list является типом списка в Python. Мы можем хранить в списке разные типы данных, даже сами списки: l = [10, "abc", 4.23, []]
print(l) # [10, "abc", 4.23, []]

Со списками операции такие же как со строками: l = [10, "abc", 4.23, []]
l += [12.5, "Hello"]
print(l) # [10, "abc", 4.23, [], 12.5, "Hello"]
l *= 2
print(l) # [10, "abc", 4.23, [], 12.5, "Hello", 10, "abc", 4.23, [], 12.5, "Hello"]

Можем обращаться к спискам по индексам, чтобы достать отдельный элемент: l = [10, "abc", 4.23, [2, 5.0]]
print(l[1]) # "abc"
print(l[3]) # [2, 5.0]

Также можем изменять списки по индексам: l = [10, "abc", 4.23, [2, 5.0]]
l[2] = "дробное число"
print(l) # [10, "abc", "дробное число", [2, 5.0]] Об остальном про списки будет рассказано в отдельном блоке.

Множества

Тип set является типом множества в Python. Мы можем хранить в множестве разные типы данных (также как и в списках), особенностью множества является то, что в нем хранятся уникальные значения: abc = {1, 3.0, 2, "abc", 2, "abc", 3}
print(abc) # {1, 2, 3.0, "abc"} Также вывод множества осуществляется рандомно, т.е. значения могут выводится в разном порядке.

В рамках данного курса работа с множествами ограничивается информацией выше.

Словари

Тип dict (от слова dictionary) является типом словаря в Python. Его особенность в том, что мы можем сохранять данные в формате [ключ]: [значение]: d = {1: "a", 2: "abc", "Hey": 20.5}
print(d) # {1: "a", 2: "abc", "Hey": 20.5}

Например ключу 1 в данном примере соответствует значение "a", а ключу "Hey" - значение 20.5.

Значениями могут быть любые типы данных, а ключами только неизменяемые: int, float, str, tuple.

В рамках данного курса работа со словарями не затрагивается.

Кортежи

Тип tuple является кортежем в Python. Проще говоря, это неизменяемый список, некоторые действия, которые можно проводить со списками, нельзя проделать с кортежами: d = ["a", 15]
l[1] = 10
print(l) # ["a", 10] s = (1, 2.0)
s[1] = 10 # TypeError: 'tuple' object does not support item assignment В рамках данного курса работа с кортежами не затрагивается.

Логическое значение

Тип bool (от слова boolean) является логическим значением в Python. Принимает только значения True или False. b = True

Преобразование из одного типа в другой

Для начала рассмотрим следующие конструкции создания различных переменных с разными типами данных: a = str() # то же самое a = ""
b = int() # то же самое b = 0
c = list() # то же самое с = []
d = set() # нет альтернативы
e = dict() # то же самое e = {}
f = tuple() # то же самое f = ()
g = bool() # то же самое g = False

Чтобы преобразовать один тип в другой мы используем конструкцию [тип]([значение]), но не все типы переводятся из одних в другие: d = {1: "a", 2: "abc"}
num = int(d)
# TypeError: int() argument must be a string, a bytes-like object or a real number, not 'dict'
 s = 13.5
print(int(s)) # 13 l = [1, 2, 5, 2.0, "abc", 1, 2, 5]
print(set(l)) # {1, 2, 5, "abc"}

При операциях чисел типов int и float происходит неявное преобразование int к float, это единственное неявное преобразование типов в Python. В остальном неявное преобразование не используется, чтобы избежать непредсказуемого поведения программы: a = 2
b = 1.5
print(a + b) # 3.5

c = [1.1, 4]
d = {2, "a"}
print(c + d) # TypeError: can only concatenate list (not "set") to list

Рассмотрим следующую конструкцию: x = int(input('Введите первое число'))
y = int(input('Введите второе число'))

# 1 способ
print(x, '+', y, '=', x + y)

# 2 способ
print(str(x) + ' + ' + str( y) + ' = ' + str(x + y))

В первых двух строках кода мы попросили пользователя ввести число, после чего с помощью int() преобразовали значения переменных x и y к целым числам (по умолчанию мы с помощью input получаем строки (данные типа str).

В 1 способе вывода мы передаем функции print несколько значений, которые она выводит и делит их пробелами, т.к. мы поделили значения запятой. В 2 способе вывода мы передаем функции print строку, которая получена путем сложения (конкатенации) нескольких строк, в этом случае мы вместо "+" записали " + ", чтобы сохранить красивый вывод, также применили функцию str, чтобы привести переменные к строковому типу.

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

  1. Тип int. Приводится к False, если значение 0, в ином случае приводится к True print(bool(0)) # False
    print(bool(15)) # True
    print(bool(-3)) # True
  2. Тип str. Приводится к False, если значение строки "" (пустая строка), в ином случае приводится к True print(bool('')) # False
    print(bool("Hello")) # True
    print(bool(" ")) # True, пробел не является пустой строкой
  3. Типы, которые предназначены для хранения разных данных (list, tuple, dict, set). Если данный тип является пустым (для списка []), то приводится к False, в ином случае приводится к True. a = {}
    b = [0]
    c = [[]]

    print(bool(a)) # False
    print(bool(b)) # True
    print(bool(c))
    # True, в списке есть другой список, хоть и пустой, но он делает основной список непустым