python_pd/03_collections/01_im_mutable_and_copy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Неизменяемые типы данных\n",
    "\n",
    "В Python все типы данных можно разделить на две группы: неизменяемые и изменяемые. Значение некоторых объектов может измениться в процессе работы программы. Объекты, чье значение может измениться, называются изменяемыми; объекты, значение которых неизменяемо после их создания, называются неизменяемыми. Изменчивость объекта определяется его типом. Неизменяемыми типами являются все простые типы и кортежи:\n",
    "- неизменяемые:\n",
    "    - числа (```int```, ```float```, ```complex```);\n",
    "    - ```bool```;\n",
    "    - ```None```;\n",
    "    - ```str```;\n",
    "    - ```tuple```;\n",
    "    - ```range```.\n",
    "\n",
    "Если объект имеет неизменяемый тип данных, это означает, что нельзя изменить значение этого объекта без его пересоздания. Например, в выражении\n",
    "\n",
    "```python\n",
    "a = 355\n",
    "a += 1\n",
    "```\n",
    "\n",
    "сначала будет создан объект целого числа со значением ```355```, затем на основе этого объекта будет создан другой объект с новым значением ```355 + 1 = 356```, который будет связан с именем ```a```. Предыдущий объект со значением ```355```, в случае если нигде не используется, подлежит удалению сборщиком мусора.\n",
    "\n",
    "<img src=\"image/immutable.png\">\n",
    "\n",
    "В этом можно легко убедиться, воспользовавшись функцией ```id```, которая возвращает адрес в памяти, где храниться объект. У объекта со значением ```355``` и ```356``` будут разные адреса в памяти."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "id(355) = 2797079820720\n",
      "id(356) = 2797079821136\n"
     ]
    }
   ],
   "source": [
    "a = 355\n",
    "print(f'id({a}) = {id(a)}')\n",
    "\n",
    "a += 1\n",
    "print(f'id({a}) = {id(a)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Остальные неизменяемые типы данных работают аналогичным образом. Отдельного упоминания стоят объекты типов ```bool```, ```NoneType``` и ```tuple```. Объекты ```True``` и ```False```, имеющие тип ```bool```, и объект ```None``` типа ```NoneType``` всегда хранятся в памяти в единственном экземпляре. Это означает, что невозможно создать новый объект типа ```bool``` или ```NoneType```. Такие объекты называются синглтонами."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is b is c = True\n"
     ]
    }
   ],
   "source": [
    "a = None\n",
    "b = None\n",
    "c = None\n",
    "\n",
    "# проверим объекты на идентичность, т.е. сравним \n",
    "# адреса в памяти с помощью оператора is\n",
    "print(f'{a is b is c = }')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Две константы True: a is b = True\n",
      "Две константы False: c is d = True\n"
     ]
    }
   ],
   "source": [
    "a, b = True, True\n",
    "c, d = False, False\n",
    "\n",
    "# аналогично проверим две \"разные\" константы True и False\n",
    "print(f'Две константы True: {a is b = }')\n",
    "print(f'Две константы False: {c is d = }')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = True, b = True\n",
      "a is b = True\n"
     ]
    }
   ],
   "source": [
    "# преобразуем тип int в bool и проверим еще раз\n",
    "a = bool(5)\n",
    "b = bool(196)\n",
    "\n",
    "print(f'{a = }, {b = }')\n",
    "print(f'{a is b = }')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Кортеж или ```tuple``` - это единственная неизменяемая стандартная коллекция. Все стандартные коллекции в Python это ссылочные типы данных. В ячейках кортежей, списков и словарей хранятся не объекты, а только ссылки на эти объекты. Ссылка только указывает в каком месте памяти искать нужный объект. Кортежи тоже хранят ссылки на объекты. \n",
    "\n",
    "<img src=\"image/tuple.png\" align=\"center\">\n",
    "\n",
    "Неизменяемость кортежа не позволяет изменять эти ссылки, т.е. неизменным является физическое содержимое кортежа, состоящее только из ссылок на объекты. Это полностью согласуется с ситуацией, когда в кортеже хранятся изменяемые типы данных, например, списки. Кортеж содержит ссылку на список — и список может быть *изменен*, но не может быть *заменен* другим списком.\n",
    "\n",
    "<img src=\"image/tuple_2.png\" align=\"center\">\n",
    "\n",
    "Список, на который ссылается кортеж, может измениться, но идентификатор объекта (списка), на который ссылаются, будет все тот же. У кортежа нет способа предотвратить изменение значений его элементов, которые являются независимыми объектами и могут быть доступны через ссылки вне кортежа. Списки и другие изменяемые объекты внутри кортежей могут изменяться, но их идентификаторы всегда будут одинаковыми."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "id(a) = 2797080176896\n",
      "id(b) = 2797080122208\n",
      "id(b[-1]) = 2797080176896\n",
      "b[-1] is a = True\n",
      "Изменение списка через имя a:\n",
      "a = [1, 2, 3, 42]\n",
      "b = (4, 5, 6, [1, 2, 3, 42])\n",
      "id(a) = 2797080176896\n",
      "id(b[-1]) = 2797080176896\n",
      "Изменение списка через кортеж:\n",
      "a = [2, 3, 42]\n",
      "b = (4, 5, 6, [2, 3, 42])\n",
      "id(a) = 2797080176896\n",
      "id(b[-1]) = 2797080176896\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3]\n",
    "b = (4, 5, 6, a)\n",
    "\n",
    "print(f'{id(a) = }')\n",
    "print(f'{id(b) = }')\n",
    "print(f'{id(b[-1]) = }')\n",
    "print(f'{b[-1] is a = }')\n",
    "\n",
    "print('Изменение списка через имя a:')\n",
    "a.append(42)\n",
    "print(f'{a = }')\n",
    "print(f'{b = }')\n",
    "print(f'{id(a) = }')\n",
    "print(f'{id(b[-1]) = }')\n",
    "\n",
    "print('Изменение списка через кортеж:')\n",
    "b[-1].pop(0)\n",
    "print(f'{a = }')\n",
    "print(f'{b = }')\n",
    "print(f'{id(a) = }')\n",
    "print(f'{id(b[-1]) = }')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Изменение кортежа через конкатенацию ведет к созданию нового объекта по аналогии с числами."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = (1, 2, 3), b = (1, 2, 3, 4)\n",
      "a is b = False\n",
      "id(a) = 2797080107904\n",
      "id(b) = 2797079955632\n"
     ]
    }
   ],
   "source": [
    "a = (1, 2, 3)\n",
    "b = a + (4, )\n",
    "\n",
    "print(f'{a = }, {b = }')\n",
    "print(f'{a is b = }')\n",
    "print(f'{id(a) = }')\n",
    "print(f'{id(b) = }')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Замена ссылки в кортеже запрещено."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "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-7-17ed0150d57f>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0mc\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m5\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m6\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0ma\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[0mc\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[0mb\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",
    "b = [4, 5]\n",
    "c = (4, 5, 6, a)\n",
    "\n",
    "c[-1] = b  # TypeError"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Изменяемые типы данных\n",
    "\n",
    "В отличие от неизменяемых типов данных, изменяемые типы позволяют изменять значения объектов. Изменяемыми типами являются остальные стандартные коллекции:\n",
    "- ```list```;\n",
    "- ```dict```;\n",
    "- ```set```.\n",
    "\n",
    "При изменении значения объекта, например, добавлении элемента в список, не происходит изменение адреса в памяти."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Адрес до изменения: id(a) = 2797079841856\n",
      "Адрес после изменения: id(a) = 2797079841856\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3]\n",
    "print(f'Адрес до изменения: {id(a) = }')\n",
    "\n",
    "a.append(4)\n",
    "print(f'Адрес после изменения: {id(a) = }')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Деление объектов на изменяемые и неизменяемые приводит к некоторой особенности поведения оператора ```=```. Он только создает еще одну ссылку на тот же объект. Попытка изменить неизменяемый объект приведет к созданию нового объекта и имена, ранее связанные с одним объектом, станут связаны с разными. Это легко продемонстрировать на числах."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is b = True\n",
      "a = 196, b = 197\n",
      "a is b = False\n"
     ]
    }
   ],
   "source": [
    "a = 196\n",
    "# создается еще одна ссылка на объект 196\n",
    "b = a\n",
    "\n",
    "# a и b указывают на одно место в памяти\n",
    "print(f'{a is b = }')\n",
    "\n",
    "# b связывается с новым объектом 197, но ссылка от имени a никуда \n",
    "# не пропадает, теперь a и b указывают на разные объекты в памяти\n",
    "b += 1\n",
    "print(f'{a = }, {b = }')\n",
    "print(f'{a is b = }')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "С изменяемыми объектами это работает немного иначе, т.к. создание нового объекта при изменении не происходит."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is b = True\n",
      "a is b = True\n",
      "b = [1, 2, 3, 42]\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3]\n",
    "# создание второй ссылки на список \n",
    "b = a\n",
    "\n",
    "# a и b указывают на одно место в памяти\n",
    "print(f'{a is b = }')\n",
    "\n",
    "a.append(42)\n",
    "# a и b все еще указывают на одно место в памяти\n",
    "print(f'{a is b = }')\n",
    "print(f'{b = }')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Копирование\n",
    "\n",
    "Зачастую возникает необходимость скопировать изменяемый объект, чтобы изменения, совершаемые в копии, не касались оригинального объекта. В Python существует два вида копии:\n",
    "- поверхностная;\n",
    "- глубокая.\n",
    "\n",
    "## Поверхностное копирование\n",
    "\n",
    "Способов создать поверхностную копию довольно много. Вот некоторые конструкции, которые ее возвращают:\n",
    "- функции ```list```, ```dict```, ```set```\n",
    "- срезы, в частности ```[:]```\n",
    "- метод ```copy```\n",
    "- функция ```copy``` из модуля ```copy```\n",
    "\n",
    "Поверхностное копирование создает новый объект или копию эквивалентную копируемому объекту верхнего уровня. Затем переносятся ссылки из копируемого объекта в копию. Вложенные структуры, если они есть не копируются.\n",
    "\n",
    "```python\n",
    "a = [1, 2, 3]\n",
    "b = list(a)\n",
    "```\n",
    "\n",
    "<img src=\"image/copy.png\" align=\"center\">\n",
    "\n",
    "### Копирование списка"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Объекты до изменения: a = [1, 2, 3], b = [1, 2, 3]\n",
      "a is b = False\n",
      "0: a[i] is b[i] = True\n",
      "1: a[i] is b[i] = True\n",
      "2: a[i] is b[i] = True\n",
      "После изменения оригинала: a = [-4, 2, 3, 42], b = [1, 2, 3]\n",
      "После изменения копии: a = [-4, 2, 3, 42], b = [2, 3]\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3]\n",
    "\n",
    "# создание поверхностной копии списка\n",
    "b = list(a)\n",
    "print(f'Объекты до изменения: {a = }, {b = }')\n",
    "# a и b указывают на разные объекты\n",
    "print(f'{a is b = }')\n",
    "\n",
    "# содержимое указывает на одни и теже объекты\n",
    "for i in range(len(a)):\n",
    "    print(f'{i}: {a[i] is b[i] = }')\n",
    "\n",
    "# изменение оригинального объекта\n",
    "a.append(42)\n",
    "a[0] = -4\n",
    "# b не изменяется\n",
    "print(f'После изменения оригинала: {a = }, {b = }')\n",
    "\n",
    "# изменение копии\n",
    "b.pop(0)\n",
    "# a не изменяется\n",
    "print(f'После изменения копии: {a = }, {b = }')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Изменение значения, например, в копии ведет к удалению ссылки на старый объект и созданию нового объекта. При этом в оригинале остается ссылка на прежний объект. \n",
    "\n",
    "<img src=\"image/copy_2.png\">\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: a[i] is b[i] = True\n",
      "1: a[i] is b[i] = True\n",
      "2: a[i] is b[i] = False\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3]\n",
    "b = list(a)\n",
    "\n",
    "b[-1] = 4\n",
    "\n",
    "for i in range(len(a)):\n",
    "    print(f'{i}: {a[i] is b[i] = }')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Копия с помощью среза\n",
      "a is l = False\n",
      "После изменения копии: a = [1, 2, 3], l = [1, 0, 3]\n",
      "--------------------------------------------------\n",
      "Копия с помощью метода copy\n",
      "a is l = False\n",
      "После изменения копии: a = [1, 2, 3], l = [1, 0, 3]\n",
      "--------------------------------------------------\n",
      "Копия с помощью функции copy\n",
      "a is l = False\n",
      "После изменения копии: a = [1, 2, 3], l = [1, 0, 3]\n",
      "--------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "import copy\n",
    "\n",
    "\n",
    "a = [1, 2, 3]\n",
    "copy_list = [\n",
    "    ('Копия с помощью среза', a[:]), \n",
    "    ('Копия с помощью метода copy', a.copy()), \n",
    "    ('Копия с помощью функции copy', copy.copy(a)),\n",
    "]\n",
    "\n",
    "for name, l in copy_list:\n",
    "    print(name)\n",
    "    print(f'{a is l = }')\n",
    "    # изменение копии\n",
    "    l[1] = 0\n",
    "    print(f'После изменения копии: {a = }, {l = }')\n",
    "    print('-' * 50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Копирование словарей\n",
    "\n",
    "Копию словаря можно создать теме же способами что и копию списка, за исключением срезов. У словарей нет операции взятия среза. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Копия с помощью функции dict\n",
      "a is d = False\n",
      "После изменения копии: a = {'a': 1, 'b': 2, 'c': 3}, d = {'a': 1, 'c': 0}\n",
      "--------------------------------------------------\n",
      "Копия с помощью метода copy\n",
      "a is d = False\n",
      "После изменения копии: a = {'a': 1, 'b': 2, 'c': 3}, d = {'a': 1, 'c': 0}\n",
      "--------------------------------------------------\n",
      "Копия с помощью функции copy\n",
      "a is d = False\n",
      "После изменения копии: a = {'a': 1, 'b': 2, 'c': 3}, d = {'a': 1, 'c': 0}\n",
      "--------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "import copy\n",
    "\n",
    "\n",
    "a = {'a': 1, 'b': 2, 'c': 3}\n",
    "\n",
    "copy_dict = [\n",
    "    ('Копия с помощью функции dict', dict(a)), \n",
    "    ('Копия с помощью метода copy', a.copy()), \n",
    "    ('Копия с помощью функции copy', copy.copy(a)),\n",
    "]\n",
    "\n",
    "for name, d in copy_dict:\n",
    "    print(name)\n",
    "    print(f'{a is d = }')\n",
    "    # изменение копии\n",
    "    d.pop('b')\n",
    "    d['c'] = 0\n",
    "    # оригинал не изменяется\n",
    "    print(f'После изменения копии: {a = }, {d = }')\n",
    "    print('-' * 50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Копирование множеств\n",
    "\n",
    "Множества - это неиндексируемая коллекция, поэтому у них нет операции взятия срезов."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Копия с помощью функции dict\n",
      "a is s = False\n",
      "После изменения копии: a = {1, 2, 3}, s = {0, 2, 3}\n",
      "--------------------------------------------------\n",
      "Копия с помощью метода copy\n",
      "a is s = False\n",
      "После изменения копии: a = {1, 2, 3}, s = {0, 2, 3}\n",
      "--------------------------------------------------\n",
      "Копия с помощью функции copy\n",
      "a is s = False\n",
      "После изменения копии: a = {1, 2, 3}, s = {0, 2, 3}\n",
      "--------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "import copy\n",
    "\n",
    "\n",
    "a = {1, 2, 3}\n",
    "\n",
    "copy_set = [\n",
    "    ('Копия с помощью функции dict', set(a)), \n",
    "    ('Копия с помощью метода copy', a.copy()), \n",
    "    ('Копия с помощью функции copy', copy.copy(a)),\n",
    "]\n",
    "\n",
    "for name, s in copy_set:\n",
    "    print(name)\n",
    "    print(f'{a is s = }')\n",
    "    # изменение копии\n",
    "    s.pop()\n",
    "    s.add(0)\n",
    "    # оригинал не изменяется\n",
    "    print(f'После изменения копии: {a = }, {s = }')\n",
    "    print('-' * 50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Копирование кортежей\n",
    "\n",
    "За счет своей неизменяемости в копировании кортежей нет необходимости. Поэтому вызов функции ```tuple()``` и получение среза всего кортежа возвращают сам объект кортежа, а не поверхностную копию как в случае со списками. Так же у кортежей нет метода ```copy()``` для создания поверхностной копии. Для кортежей несколько иначе работает и модуль ```copy```. Функция ```copy.copy()``` не копирует кортежи вне зависимости от их содержимого."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Копия с помощью функции tuple\n",
      "a is s = True\n",
      "--------------------------------------------------\n",
      "Копия с помощью среза\n",
      "a is s = True\n",
      "--------------------------------------------------\n",
      "Копия с помощью функции copy\n",
      "a is s = True\n",
      "--------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "import copy\n",
    "\n",
    "\n",
    "a = (1, 2, 3)\n",
    "\n",
    "copy_tuple = [\n",
    "    ('Копия с помощью функции tuple', tuple(a)), \n",
    "    ('Копия с помощью среза', a[:]), \n",
    "    ('Копия с помощью функции copy', copy.copy(a)),\n",
    "]\n",
    "\n",
    "for name, s in copy_tuple:\n",
    "    print(name)\n",
    "    # копии не создаются\n",
    "    print(f'{a is s = }')\n",
    "    print('-' * 50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Поверхностное копирование вложенных структур\n",
    "\n",
    "Поверхностная копия работает немного иначе, если внутри коллекции есть другие коллекции. В этом случае копирование вложенных коллекций не осуществляется.\n",
    "\n",
    "<img src=\"image/copy_3.png\" align=\"center\">\n",
    "\n",
    "Это приводит к тому, что изменение вложенных структур в оригинале будет отображаться в каждой копии и наоборот.\n",
    "\n",
    "### Копирование списков"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is b = False\n",
      "Оригинал: a = [1, 2, [3, 4, 42]]\n",
      "Поверхностная копия: b = [1, 2, [3, 4, 42]]\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, [3, 4]]\n",
    "\n",
    "b = list(a)\n",
    "print(f'{a is b = }')\n",
    "\n",
    "# изменение вложенного списка в оригинале\n",
    "a[-1].append(42)\n",
    "\n",
    "print(f'Оригинал: {a = }')\n",
    "print(f'Поверхностная копия: {b = }')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Копирование словарей"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is b = False\n",
      "Оригинал: a = {'a': 1, 'b': 2, 'c': [3, 4, 42]}\n",
      "Поверхностная копия: b = {'a': 1, 'b': 2, 'c': [3, 4, 42]}\n"
     ]
    }
   ],
   "source": [
    "a = {'a': 1, 'b': 2, 'c': [3, 4]}\n",
    "\n",
    "b = dict(a)\n",
    "print(f'{a is b = }')\n",
    "\n",
    "# изменение вложенного списка в оригинале\n",
    "a['c'].append(42)\n",
    "\n",
    "print(f'Оригинал: {a = }')\n",
    "print(f'Поверхностная копия: {b = }')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Копирование множеств\n",
    "\n",
    "Во множествах нельзя хранить изменяемые типы данных. Они могут содержать только кортежи, внутри которых находятся только неизменяемые типы. Это исключает проблему изменения вложенных коллекций после копирования."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c is b = False\n",
      "1: item is a = False\n",
      "2: item is a = False\n",
      "(3, 4): item is a = True\n",
      "После изменения кортежа: a = (3, 4, 1), b = {1, 2, (3, 4)}, c = {1, 2, (3, 4)}\n"
     ]
    }
   ],
   "source": [
    "a = (3, 4)\n",
    "b = {1, 2, a}\n",
    "c = set(b)\n",
    "print(f'{c is b = }')\n",
    "\n",
    "# копия множества содержит ссылку на тот же кортеж, что и оригинал\n",
    "for item in c:\n",
    "    print(f'{item}: {item is a = }')\n",
    "\n",
    "a += (1, )\n",
    "print(f'После изменения кортежа: {a = }, {b = }, {c = }')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Копирование кортежей"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is b = True\n",
      "Оригинал: a = (1, 2, [3, 4, 42])\n",
      "Поверхностная копия: b = (1, 2, [3, 4, 42])\n"
     ]
    }
   ],
   "source": [
    "a = (1, 2, [3, 4])\n",
    "\n",
    "b = tuple(a)\n",
    "print(f'{a is b = }')\n",
    "\n",
    "# изменение вложенного списка в оригинале\n",
    "a[-1].append(42)\n",
    "\n",
    "print(f'Оригинал: {a = }')\n",
    "print(f'Поверхностная копия: {b = }')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Глубокое копирование\n",
    "\n",
    "Глубокое копирование осуществляет полное копирование объекта вместе со всеми вложенными объектами. Это очень затратная операция. Ее можно создать только одним способом - с помощью функции ```deepcopy``` из модуля ```copy```. \n",
    "\n",
    "Одномерные коллекции, содержащие объекты неизменяемых типов данных не имеет смысла копировать с помощью ```deepcopy```, т.к. их поведение уже схоже с глубокой копией. Так использовать глубокое копирования для множеств не нужно, т.к. они по определению содержат только неизменяемые объекты.\n",
    "\n",
    "Глубокую копию нужно применять только для вложенных структур, например, многомерных списков или вложенных словарей.\n",
    "\n",
    "### Копирование списков"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is b = False\n",
      "0: a[i] is b[i] = False\n",
      "1: a[i] is b[i] = False\n",
      "2: a[i] is b[i] = False\n",
      "a[0] = [0, 2, 3], b[0] = [1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "import copy\n",
    "\n",
    "\n",
    "a = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
    "b = copy.deepcopy(a)\n",
    "print(f'{a is b = }')\n",
    "\n",
    "# вложенные списки скопированы\n",
    "for i in range(3):\n",
    "    print(f'{i}: {a[i] is b[i] = }')\n",
    "\n",
    "# изменение элемента во вложенном списке\n",
    "a[0][0] = 0\n",
    "print(f'{a[0] = }, {b[0] = }')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Копирование словарей"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a: d[key] is b[key] = False\n",
      "b: d[key] is b[key] = False\n",
      "c: d[key] is b[key] = False\n"
     ]
    }
   ],
   "source": [
    "d = {'a': ['attack', 'all', 'any'], 'b': ['bar', 'baz', 'basic'], 'c': ['cake', 'cube', 'companion']}\n",
    "b = copy.deepcopy(d)\n",
    "\n",
    "# вложенные списки скопированы\n",
    "for key in d:\n",
    "    print(f'{key}: {d[key] is b[key] = }')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Копирование кортежей\n",
    "\n",
    "Функция ```deepcopy``` создаст глубокую копию кортежа только в случае, если он содержит изменяемй тип данных, т. е. список, словарь или множество."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Глубокая копия a: a is c = True\n",
      "Глубокая копия b: b is d = False\n",
      "Оригинал: b = (1, 2, [42, 0])\n",
      "Копия: d = (1, 2, [42])\n"
     ]
    }
   ],
   "source": [
    "import copy\n",
    "\n",
    "\n",
    "a = (1, 2, 3)\n",
    "b = (1, 2, [42])\n",
    "\n",
    "c = copy.deepcopy(a)\n",
    "d = copy.deepcopy(b)\n",
    "\n",
    "print(f'Глубокая копия a: {a is c = }')\n",
    "print(f'Глубокая копия b: {b is d = }')\n",
    "\n",
    "b[-1].append(0)\n",
    "print(f'Оригинал: {b = }')\n",
    "print(f'Копия: {d = }')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Полезные ссылки\n",
    "\n",
    "- [Документация по модели данных в Python](https://docs.python.org/3/reference/datamodel.html#objects-values-and-types)\n",
    "- [Immutable vs Mutable types](https://stackoverflow.com/questions/8056130/immutable-vs-mutable-types)\n",
    "- [Mutable vs Immutable Objects in Python](https://medium.com/@meghamohan/mutable-and-immutable-side-of-python-c2145cf72747)\n",
    "- [Python tuples: immutable but potentially changing](http://radar.oreilly.com/2014/10/python-tuples-immutable-but-potentially-changing.html)"
   ]
  }
 ],
 "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
}