lessons/python_advanced/deep_and_shallow_copy.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "print(\"Python Version:\", sys.version, '\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Deep and Shallow Copy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The way Python treats variables is a bit frustrating at times. We're going to fully examine how it works today. The first thing to remember is that the variable doesn't contain the value. What it contains is the memory location of the value. So we'll need to play some games to make sure we get what we want when assigning things to variables.\n",
    "\n",
    "Let's start by looking at an example with just an integer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 5\n",
    "b = a\n",
    "a = a + 7\n",
    "\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Well, that behaved about as we expected. Now let's try it with a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1,2,3,4]\n",
    "b = a\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.append(7)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Whoa. Changing `a`, actually changed `b`. Is that what we expected. What if we do this one?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [5,6,7,8]\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1,2,3,4]\n",
    "b = a\n",
    "a[0] = 5\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"deep_copy_demo/deep_copy_demo.001.jpeg\"  style=\"max-width:50%; float:right;\">\n",
    "\n",
    "Python variables work by assigning *names* to values.\n",
    "\n",
    "* Immutable objects (int, float, tuple, etc) live in one spot in memory, and multiple names can point to them.\n",
    "* Mutable ojects (lists, dictionaries, dataframes) are the same, but you can change them, so changing what one name \"holds\" affects what other \"names\" access.\n",
    "\n",
    "So changing one might affect the other. Let's look at a cartoon of the memory.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What if we want to make a new list that looks like `a`? Will it do the same thing as above?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1,2,3,4]\n",
    "b = list(a)\n",
    "a[0] = 4\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"deep_copy_demo/deep_copy_demo.002.jpeg\"  style=\"max-width:50%; float:right;\">\n",
    "\n",
    "Wait, why did that work?\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we called `list(a)`, we called a constructor which asked Python to make a whole new list of the values `a` contained. That's great. \n",
    "\n",
    "#### So if that's the case, something like this should work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1,2,[3,4],5]\n",
    "b = list(a)\n",
    "a[2][0] = 1\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"deep_copy_demo/deep_copy_demo.003.jpeg\" style=\"max-width:50%; float:right;\">\n",
    "\n",
    "Well. Uhh. That's weird then. What's happened? Let's go back to our cartoon of the memory.\n",
    "\n",
    "The copy we made made a copy of each element, including the list, however it made an exact copy of the list. Meaning, the list it made just points to the same elements that the list in `a` does. The nested structure didn't get a duplicate made, just the top-level list. So our nested data (the integers inside the second list) is still just at one specific location in memory. So our copies share an address that they point to."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is known as a \"shallow copy.\" From the documentation on different types of copying:\n",
    "\n",
    ">The difference between shallow and deep copying is only relevant for compound objects (objects that contain other objects, like lists or class instances):\n",
    ">\n",
    ">- A shallow copy constructs a new compound object and then (to the extent possible) inserts references into it to the objects found in the original.\n",
    ">- A deep copy constructs a new compound object and then, recursively, inserts copies into it of the objects found in the original."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1,2,[3,6],4,5]\n",
    "b = list(a)\n",
    "a[0] = 5\n",
    "print(b) # Note that b doesn't change it's 0th spot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a[2][0] = 9\n",
    "print(b) # Note that b does change it's internal list spot 0!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from copy import deepcopy\n",
    "a = [1,2,[3,6],4,5]\n",
    "b = deepcopy(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a[2][0] = 9\n",
    "print(b) # Note that it doesn't change once we deep copy!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"deep_copy_demo/deep_copy_demo.004.jpeg\"  style=\"max-width:50%; float:right;\">\n",
    "Deep copy takes up more memory than a shallow copy, as it recreates everything recursively. However, that can be safer and necessary when working with highly nested data. If in doubt, deep copy. Unless the data's huge.\n",
    "\n",
    "In cartoon format, our deep copy looks like:\n",
    "\n",
    "\n",
    "### Additional Resources:\n",
    "- [Python Documentation](https://docs.python.org/2/library/copy.html)\n",
    "- [Video of copy types](https://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=video&cd=2&cad=rja&uact=8&ved=0ahUKEwiH78iJkOLYAhVE7GMKHb3ODmsQtwIILTAB&url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3Di7ePjqf6Y-Y&usg=AOvVaw3pH-AYImBuStUn91Ap_gz4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "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.6.5"
  },
  "toc": {
   "nav_menu": {
    "height": "66px",
    "width": "252px"
   },
   "number_sections": false,
   "sideBar": false,
   "skip_h1_title": false,
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": "block",
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}