Data types

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

Целые числа, числа с плавающей запятой и комплексные числа относятся к группе чисел. В Python они представлены классами int, float и complex.

Мы можем использовать функцию type(), чтобы узнать класс переменной или значения, и функцию isinstance() для проверки принадлежности объекта определённому классу:

        
          
          a: int = 5print(a, "is of type", type(a))# 5 is of type <class 'int'>b: float = 2.0print(b, "is of type", type(a))# 2.0 is of type <class 'float'>c: complex = 1+2jprint(a, "is complex number?", isinstance(1+2j, complex))# (1+2j) is complex number? True
          a: int = 5
print(a, "is of type", type(a))
# 5 is of type <class 'int'>
b: float = 2.0
print(b, "is of type", type(a))
# 2.0 is of type <class 'float'>
c: complex = 1+2j
print(a, "is complex number?", isinstance(1+2j, complex))
# (1+2j) is complex number? True

        
        
          
            
            Скопировать
            Скопировано
            Не удалось скопировать
          
        
      

Целые числа могут быть любой длины, они ограничиваются лишь доступной памятью в 4 байта.

Числа с плавающей запятой имеют ограниченную точность. Визуально разницу между целым числом и числом с плавающей запятой можно заметить в консоли по наличию точки: 1 — целое число, 1.0 — с плавающей запятой.

Комплексные числа записываются в форме x+yj, где x — действительная часть числа, а y — мнимая.

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

Объявить список довольно просто. Внутрь квадратных скобок помещаются элементы списка, разделённые запятой:

        
          
          a: list = [1, 2.2, 'python']
          a: list = [1, 2.2, 'python']

        
        
          
            
            Скопировать
            Скопировано
            Не удалось скопировать
          
        
      

Мы можем использовать оператор [] для извлечения элемента (такая операция называется «доступ по индексу») или диапазона элементов (такая операция называется «извлечение среза») из списка. В Python индексация начинается с нуля:

        
          
          a: list = [5,10,15,20,25,30,35,40]print("a[2] =", a[2])# a[2] = 15print("a[0:3] =", a[0:3])# a[0:3] = [5, 10, 15]print("a[5:] =", a[5:])# a[5:] = [30, 35, 40]
          a: list = [5,10,15,20,25,30,35,40]
print("a[2] =", a[2])
# a[2] = 15
print("a[0:3] =", a[0:3])
# a[0:3] = [5, 10, 15]
print("a[5:] =", a[5:])
# a[5:] = [30, 35, 40]

        
        
          
            
            Скопировать
            Скопировано
            Не удалось скопировать
          
        
      

Списки являются изменяемым типом, т.е. значения его элементов можно изменить:

        
          
          a: list = [1,2,3]a[2] = 4print(a)# [1, 2, 4]
          a: list = [1,2,3]
a[2] = 4
print(a)
# [1, 2, 4]

        
        
          
            
            Скопировать
            Скопировано
            Не удалось скопировать
          
        
      

Так же как и список, кортеж (tuple) является упорядоченной последовательностью элементов. Вся разница заключается в том, что кортежи неизменяемы.

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

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

        
          
          t: tuple = (5,'program', 1+3j)# Мы можем использовать оператор извлечения среза []# для извлечения элементов, но мы не можем менять их значения:print("t[1] = ", t[1])# t[1] = programprint("t[0:3] =", t[0:3])# t[0:3] = (5, 'program', (1+3j))
          t: tuple = (5,'program', 1+3j)
# Мы можем использовать оператор извлечения среза []
# для извлечения элементов, но мы не можем менять их значения:
print("t[1] = ", t[1])
# t[1] = program
print("t[0:3] =", t[0:3])
# t[0:3] = (5, 'program', (1+3j))

        
        
          
            
            Скопировать
            Скопировано
            Не удалось скопировать
          
        
      

