python_pd/03_collections/basic_collections/04_tuple.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Кортежи (```tuple```)\n",
    "\n",
    "Помимо списков и словарей в Python реализовано еще несколько стандартных коллекцией. Одной из таких являются кортежи. Кортежи - это неизменяемая коллекция, которая по своему подобию очень похожа на список. Кортежи можно создавать с помощью литерала круглых скобок ```()``` или с помощью одноименной функции ```tuple()```. Кортежи имеют одноименный тип ```tuple```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "type(a) = <class 'tuple'>\n",
      "type(b) = <class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "a = ()\n",
    "b = tuple()\n",
    "print(f'{type(a) = }')\n",
    "print(f'{type(b) = }')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Непустой кортеж можно создать, записывая в круглых скобках элементы кортежа и разделяя их запятой. Одно из отличий от списков заключается в создании коллекции из одного элемента. Кортеж из одного элемента нельзя создать с помощью выражения ```(42)```, необходимо обязательно ставить запятую, т. е. ```(42, )```. Скобки можно опускать и записывать сразу элементы через запятую, в этом случае интерпретатор тоже создаст кортеж. Для большей читаемости кода не следует опускать скобки в одноэлементных кортежах."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = (1, 2, 3)\n",
      "b = (42,)\n",
      "c = (1, 2, 3)\n",
      "d = (0,)\n"
     ]
    }
   ],
   "source": [
    "a = (1, 2, 3)\n",
    "b = (42, )\n",
    "c = 1, 2, 3\n",
    "d = 0,\n",
    "print(f'{a = }')\n",
    "print(f'{b = }')\n",
    "print(f'{c = }')\n",
    "print(f'{d = }')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В кортежах, как и в списках, можно хранить разные типы данных, в том числе изменяемые, например, списки, словари и др. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "foo = (\n",
    "    'parker_square',  # str\n",
    "    True, False,  # bool\n",
    "    None,  # NoneType\n",
    "    (42, 0.196, 1+2j),  # tuple[int, float, complex]\n",
    "    [1, 2, 3],   # list[int]\n",
    "    {\n",
    "        'monty': 'python', \n",
    "        '42': 'The Ultimate Question of Life, the Universe, and Everything',\n",
    "    },  # dict\n",
    "    print,  # function\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Кортежи - это неизменяемый тип данных. Они хранят ссылки на объекты. Поэтому в кортежах можно хранить ссылку на изменяемые типы данных. При этом объекты изменяемых типов, хранимые в кортежах, по-прежнему можно изменять. Если в программе не планируется изменять какой-либо набор значений, то стоит выбрать кортеж для их хранения. \n",
    "\n",
    "Работа изменяемых и неизменяемых типов данных будет рассмотрена позденее. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = (1, 2, [42, 0])\n"
     ]
    }
   ],
   "source": [
    "a = (1, 2, [42])\n",
    "a[-1].append(0)\n",
    "print(f'{a = }')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Однако, изменять сами элементы кортежа не разрешено. Попытка произвести эту операцию вызывает исключение ```TypeError```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-5-d8083caab6e5>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0ma\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;36m42\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0ma\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m0\u001b[0m  \u001b[1;31m# TypeError\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "a = (1, 2, [42])\n",
    "a[-1] = 0  # TypeError"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Операции с кортежами\n",
    "\n",
    "Кортежи - это неизменяемая коллекция. Поэтому они не поддерживают операции добавления, удаления и изменения элементов. Все остальные операции, аналогичнуе спискам, доступны:\n",
    "- индексирование;\n",
    "- срезы;\n",
    "- вычисление длины;\n",
    "- конкатенация;\n",
    "- умножение на константу;\n",
    "- подсчет всех вхождений элемента;\n",
    "- поиск первого вхождения элемента;\n",
    "- и другие."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Длина: len(a) = 4\n",
      "Конкатенация: a + b = (1, 2, 3, 1, 3, 4)\n",
      "Умножение на целочисленную константу: 3 * a = (1, 2, 3, 1, 1, 2, 3, 1, 1, 2, 3, 1)\n",
      "Индексация: a[0] = 1\n",
      "Индексация: a[-2] = 3\n",
      "Срез: (2, 1)\n",
      "Индекс первого вхождения: a.index(1) = 0\n",
      "Подсчет всех вхлждения: a.count(1) = 2\n"
     ]
    }
   ],
   "source": [
    "a = (1, 2, 3, 1)\n",
    "b = 3, 4\n",
    "\n",
    "print(f'Длина: {len(a) = }')\n",
    "print(f'Конкатенация: {a + b = }')\n",
    "print(f'Умножение на целочисленную константу: {3 * a = }')\n",
    "print(f'Индексация: {a[0] = }')\n",
    "print(f'Индексация: {a[-2] = }')\n",
    "print(f'Срез: {a[1::-1]}')\n",
    "print(f'Индекс первого вхождения: {a.index(1) = }')\n",
    "print(f'Подсчет всех вхлждения: {a.count(1) = }')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Одним из применений кортежей является замена объектов и их имен местами. В Python выражения оцениваются слева на право (см. [документацию](https://docs.python.org/3/reference/expressions.html#evaluation-order)). Выражение ```a, b = b, a``` будет выполняться в следующем порядке. Сначала выполниться левая часть, т. е. будет создан кортеж из двух элементов со ссылками на объекты, на которые ссылаются ```b``` и ```a``` соответственно. Затем кортеж будет связан с правой частью. Так как в правой части стоят два имени, то он будет распакован. Таким образом первый элемент кортежа, которых хранит ссылку на объект из ```b``` будет связан с именем ```a```, затем тоже самое произойдет со вторым элементом кортежа, он будет связан с именем ```b```. Про замену значений читайте [обсуждение](https://stackoverflow.com/questions/14836228/is-there-a-standardized-method-to-swap-two-variables-in-python) на stackoverflow."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = 0\n",
      "b = 42\n"
     ]
    }
   ],
   "source": [
    "a, b = 42, 0\n",
    "b, a = a, b\n",
    "print(f'{a = }')\n",
    "print(f'{b = }')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В Python есть специальный модуль ```dis``` для просмотра байт-кода. Это специальное представление программы, которое непосредственно выполняется интерпретатором.\n",
    "\n",
    "Убедиться в порядке выполнения этого выражения можно с помощью модуля ```dis``` и его функции ```dis```, которая принимает строку Python кода."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  2           0 LOAD_CONST               0 ((1, 2))\n",
      "              2 UNPACK_SEQUENCE          2\n",
      "              4 STORE_NAME               0 (a)\n",
      "              6 STORE_NAME               1 (b)\n",
      "\n",
      "  3           8 LOAD_NAME                1 (b)\n",
      "             10 LOAD_NAME                0 (a)\n",
      "             12 ROT_TWO\n",
      "             14 STORE_NAME               0 (a)\n",
      "             16 STORE_NAME               1 (b)\n",
      "             18 LOAD_CONST               1 (None)\n",
      "             20 RETURN_VALUE\n"
     ]
    }
   ],
   "source": [
    "import dis\n",
    "\n",
    "code = \"\"\"\n",
    "a, b = 1, 2\n",
    "a, b = b, a\n",
    "\"\"\"\n",
    "\n",
    "dis.dis(code)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Блок с номером 2 отвечает за выполнение строки ```a, b = 1, 2```, а с номером 3 за строку ```a, b = b, a```. Здесь можно увидеть, что в первой строке снача создается константа в виде кортежа из двух элементов 1 и 2.\n",
    "\n",
    "```0 LOAD_CONST               0 ((1, 2))``` \n",
    "\n",
    "Затем выполняется операция распаковки. Эта операция связывает каждый элемент из кортежа с соответствующим именем в порядке следования."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Кортежи или списки можно удобно использовать в различных условиях\n",
    "вместе с функциями `any` и `all`. Продемонстрируем на примере условия с\n",
    "тремя флагами.\n",
    "\n",
    "Один из не самых лучших вариантов это сравнить каждый флаг с 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OK\n"
     ]
    }
   ],
   "source": [
    "a, b, c = 0, 1, 0\n",
    "\n",
    "if a == 1 or b == 1 or c == 1:\n",
    "    print('OK')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Самым верным вариантом будет использовать свойства истинности объектов и\n",
    "просто объединить переменные оператором `or`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OK\n"
     ]
    }
   ],
   "source": [
    "if a or b or c:\n",
    "    print('OK')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Есть и другие варианты. Например, использовать оператор `in`. Работа\n",
    "такого выражения будет аналогична вариантам выше."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OK\n"
     ]
    }
   ],
   "source": [
    "if 1 in (a, b, c):\n",
    "    print('OK')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если нужно проверить истинность хотя бы одного объекта в коллекции лучше\n",
    "всего использовать функцию `any`. Которая эквивалентна объединению всех\n",
    "элементов последовательности операторами `or`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OK\n"
     ]
    }
   ],
   "source": [
    "if any((a, b, c)):\n",
    "    print('OK')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Еще одна функция, но проверяющая истинность сразу всех объектов, это\n",
    "`all`. Как не трудно догадаться она будет аналогом объединения всех\n",
    "элементов оператором `and`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NO\n"
     ]
    }
   ],
   "source": [
    "if all((a, b, c)):\n",
    "    print('OK')\n",
    "else:\n",
    "    print('NO')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Кортежи vs списки\n",
    "\n",
    "Для ясного понимания в каких ситуациях стоит использовать списки, а каких кортежи нужно подробнее разобрать достоинства и недостатки обоих типов данных. Основным отличием этих типов является изменяемость. Кортежи -- это неизменяемый тип данных, а списки наоборот изменяемый. Это означает, что при попытке, например, добавить к кортежу новый элемент, произойдет создание абсолютно нового объекта. Поведение списков в этом плане совершенно другое. При добавлении или удалении элементов списка пересоздание объекта происходить не будет. Не стоит забывать, что из-за неизменяемости кортежей у них нет специализированных методов для операций добавления, удаления и вставки. Это означает, что добавить элемент в кортеж можно только конкатенацией его с другим кортежем."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "id_a == id(a) = False\n",
      "id_b == id(b) = True\n"
     ]
    }
   ],
   "source": [
    "a = (1, 2, 3)\n",
    "b = [1, 2, 3]\n",
    "id_a = id(a)\n",
    "id_b = id(b)\n",
    "a += (196, )\n",
    "b += [196]\n",
    "print(f'{id_a == id(a) = }')\n",
    "print(f'{id_b == id(b) = }')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Изменять элементы кортежа также не разрешено."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-15-95f58b93f623>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0ma\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m3\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0ma\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m0\u001b[0m  \u001b[1;31m# TypeError\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "a = (1, 2, 3)\n",
    "a[0] = 0  # TypeError"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Поскольку размер кортежей фиксирован и у них отсутствуют методы добавления и удаления элементов, то в памяти они хранятся несколько более эффективно, чем списки. Это связано с тем, что в списках заранее выделяется несколько больший размер памяти, чем требуется для хранения элементов, для обеспечения большей эффективности добавления новых элементов."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Размер списка a: 120 байт\n",
      "Размер кортежа b: 104 байт\n"
     ]
    }
   ],
   "source": [
    "a = list(range(10))\n",
    "b = tuple(a)\n",
    "print(f'Размер списка a: {a.__sizeof__()} байт')\n",
    "print(f'Размер кортежа b: {b.__sizeof__()} байт')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Быстродействие разных операций с кортежами (создание, распаковка, доступ по индексу) также отличается от быстродействия этих операций со списками. Для измерения быстродействия воспользуемся модулем ```timeit```, подробнее о нем см. в [документации](https://docs.python.org/3/library/timeit.html). Если список или кортеж состоят из значений неизменяемых типов данных, кортеж сильно выигрывает в быстродействии операций создания и распаковки. Ситуация изменяется, когда в кортеже необходимо хранить объекты изменяемых типов. В этом случае различия в быстродействии становятся не такими значительными. Операция доступа по индексу осуществляется за сравнимое время у обоих типов коллекций."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Создание списка (1): 0.09184330000005048\n",
      "Создание кортежа (1): 0.01157680000005712\n",
      "Распаковка списка (1): 0.09308040000007622\n",
      "Распаковка кортежа (1): 0.03135259999999107\n",
      "--------------------------------------------------\n",
      "Создание списка (2): 0.10378170000001319\n",
      "Создание кортежа (2): 0.12557390000006308\n",
      "Распаковка списка (2): 0.1278416999999763\n",
      "Распаковка кортежа (2): 0.06713860000002114\n",
      "--------------------------------------------------\n",
      "Индексация списка: 0.46414019999997436\n",
      "Индексация кортежа: 0.4314108999999462\n"
     ]
    }
   ],
   "source": [
    "import timeit\n",
    "\n",
    "print(f'Создание списка (1): {timeit.timeit(\"[1, 2, 3]\")}')\n",
    "print(f'Создание кортежа (1): {timeit.timeit(\"(1, 2, 3)\")}')\n",
    "print(f'Распаковка списка (1): {timeit.timeit(\"x, y, z = [1, 2, 3]\")}')\n",
    "print(f'Распаковка кортежа (1): {timeit.timeit(\"x, y, z = (1, 2, 3)\")}')\n",
    "print('-' * 50)\n",
    "\n",
    "print(f'Создание списка (2): {timeit.timeit(\"[1, 2, [42]]\")}')\n",
    "print(f'Создание кортежа (2): {timeit.timeit(\"(1, 2, [42])\")}')\n",
    "print(f'Распаковка списка (2): {timeit.timeit(\"x, y, z = [1, 2, [42]]\")}')\n",
    "print(f'Распаковка кортежа (2): {timeit.timeit(\"x, y, z = (1, 2, [42])\")}')\n",
    "print('-' * 50)\n",
    "\n",
    "print(f'Индексация списка: {timeit.timeit(\"a[1]\", setup=\"a = [1, 2, 3]\", number=10_000_000)}')\n",
    "print(f'Индексация кортежа: {timeit.timeit(\"a[1]\", setup=\"a = (1, 2, 3)\", number=10_000_000)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Различия в производительности заключаются в оптимизациях, которые выполняются над кортежами. Ниже приведен пример байт-кода создания списка и кортежа, сгенерированный с помощью модуля ```dis```. В приведенном байт-коде видно, что при создании списка поочередно создаются объекты, которые в него входят. С созданием кортежа дело обстоит иначе. Он создается за одну операцию. Здесь используется оптимизация, называемая [сверткой констант](https://ru.wikipedia.org/wiki/%D0%A1%D0%B2%D1%91%D1%80%D1%82%D0%BA%D0%B0_%D0%BA%D0%BE%D0%BD%D1%81%D1%82%D0%B0%D0%BD%D1%82). Если интерпретатору доступны все значения, которые будут храниться в кортеже, то он их вычисляет заранее."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  1           0 BUILD_LIST               0\n",
      "              2 LOAD_CONST               0 ((1, 2, 3))\n",
      "              4 LIST_EXTEND              1\n",
      "              6 RETURN_VALUE\n"
     ]
    }
   ],
   "source": [
    "import dis\n",
    "\n",
    "dis.dis('[1, 2, 3]')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  1           0 LOAD_CONST               0 ((1, 2, 3))\n",
      "              2 RETURN_VALUE\n"
     ]
    }
   ],
   "source": [
    "dis.dis('(1, 2, 3)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Подводя итог, различия списков и кортежей можно представить в виде таблицы.\n",
    "\n",
    "| Критерий                | Список                             | Кортеж                     |\n",
    "|-------------------------|:----------------------------------:|:--------------------------:|\n",
    "| *Литералы*              | ```[]```                           | ```()```                   |\n",
    "| *Функции*               | ```list```                         | ```tuple```                |\n",
    "| *Изменяемый тип*        | &#10004;                           | &#10006;                   |\n",
    "| *Сворачивание констант* | &#10006;                           | &#10004;                   |\n",
    "| *Хранимые типы данных*  | Любые, желательно однородного типа | Любые, разнородного типа   |\n",
    "| *Копирование*           | Поверхностная и глубокая копия     | Глубокая копия при наличии |\n",
    "|                         |                                    | вложенных изменяемых типов |\n",
    "| *Потребление памяти*    | Высокое, за счет дополнительных    | Ниже чем у списков         |\n",
    "|                         |       накладных расходов           |                            |\n",
    "| *Быстродействие*        | Низкое для создания, распаковки    | Высокое                    |\n",
    "\n",
    "Стоит обратить особое внимание на то, что списки предназначены для хранения последовательностей из однородных объектов. В списке индекс означает порядок следования элемента в последовательности. Кортежи, наоборот, предназначены для хранения разнородных данных. Кортежи обладают структурой, т. е. индекс элемента не просто указывает на порядок следования элемента в последовательности, но и имеет определенный смысл. Например с помощью модуля ```time``` можно узнать текущее время и результат можно представить в виде кортежа чисел, где на первом месте всегда идет год, затем месяц и т. д. Другим примером является координаты точек в трехмерном пространстве, представимых в виде ```(x, y, z)```, или что тоже самое координаты геопозиционирования с широтой, долготой и высотой. Упорядочивать или сортировать такие последовательности не имеет смысла, иначе потеряется исходная структура данных и они станут бесполезными. Поэтому, если необходимо хранить данные, которые обладают некоторым смыслом, например данные о человеке (имя, фамилию, возраст и т. д.), то стоит выбирать кортеж."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Год: 2021\n",
      "Месяц: 10\n",
      "День: 23\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "\n",
    "date = time.localtime()\n",
    "print(f'Год: {date[0]}')\n",
    "print(f'Месяц: {date[1]}')\n",
    "print(f'День: {date[2]}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Полезные ссылки\n",
    "\n",
    "- [Кортежи более эффективны, чем списки в Python? (здесь можно посмотреть как кортежи и списки представлены в виде Си структур)](https://stackoverflow.com/questions/68630/are-tuples-more-efficient-than-lists-in-python)\n",
    "- [В чем разница между списками и кортежами? (здесь хорошо описано, в какиких случаях стоит применять кортежи)](https://stackoverflow.com/questions/626759/whats-the-difference-between-lists-and-tuples)"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "178cad48488a45b94c2e1acb3bfd8ec03d0e926b0801a270a439a0363b59c19a"
  },
  "kernelspec": {
   "display_name": "Python 3.9.0 64-bit ('.venv': venv)",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.0"
  },
  "orig_nbformat": 2
 },
 "nbformat": 4,
 "nbformat_minor": 2
}