numpy/copying.ipynb

{
 "metadata": {
  "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.1"
  },
  "orig_nbformat": 2,
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3.9.1 64-bit",
   "metadata": {
    "interpreter": {
     "hash": "e7f04c2f23573a1b4b7569d608804e4fe639f50a08b8e6ae5050edd4b669aea8"
    }
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2,
 "cells": [
  {
   "source": [
    "# Copying\n",
    "\n",
    "QUOTE: Views are an important NumPy concept! NumPy functions, as well as operations like indexing and slicing, will return views whenever possible. This saves memory and is faster (no copy of the data has to be made). However it’s important to be aware of this - modifying data in a view also modifies the original array!"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "source": [
    "## Not Copy\n",
    "\n",
    "Directly assign a numpy array to a new variable doesn't make any copy. The two variables still refer to the same memory address."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "True\n1297068598544\n1297068598544\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(10).reshape(5, 2)\n",
    "b = a\n",
    "print(b is a)\n",
    "print(id(a))\n",
    "print(id(b))"
   ]
  },
  {
   "source": [
    "## View or Shallow Copy\n",
    "\n",
    "We can use `view`, `reshape`, `slicing` (`e.g., [:10]`), etc. to create a new array object with the same values from the one we copied. But they still share the same values."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(10).reshape(5, 2)\n",
    "b = a.view()\n",
    "c = a.reshape(-1)\n",
    "d = a[:3, :1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "(array([[0, 1],\n",
       "        [2, 3],\n",
       "        [4, 5],\n",
       "        [6, 7],\n",
       "        [8, 9]]),\n",
       " array([[0, 1],\n",
       "        [2, 3],\n",
       "        [4, 5],\n",
       "        [6, 7],\n",
       "        [8, 9]]),\n",
       " array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),\n",
       " array([[0],\n",
       "        [2],\n",
       "        [4]]))"
      ]
     },
     "metadata": {},
     "execution_count": 79
    }
   ],
   "source": [
    "a, b, c, d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "(5, 2)"
      ]
     },
     "metadata": {},
     "execution_count": 81
    }
   ],
   "source": [
    "b.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "(array([[100,   1],\n",
       "        [200,   3],\n",
       "        [  4, 500],\n",
       "        [  6, 700],\n",
       "        [  8, 900]]),\n",
       " array([[100,   1],\n",
       "        [200,   3],\n",
       "        [  4, 500],\n",
       "        [  6, 700],\n",
       "        [  8, 900]]),\n",
       " array([100,   1, 200,   3,   4, 500,   6, 700,   8, 900]),\n",
       " array([[100],\n",
       "        [200],\n",
       "        [  4]]))"
      ]
     },
     "metadata": {},
     "execution_count": 82
    }
   ],
   "source": [
    "b[2:, 1:] = b[2:, 1:] * 100\n",
    "c[2] = 200\n",
    "d[0, 0] = 100\n",
    "a, b, c, d"
   ]
  },
  {
   "source": [
    "## Deep Copy\n",
    "\n",
    "The `copy` method will make a copy with new data and a new memory address from the copied one. "
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "metadata": {},
     "execution_count": 83
    }
   ],
   "source": [
    "a = np.arange(10)\n",
    "b = a.copy()\n",
    "b is a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[100   1   2   3   4   5   6   7   8   9]\n[0 1 2 3 4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "b[0] = 100\n",
    "print(b)\n",
    "print(a)"
   ]
  },
  {
   "source": [
    "QUOTE: Sometimes `copy` should be called after slicing if the original array is not required anymore. \n",
    "\n",
    "For example, suppose `a` is a huge intermediate result and the final result `b` only contains a small fraction of `a`, a `deep copy` should be made when constructing `b` with `slicing`:"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(10000)\n",
    "b = a[:100].copy()\n",
    "del a\n",
    "\n",
    "# If b = a[:100] is used instead, \n",
    "# a is referenced by b and will persist in memory even if del a is executed."
   ]
  },
  {
   "source": [
    "# Reference\n",
    "\n",
    "- https://numpy.org/doc/stable/user/quickstart.html#copies-and-views\n",
    "- https://numpy.org/doc/stable/user/absolute_beginners.html#how-to-create-an-array-from-existing-data"
   ],
   "cell_type": "markdown",
   "metadata": {}
  }
 ]
}