Строка представляет собой последовательность символов. Мы можем использовать одинарные или двойные кавычки для создания строки. Многострочные строки можно обозначить тройными кавычками, ''' или """:

        
          
          s1: str = "Простая строка"s2: str = '''многострочная строка'''
          s1: str = "Простая строка"
s2: str = '''многострочная строка'''

        
        
          
            
            Скопировать
            Скопировано
            Не удалось скопировать
          
        
      

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

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

        
          
          a: set = {5,2,3,1,4}# вывод переменной множестваprint("a =", a)# a = {1, 2, 3, 4, 5}
          a: set = {5,2,3,1,4}
# вывод переменной множества
print("a =", a)
# a = {1, 2, 3, 4, 5}

        
        
          
            
            Скопировать
            Скопировано
            Не удалось скопировать
          
        
      

Над множествами можно выполнять такие операции, как объединение и пересечение. Т.к. элементы в множестве должны быть уникальны, они автоматически удаляют дубликаты:

        
          
          a: set = {1,2,2,3,3,3}print("a =", a)# a = {1, 2, 3}
          a: set = {1,2,2,3,3,3}
print("a =", a)
# a = {1, 2, 3}

        
        
          
            
            Скопировать
            Скопировано
            Не удалось скопировать
          
        
      

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

        
          
          a: set = {1, 2, 3}print(a[1])Traceback (most recent call last):  File "<stdin>", line 1, in <module>TypeError: 'set' object does not support indexing
          a: set = {1, 2, 3}
print(a[1])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'set' object does not support indexing

        
        
          
            
            Скопировать
            Скопировано
            Не удалось скопировать
          
        
      

Словари — неупорядоченные наборы пар ключ-значение.

Они используются, когда нужно сопоставить каждому из ключей значение и иметь возможность быстро получать доступ к значению, зная ключ. В других языках словари обычно называются map, hash или object. Словари оптимизированы для извлечения данных. Чтобы извлечь значение, нужно знать ключ.

Словарь объявляется парами элементов в форме ключ:значение, заключенными в фигурные скобки:

        
          
          d: dict = {1:'value', 'key':2}print(type(d))# <class 'dict'>
          d: dict = {1:'value', 'key':2}
print(type(d))
# <class 'dict'>

        
        
          
            
            Скопировать
            Скопировано
            Не удалось скопировать
          
        
      

Значение может быть любого типа, а вот ключ — только неизменяемого.

Мы используем ключ, чтобы получить соответствующее ему значение. Но не наоборот:

        
          
          d: dict = {1:'value', 'key':2}print("d[1] =", d[1])# d[1] = valueprint("d['key'] =", d['key'])# d['key'] = 2print("d[2] =", d[2]) # Приводит к ошибке
          d: dict = {1:'value', 'key':2}
print("d[1] =", d[1])
# d[1] = value
print("d['key'] =", d['key'])
# d['key'] = 2
print("d[2] =", d[2]) # Приводит к ошибке

        
        
          
            
            Скопировать
            Скопировано
            Не удалось скопировать
          
        
      

Мы можем преобразовывать значения из одного типа в другой с помощью таких функций, как int(), float(), str() и т.д. Для преобразования из/в строку должны использоваться совместимые значения:

        
          
          float(5)  # 5.0int(10.6)  # 10float('2.5')  # 2.5str(25)  # '25'int('1p')Traceback (most recent call last):  File "<stdin>", line 1, in <module>ValueError: invalid literal for int() with base 10: '1p'
          float(5)  # 5.0
int(10.6)  # 10
float('2.5')  # 2.5
str(25)  # '25'
int('1p')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '1p'

        
        
          
            
            Скопировать
            Скопировано
            Не удалось скопировать
          
        
      

Можно даже преобразовывать одну последовательность в другую:

        
          
          set([1,2,3])  # {1, 2, 3}tuple({5,6,7})  # (5, 6, 7)list('hello')  # ['h', 'e', 'l', 'l', 'o']
          set([1,2,3])  # {1, 2, 3}
tuple({5,6,7})  # (5, 6, 7)
list('hello')  # ['h', 'e', 'l', 'l', 'o']

        
        
          
            
            Скопировать
            Скопировано
            Не удалось скопировать
          
        
      

Для преобразования в словарь каждый элемент последовательности должен быть парой:

        
          
          dict([[1,2],[3,4]])  # {1: 2, 3: 4}dict([(3,26),(4,44)])  # {3: 26, 4: 44}
          dict([[1,2],[3,4]])  # {1: 2, 3: 4}
dict([(3,26),(4,44)])  # {3: 26, 4: 44}

        
        
          
            
            Скопировать
            Скопировано
            Не удалось скопировать