data science tools/numpy-202001.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 0.1 Introduction to Numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As with any other package we start off by importing the library, NumPy in this case, by its most commonly used alias, np."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Create a 1-dimensional array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 4, 2, 3, 5, 7, 8, 6])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([1,4,2,3,5,7,8,6])\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Create a 2-dimensional array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[5, 0, 1, 0, 2, 3],\n",
       "       [1, 3, 0, 1, 2, 0],\n",
       "       [0, 1, 0, 0, 1, 3]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = np.array([[5,0,1,0,2,3], [1,3,0,1,2,0], [0,1,0,0,1,3]])\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternatively, we can initialize an array by calling on common functions like zeros, ones, full, and random. The first argument to all these functions is the shape of the array we would like. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Create a 2x2 array of all zeros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0.],\n",
       "       [0., 0.]])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((2, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Create an 1x2 array of all ones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1.]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones((1, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Create a 2x2 constant array of the number 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[7, 7],\n",
       "       [7, 7]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.full((2, 2), 7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Creates a 2x2 array filled with random values between 0 and 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.37454012, 0.95071431],\n",
       "       [0.73199394, 0.59865848]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.seed(42) # set a seed to that we always get the same random values\n",
    "c = np.random.random((2, 2))\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Create a 2x2 identity matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0.],\n",
       "       [0., 1.]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.eye(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once we have some data as a NumPy array, it is useful to observe its defining features. Here are a few:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Shape and size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(8,)\n",
      "(3, 6)\n"
     ]
    }
   ],
   "source": [
    "print(a.shape)\n",
    "print(b.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Find the number of dimensions (ndim) of an array "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of dimensions of NumPy array \"a\"\n",
      "1\n",
      "Number of dimensions of NumPy array \"b\"\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "print('Number of dimensions of NumPy array \"a\"')\n",
    "print(a.ndim)\n",
    "print('Number of dimensions of NumPy array \"b\"')\n",
    "print(b.ndim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Total number of elements (size) of an array "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of elements in NumPy array \"a\"\n",
      "8\n",
      "Total number of elements in NumPy array \"b\"\n",
      "18\n",
      "Total number of elements in NumPy array \"c\"\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "print('Total number of elements in NumPy array \"a\"')\n",
    "print(a.size)\n",
    "\n",
    "print('Total number of elements in NumPy array \"b\"')\n",
    "print(b.size)\n",
    "\n",
    "print('Total number of elements in NumPy array \"c\"')\n",
    "print(c.size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DataType"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Type of data stored in NumPy array \"a\"\n",
      "int32\n",
      "Type of data stored in NumPy array \"b\"\n",
      "int32\n",
      "Type of data stored in NumPy array \"c\"\n",
      "float64\n"
     ]
    }
   ],
   "source": [
    "print('Type of data stored in NumPy array \"a\"')\n",
    "print(a.dtype.name)\n",
    "\n",
    "print('Type of data stored in NumPy array \"b\"')\n",
    "print(b.dtype.name)\n",
    "\n",
    "print('Type of data stored in NumPy array \"c\"')\n",
    "print(c.dtype.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "dtype tells us the type of each element stored in the array. When the array has integers, the type is 'int64', i.e. 64-bit integers. When the array has real numbers, the type is 'float64', i.e. 64-bit floating point values."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Size of an individual array element (in bytes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Size of an individual array elements in NumPy array \"a\"\n",
      "4\n",
      "\n",
      "Size of an individual array elements in NumPy array \"b\"\n",
      "4\n",
      "\n",
      "Size of an individual array elements in NumPy array \"c\"\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "print('Size of an individual array elements in NumPy array \"a\"')\n",
    "print(a.itemsize)\n",
    "print()\n",
    "\n",
    "print('Size of an individual array elements in NumPy array \"b\"')\n",
    "print(b.itemsize)\n",
    "print()\n",
    "\n",
    "print('Size of an individual array elements in NumPy array \"c\"')\n",
    "print(c.itemsize)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since 8 bits = 1 byte, and we have 64-bit integers and floats, the number of bytes per array element is 64 / 8 = 8. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The type of array itself"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "print(type(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  using attributes to create new arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A new array of zeroes of the same shape as \"b\"\n",
      "[[0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0.]]\n",
      "\n",
      "A new array of ones of the same shape as \"a\"\n",
      "[1. 1. 1. 1. 1. 1. 1. 1.]\n"
     ]
    }
   ],
   "source": [
    "# Create an array of zeroes of the same shape as \"b\"\n",
    "print('A new array of zeroes of the same shape as \"b\"')\n",
    "print(np.zeros(b.shape))\n",
    "print()\n",
    "\n",
    "# Create an array of ones of the same shape as \"a\"\n",
    "print('A new array of ones of the same shape as \"a\"')\n",
    "print(np.ones(a.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "array \"a\"\n",
      "[1 4 2 3 5 7 8 6]\n",
      "\n",
      "First element of array \"a\"\n",
      "1\n",
      "\n",
      "Second element of array \"a\"\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# Recall what array a looked like\n",
    "print('array \"a\"')\n",
    "print(a)\n",
    "print()\n",
    "\n",
    "# Indexing. As always, indexes start from 0.\n",
    "print('First element of array \"a\"')\n",
    "print(a[0])   # element 1\n",
    "print()\n",
    "\n",
    "print('Second element of array \"a\"')\n",
    "print(a[1])   # element 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For 2-dimensional arrays, we use the notation array[i, j] to pull out the element in row i, column j."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "array \"b\"\n",
      "[[5 0 1 0 2 3]\n",
      " [1 3 0 1 2 0]\n",
      " [0 1 0 0 1 3]]\n",
      "\n",
      "Element from row 0, column 1, of array \"b\"\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "# Recall what array b looked like\n",
    "print('array \"b\"')\n",
    "print(b)\n",
    "print()\n",
    "\n",
    "# Indexing. As always, indexes start from 0.\n",
    "print('Element from row 0, column 1, of array \"b\"')\n",
    "print(b[0, 1])   # (row 0, column 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: This syntax is different from having a list of lists in Python. In that case, you would do a[i][j] (as opposed to a[i, j])."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instead of just a single element, it is also possible for us to look at sub-arrays or sub-parts of the original array. This is done using slicing. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Elements 2 through 4 (4 not included), of array \"a\"\n",
      "[2 3]\n",
      "\n",
      "First 3 elements of array \"a\"\n",
      "[1 4 2]\n"
     ]
    }
   ],
   "source": [
    "# Slicing pulls out a subarray\n",
    "# Example for pulling out elements 2 through 4\n",
    "# (element 2 is included and 4 is not, same as python list slicing).\n",
    "print('Elements 2 through 4 (4 not included), of array \"a\"')\n",
    "print(a[2:4])\n",
    "print()\n",
    "\n",
    "# Example for pulling out first 3 elements\n",
    "print('First 3 elements of array \"a\"')\n",
    "print(a[:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Similar to indexing, slicing can be done on higher dimensional arrays as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First 2 rows and columns 1 through 3 (3 not included) of array \"b\" \n",
      "[[0 1]\n",
      " [3 0]]\n",
      "\n",
      "Values from row 1 through 2 and all columns, of array \"b\"\n",
      "[[1 3 0 1 2 0]]\n",
      "\n",
      "Values from all rows and column 2\n",
      "[1 0 0]\n"
     ]
    }
   ],
   "source": [
    "# Example for pulling out first 2 rows and columns 1 though 3\n",
    "# (column 1 is included and 3 is not, same as python list slicing).\n",
    "print('First 2 rows and columns 1 through 3 (3 not included) of array \"b\" ')\n",
    "print(b[:2, 1:3])\n",
    "print()\n",
    "\n",
    "# Values from row 1 through 2 and all columns\n",
    "print('Values from row 1 through 2 and all columns, of array \"b\"')\n",
    "print(b[1:2, :])\n",
    "print()\n",
    "\n",
    "# Values from all rows and column 2\n",
    "print('Values from all rows and column 2')\n",
    "print(b[:, 2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that there is a small but important difference in the last two examples. b[1:2,:] returns a 2-D array of shape (1, 6). Whereas b[:,2] returns a 1-D array of shape (3, ). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### modifying elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[7 0 1 0 2 3]\n",
      " [1 3 0 1 2 0]\n",
      " [0 1 0 0 1 3]]\n"
     ]
    }
   ],
   "source": [
    "b[0, 0] = 7  # sets the first value in the first column to 7.\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[7 0 1 0 2 3]\n",
      " [1 3 9 9 2 0]\n",
      " [0 1 9 9 1 3]]\n"
     ]
    }
   ],
   "source": [
    "d = np.copy(b)\n",
    "d[1:3, 2:4] = 9  # sets all values in the subarray to 9.\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also set each element in a sub-array to different values, as defined by another array. This array must have the same shape as the sub-array we select."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[7 2 0 0 2 3]\n",
      " [1 4 3 9 2 0]\n",
      " [0 1 9 9 1 3]]\n"
     ]
    }
   ],
   "source": [
    "d[:2, 1:3] = np.array([[2, 0], [4, 3]])\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Conditionals and Conditional Indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "array \"a\"\n",
      "[1 4 2 3 5 7 8 6]\n",
      "\n",
      "Conditional of array \"a\", for elements of \"a\" greater than 2\n",
      "[False  True False  True  True  True  True  True]\n"
     ]
    }
   ],
   "source": [
    "# Recall what array a looked like\n",
    "print('array \"a\"')\n",
    "print(a)\n",
    "print()\n",
    "\n",
    "print('Conditional of array \"a\", for elements of \"a\" greater than 2')\n",
    "print(a > 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This array of True and False can be used for indexing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Values of array \"a\" larger than 2\n",
      "[4 3 5 7 8 6]\n"
     ]
    }
   ],
   "source": [
    "print('Values of array \"a\" larger than 2')\n",
    "print(a[a > 2]) # values of a larger than 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "array \"b\"\n",
      "[[7 0 1 0 2 3]\n",
      " [1 3 0 1 2 0]\n",
      " [0 1 0 0 1 3]]\n",
      "\n",
      "Conditional of array \"b\", for elements of \"b\" greater than 2\n",
      "[[ True False False False False  True]\n",
      " [False  True False False False False]\n",
      " [False False False False False  True]]\n",
      "\n",
      "Values of array \"b\" larger than 2\n",
      "[7 3 3 3]\n"
     ]
    }
   ],
   "source": [
    "# Recall what array b looked like\n",
    "print('array \"b\"')\n",
    "print(b)\n",
    "print()\n",
    "\n",
    "print('Conditional of array \"b\", for elements of \"b\" greater than 2')\n",
    "print(b > 2)\n",
    "print()\n",
    "\n",
    "print('Values of array \"b\" larger than 2')\n",
    "print(b[b > 2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note above that when we performed conditional indexing on a 2-D array, the result was a flattened array. This is true when the conditional (in this case, b > 2) has the same shape as the original array (in this case, b).\n",
    "\n",
    "NumPy doesn't have a choice here but to flatten the result, since it is possible for the result to include different number of values from each row and column. In the example above, 2 values in row 1 are greater than 2, but only 1 value from rows 2 and 3 are greater than 2."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Conclusion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In summary, advantages of using NumPy\n",
    "\n",
    "    array oriented computing\n",
    "    efficiently implemented multi-dimensional arrays\n",
    "    designed for scientific computation\n",
    "    sophisticated functions for initializing, indexing and slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 0.2 Numpy Operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's start by defining some arrays "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "array \"a\"\n",
      "[1 4 2 3 5 7 8 6]\n",
      "\n",
      "array \"b\"\n",
      "[[1 0 1 0 2 3]\n",
      " [1 3 0 1 2 0]\n",
      " [0 1 0 0 1 3]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# Create a 1-dimensional array\n",
    "a = np.array([1,4,2,3,5,7,8,6])\n",
    "print('array \"a\"')\n",
    "print(a)\n",
    "print()\n",
    "\n",
    "# Create a 2-dimensional array\n",
    "b = np.array([[1,0,1,0,2,3], [1,3,0,1,2,0], [0,1,0,0,1,3]])\n",
    "print('array \"b\"')\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Element-wise operations (add, multiply, etc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[6 5 6 5 7 8]\n",
      " [6 8 5 6 7 5]\n",
      " [5 6 5 5 6 8]]\n"
     ]
    }
   ],
   "source": [
    "c = b + 5\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Element-wise sum of \"b\" and \"c\"\n",
      "[[ 7  5  7  5  9 11]\n",
      " [ 7 11  5  7  9  5]\n",
      " [ 5  7  5  5  7 11]]\n",
      "\n",
      "Element-wise sum of \"b\" and \"c\"\n",
      "[[ 7  5  7  5  9 11]\n",
      " [ 7 11  5  7  9  5]\n",
      " [ 5  7  5  5  7 11]]\n"
     ]
    }
   ],
   "source": [
    "# Element-wise addition\n",
    "print('Element-wise sum of \"b\" and \"c\"')\n",
    "print(b + c)\n",
    "print()\n",
    "\n",
    "print('Element-wise sum of \"b\" and \"c\"')\n",
    "print(np.add(b, c))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Element-wise difference of \"b\" and \"c\"\n",
      "[[-5 -5 -5 -5 -5 -5]\n",
      " [-5 -5 -5 -5 -5 -5]\n",
      " [-5 -5 -5 -5 -5 -5]]\n",
      "\n",
      "Element-wise difference of \"b\" and \"c\"\n",
      "[[-5 -5 -5 -5 -5 -5]\n",
      " [-5 -5 -5 -5 -5 -5]\n",
      " [-5 -5 -5 -5 -5 -5]]\n"
     ]
    }
   ],
   "source": [
    "# Element-wise subtraction\n",
    "print('Element-wise difference of \"b\" and \"c\"')\n",
    "print(b - c)\n",
    "print()\n",
    "\n",
    "print('Element-wise difference of \"b\" and \"c\"')\n",
    "print(np.subtract(b, c))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Element-wise multiplication of \"b\" and \"c\"\n",
      "[[ 6  0  6  0 14 24]\n",
      " [ 6 24  0  6 14  0]\n",
      " [ 0  6  0  0  6 24]]\n",
      "\n",
      "Element-wise multiplication of \"b\" and \"c\"\n",
      "[[ 6  0  6  0 14 24]\n",
      " [ 6 24  0  6 14  0]\n",
      " [ 0  6  0  0  6 24]]\n"
     ]
    }
   ],
   "source": [
    "# Element-wise multiplication\n",
    "print('Element-wise multiplication of \"b\" and \"c\"')\n",
    "print(b * c)\n",
    "print()\n",
    "\n",
    "print('Element-wise multiplication of \"b\" and \"c\"')\n",
    "print(np.multiply(b, c))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Element-wise division of \"b\" and \"c\" \n",
      "[[0.16666667 0.         0.16666667 0.         0.28571429 0.375     ]\n",
      " [0.16666667 0.375      0.         0.16666667 0.28571429 0.        ]\n",
      " [0.         0.16666667 0.         0.         0.16666667 0.375     ]]\n"
     ]
    }
   ],
   "source": [
    "# Element-wise division\n",
    "print('Element-wise division of \"b\" and \"c\" ')\n",
    "print(b / c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: The arrays are implicitly converted to float in latest NumPy versions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Element-wise square root of array \"b\"\n",
      "[[1.         0.         1.         0.         1.41421356 1.73205081]\n",
      " [1.         1.73205081 0.         1.         1.41421356 0.        ]\n",
      " [0.         1.         0.         0.         1.         1.73205081]]\n"
     ]
    }
   ],
   "source": [
    "# Element-wise square-root\n",
    "print('Element-wise square root of array \"b\"')\n",
    "print(np.sqrt(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Aggregation operations (sum, min, max, etc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of all elements of array \"b\"\n",
      "19\n",
      "\n",
      "Sum of each column of array \"b\"\n",
      "[2 4 1 1 5 6]\n",
      "\n",
      "Sum of each row of array \"b\"\n",
      "[7 7 5]\n"
     ]
    }
   ],
   "source": [
    "# Sum of all elements\n",
    "print('Sum of all elements of array \"b\"')\n",
    "print(b.sum())\n",
    "print()\n",
    "\n",
    "# Sum of each column\n",
    "print('Sum of each column of array \"b\"')\n",
    "print(b.sum(axis=0))\n",
    "print()\n",
    "\n",
    "# Sum of each row\n",
    "print('Sum of each row of array \"b\"')\n",
    "print(b.sum(axis=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum of all values of array \"b\"\n",
      "0\n",
      "\n",
      "Maximum across axis 1 of array \"b\"\n",
      "[3 3 3]\n",
      "\n",
      "Cumulative sum across axis 0 of array \"b\"\n",
      "[[1 0 1 0 2 3]\n",
      " [2 3 1 1 4 3]\n",
      " [2 4 1 1 5 6]]\n"
     ]
    }
   ],
   "source": [
    "# Minimum of all values\n",
    "print('Minimum of all values of array \"b\"')\n",
    "print(b.min())\n",
    "print()\n",
    "\n",
    "# Maximum across axis 1\n",
    "print('Maximum across axis 1 of array \"b\"')\n",
    "print(b.max(axis=1))\n",
    "print()\n",
    "\n",
    "# Cumulative sum across axis 0\n",
    "print('Cumulative sum across axis 0 of array \"b\"')\n",
    "print(b.cumsum(axis=0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### And also mean, median, std (standard deviation)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean along axis 0 of array \"b\"\n",
      "[0.66666667 1.33333333 0.33333333 0.33333333 1.66666667 2.        ]\n",
      "\n",
      "Median along axis 0 of array \"b\"\n",
      "[1. 1. 0. 0. 2. 3.]\n",
      "\n",
      "Standard deviation along axis 0 of array \"b\"\n",
      "[0.47140452 1.24721913 0.47140452 0.47140452 0.47140452 1.41421356]\n",
      "\n",
      "Mean along axis 0 of array \"b\"\n",
      "[0.66666667 1.33333333 0.33333333 0.33333333 1.66666667 2.        ]\n"
     ]
    }
   ],
   "source": [
    "print('Mean along axis 0 of array \"b\"')\n",
    "print(b.mean(axis=0))\n",
    "print()\n",
    "\n",
    "print('Median along axis 0 of array \"b\"')\n",
    "print(np.median(b, axis=0))\n",
    "print()\n",
    "\n",
    "print('Standard deviation along axis 0 of array \"b\"')\n",
    "print(np.std(b, axis=0))\n",
    "print()\n",
    "\n",
    "print('Mean along axis 0 of array \"b\"')\n",
    "print(np.mean(b, axis=0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "unique elements in array \"b\"\n",
      "[0 1 2 3]\n"
     ]
    }
   ],
   "source": [
    "print('unique elements in array \"b\"')\n",
    "print(np.unique(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Matrix Operations (dot products, matrix multiplication, etc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "array \"v\"\n",
      "[1 1 0]\n",
      "\n",
      "array \"w\"\n",
      "[0 3 1]\n"
     ]
    }
   ],
   "source": [
    "# Create array \"v\"\n",
    "v = b[:, 0]\n",
    "print('array \"v\"')\n",
    "print(v)\n",
    "print()\n",
    "\n",
    "# Create array \"w\"\n",
    "w = b[:, 1]\n",
    "print('array \"w\"')\n",
    "print(w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Dot Product"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dot product of \"v\" and \"w\"\n",
      "3\n",
      "\n",
      "Dot product of \"v\" and \"v\"\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "# Inner product of vectors: v[0]*w[0] + v[1]*w[1] + ... v[n]*w[n]\n",
    "print('Dot product of \"v\" and \"w\"')\n",
    "print(v.dot(w)) # or np.dot(v, w)\n",
    "print()\n",
    "\n",
    "print('Dot product of \"v\" and \"v\"')\n",
    "print(v.dot(v)) # or np.dot(v, v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When the arrays are 2-dimensional, dot-product is equivalent to performing matrix multiplication. Below are examples of matrix-vector multiplication and matrix-matrix multiplication. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Transpose of \"b\"\n",
      "[[1 1 0]\n",
      " [0 3 1]\n",
      " [1 0 0]\n",
      " [0 1 0]\n",
      " [2 2 1]\n",
      " [3 0 3]]\n",
      "\n",
      "Matrix-vector product of \"b-transpose\" and \"v\"\n",
      "[2 3 1 1 4 3]\n",
      "\n",
      "Matrix-matrix product of \"b-transpose\" and \"b\"\n",
      "[[ 2  3  1  1  4  3]\n",
      " [ 3 10  0  3  7  3]\n",
      " [ 1  0  1  0  2  3]\n",
      " [ 1  3  0  1  2  0]\n",
      " [ 4  7  2  2  9  9]\n",
      " [ 3  3  3  0  9 18]]\n"
     ]
    }
   ],
   "source": [
    "# Transpose of a matrix\n",
    "print('Transpose of \"b\"')\n",
    "print(b.T)\n",
    "print()\n",
    "\n",
    "# Matrix-vector product\n",
    "print('Matrix-vector product of \"b-transpose\" and \"v\"')\n",
    "print(np.dot(b.T, v))\n",
    "print()\n",
    "\n",
    "# Matrix-matrix product (matrix multiplication)\n",
    "print('Matrix-matrix product of \"b-transpose\" and \"b\"')\n",
    "print(np.dot(b.T, b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For dot products and matrix multiplication to be performed, the dimensions of the arrays need to be compatible. If they are not, NumPy will raise an exception."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "shapes (3,6) and (3,) not aligned: 6 (dim 1) != 3 (dim 0)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-18-d975e04ae702>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# Incompatible dimensions (matrix-vector)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mb\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mv\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<__array_function__ internals>\u001b[0m in \u001b[0;36mdot\u001b[1;34m(*args, **kwargs)\u001b[0m\n",
      "\u001b[1;31mValueError\u001b[0m: shapes (3,6) and (3,) not aligned: 6 (dim 1) != 3 (dim 0)"
     ]
    }
   ],
   "source": [
    "# Incompatible dimensions (matrix-vector)\n",
    "print(np.dot(b, v))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "shapes (3,6) and (3,6) not aligned: 6 (dim 1) != 3 (dim 0)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-19-ab43a7911a46>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# Incompatible dimensions (matrix-matrix)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mb\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mc\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<__array_function__ internals>\u001b[0m in \u001b[0;36mdot\u001b[1;34m(*args, **kwargs)\u001b[0m\n",
      "\u001b[1;31mValueError\u001b[0m: shapes (3,6) and (3,6) not aligned: 6 (dim 1) != 3 (dim 0)"
     ]
    }
   ],
   "source": [
    "# Incompatible dimensions (matrix-matrix)\n",
    "print(np.dot(b, c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### sorting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "array \"a\"\n",
      "[1 4 2 3 5 7 8 6]\n",
      "\n",
      "sorted array \"a\"\n",
      "[1 2 3 4 5 6 7 8]\n"
     ]
    }
   ],
   "source": [
    "print('array \"a\"')\n",
    "print(a)\n",
    "print()\n",
    "\n",
    "# sort array \"a\"\n",
    "print('sorted array \"a\"')\n",
    "print(np.sort(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The sort() function also accepts an axis parameter.\n",
    "\n",
    "axis parameter is used to specify the axis along which we want to sort. In NumPy, axis values increase from the outside-in. For example, if we pass a 2D array and axis is 0, NumPy will sort each column. If axis is 1, NumPy will sort each row.\n",
    "\n",
    "axis = -1 sorts along the last axis. This is also the default value. axis can also be None, in which case, the array is flattened and then the elements are sorted. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "array \"b\"\n",
      "[[1 0 1 0 2 3]\n",
      " [1 3 0 1 2 0]\n",
      " [0 1 0 0 1 3]]\n",
      "\n",
      "array \"b\" sorted along rows (axis=1)\n",
      "[[0 0 1 1 2 3]\n",
      " [0 0 1 1 2 3]\n",
      " [0 0 0 1 1 3]]\n",
      "\n",
      "array \"b\" sorted along rows (axis=-1)\n",
      "[[0 0 1 1 2 3]\n",
      " [0 0 1 1 2 3]\n",
      " [0 0 0 1 1 3]]\n",
      "\n",
      "array \"b\" sorted along columns (axis=0)\n",
      "[[0 0 0 0 1 0]\n",
      " [1 1 0 0 2 3]\n",
      " [1 3 1 1 2 3]]\n",
      "\n",
      "array \"b\" flattened and then sorted (axis=None)\n",
      "[0 0 0 0 0 0 0 1 1 1 1 1 1 2 2 3 3 3]\n"
     ]
    }
   ],
   "source": [
    "print('array \"b\"')\n",
    "print(b)\n",
    "print()\n",
    "\n",
    "# sort array \"b\" along rows, axis 1\n",
    "print('array \"b\" sorted along rows (axis=1)')\n",
    "print(np.sort(b, axis=1))\n",
    "print()\n",
    "\n",
    "# sort array \"b\" along rows (also the last axis in this case)\n",
    "print('array \"b\" sorted along rows (axis=-1)')\n",
    "print(np.sort(b, axis=-1))\n",
    "print()\n",
    "\n",
    "# sort array \"b\" along columns, axis 0\n",
    "print('array \"b\" sorted along columns (axis=0)')\n",
    "print(np.sort(b, axis=0))\n",
    "print()\n",
    "\n",
    "# sort array \"b\" after flattening it\n",
    "print('array \"b\" flattened and then sorted (axis=None)')\n",
    "print(np.sort(b, axis=None))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "array with \"nan\" values\n",
      "[ 0. nan  1.  2. nan  7.  3.  5.  1. nan]\n",
      "\n",
      "sorted array\n",
      "[ 0.  1.  1.  2.  3.  5.  7. nan nan nan]\n"
     ]
    }
   ],
   "source": [
    "# create a new array with 'nan' values\n",
    "z = np.array([0, np.nan, 1, 2, np.nan, 7, 3, 5, 1, np.nan])\n",
    "print('array with \"nan\" values')\n",
    "print(z)\n",
    "print()\n",
    "\n",
    "# sort array and display\n",
    "print('sorted array')\n",
    "print(np.sort(z))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "to sort every column of array b inplace, we do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 0 0 0 1 0]\n",
      " [1 1 0 0 2 3]\n",
      " [1 3 1 1 2 3]]\n"
     ]
    }
   ],
   "source": [
    "b.sort(axis=0)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### summary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    perform element-wise operations like addition, subtraction, etc. and functions like square root, log, etc.\n",
    "    performing aggregation operations like sum, cumulative sum, mean, etc\n",
    "    performing dot products and matrix multiplications\n",
    "    sorting numpy arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 0.3 Manipulating arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's start by defining some arrays "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "array \"a\"\n",
      "[1 4 2 3 5 7 8 6]\n",
      "\n",
      "array \"b\"\n",
      "[[1 0 1 0 2 3]\n",
      " [1 3 0 1 2 0]\n",
      " [0 1 0 0 1 3]]\n",
      "\n",
      "array \"c\"\n",
      "[[6 5 6 5 7 8]\n",
      " [6 8 5 6 7 5]\n",
      " [5 6 5 5 6 8]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# Create a 1-dimensional array\n",
    "a = np.array([1,4,2,3,5,7,8,6])\n",
    "print('array \"a\"')\n",
    "print(a)\n",
    "print()\n",
    "\n",
    "# Create a 2-dimensional array\n",
    "b = np.array([[1,0,1,0,2,3], [1,3,0,1,2,0], [0,1,0,0,1,3]])\n",
    "print('array \"b\"')\n",
    "print(b)\n",
    "print()\n",
    "\n",
    "np.random.seed(42) # set a seed to that we always get the same random values\n",
    "c = b + 5\n",
    "print('array \"c\"')\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Reshape and flatten"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "array \"a\" reshaped to 4 x 2\n",
      "[[1 4]\n",
      " [2 3]\n",
      " [5 7]\n",
      " [8 6]]\n",
      "\n",
      "array \"a\" reshaped to 2 x 4\n",
      "[[1 4 2 3]\n",
      " [5 7 8 6]]\n"
     ]
    }
   ],
   "source": [
    "# Reshape to shape 4 x 2\n",
    "a = a.reshape(4, 2)\n",
    "print('array \"a\" reshaped to 4 x 2')\n",
    "print(a)\n",
    "print()\n",
    "\n",
    "# Reshape to shape 2 x 4\n",
    "a = a.reshape(2, 4)\n",
    "print('array \"a\" reshaped to 2 x 4')\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see above, during reshaping to a 2-D object, values are filled row by row."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\"Flatten\" is equivalent to reshaping to vector of length a.size."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Flattened array \"a\"\n",
      "[1 4 2 3 5 7 8 6]\n"
     ]
    }
   ],
   "source": [
    "a = a.flatten()\n",
    "print('Flattened array \"a\"')\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Resize"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we would like to reshape while changing the total number of elements in the array, we can use resize. Resize will repeat elements (if resizing to a larger size), or it will throw away elements (if resizing to a smaller size)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 4 2 3 5]\n",
      " [7 8 6 1 4]\n",
      " [2 3 5 7 8]]\n"
     ]
    }
   ],
   "source": [
    "print(np.resize(a, (3, 5)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### broadcasting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Broadcasting makes copies of the existing array.\n",
    "\n",
    "The first argument is the array itself, and the second argument is the shape of the new array.\n",
    "\n",
    "Since broadcasting makes copies of the original array, the trailing dimensions of the new array must match the dimensions of the original array. For example, we can broadcast an array of shape (8, ) to an array of shape (6, 8). But we cannot broadcast it to shape (6, 4). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Broadcasting array \"a\" to a new size\n",
      "[[1 4 2 3 5 7 8 6]\n",
      " [1 4 2 3 5 7 8 6]\n",
      " [1 4 2 3 5 7 8 6]\n",
      " [1 4 2 3 5 7 8 6]\n",
      " [1 4 2 3 5 7 8 6]\n",
      " [1 4 2 3 5 7 8 6]]\n"
     ]
    }
   ],
   "source": [
    "print('Broadcasting array \"a\" to a new size')\n",
    "print(np.broadcast_to(a, (6, 8)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's try broadcasting the 2D array. The original shape of B was (3, 6), and we will broadcast it to the shape (2, 3, 6). This will repeat the array twice."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 0 1 0 2 3]\n",
      " [1 3 0 1 2 0]\n",
      " [0 1 0 0 1 3]]\n",
      "\n",
      "Broadcasting array \"b\" to a new size\n",
      "New shape (2, 3, 6)\n",
      "[[[1 0 1 0 2 3]\n",
      "  [1 3 0 1 2 0]\n",
      "  [0 1 0 0 1 3]]\n",
      "\n",
      " [[1 0 1 0 2 3]\n",
      "  [1 3 0 1 2 0]\n",
      "  [0 1 0 0 1 3]]]\n"
     ]
    }
   ],
   "source": [
    "print(b)\n",
    "print()\n",
    "\n",
    "print('Broadcasting array \"b\" to a new size')\n",
    "z = np.broadcast_to(b, (2, 3, 6))\n",
    "print('New shape', z.shape)\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Expanding and squeezing dimensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "expand_dims and squeeze can be used to add or remove dimensions from an array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Expanded array \"z\"\n",
      "Shape of z (3, 1, 6)\n",
      "[[[1 0 1 0 2 3]]\n",
      "\n",
      " [[1 3 0 1 2 0]]\n",
      "\n",
      " [[0 1 0 0 1 3]]]\n",
      "\n",
      "Squeezed array \"z\"\n",
      "[[1 0 1 0 2 3]\n",
      " [1 3 0 1 2 0]\n",
      " [0 1 0 0 1 3]]\n"
     ]
    }
   ],
   "source": [
    "# Expand the shape of an array by inserting axis\n",
    "z = np.expand_dims(b, axis=1) # expand at position 1\n",
    "print('Expanded array \"z\"')\n",
    "print('Shape of z', z.shape)\n",
    "print(z)\n",
    "print()\n",
    "\n",
    "# Remove single-dimensional entries from the shape of an array\n",
    "print('Squeezed array \"z\"')\n",
    "print(np.squeeze(z))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Concatenating and stacking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "array \"b\"\n",
      "[[1 0 1 0 2 3]\n",
      " [1 3 0 1 2 0]\n",
      " [0 1 0 0 1 3]]\n",
      "\n",
      "array \"c\"\n",
      "[[6 5 6 5 7 8]\n",
      " [6 8 5 6 7 5]\n",
      " [5 6 5 5 6 8]]\n"
     ]
    }
   ],
   "source": [
    "print('array \"b\"')\n",
    "print(b)\n",
    "print()\n",
    "\n",
    "print('array \"c\"')\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Concatenated array \"b\" and \"c\", along axis 0\n",
      "[[1 0 1 0 2 3]\n",
      " [1 3 0 1 2 0]\n",
      " [0 1 0 0 1 3]\n",
      " [6 5 6 5 7 8]\n",
      " [6 8 5 6 7 5]\n",
      " [5 6 5 5 6 8]]\n",
      "\n",
      "Concatenated arrays \"b\" and \"c\" along axis 1\n",
      "[[1 0 1 0 2 3 6 5 6 5 7 8]\n",
      " [1 3 0 1 2 0 6 8 5 6 7 5]\n",
      " [0 1 0 0 1 3 5 6 5 5 6 8]]\n"
     ]
    }
   ],
   "source": [
    "# Join arrays along an existing axis, axis 0\n",
    "print('Concatenated array \"b\" and \"c\", along axis 0')\n",
    "print(np.concatenate((b, c), axis=0))\n",
    "print()\n",
    "\n",
    "# Join arrays along an existing axis, axis 1\n",
    "print('Concatenated arrays \"b\" and \"c\" along axis 1')\n",
    "print(np.concatenate((b, c), axis=1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unlike concatenation, stacking creates a new dimension:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stack arrays \"b\" and \"c\" along a new axis, 0\n",
      "(2, 3, 6)\n",
      "[[[1 0 1 0 2 3]\n",
      "  [1 3 0 1 2 0]\n",
      "  [0 1 0 0 1 3]]\n",
      "\n",
      " [[6 5 6 5 7 8]\n",
      "  [6 8 5 6 7 5]\n",
      "  [5 6 5 5 6 8]]]\n",
      "\n",
      "Stack arrays \"b\" and \"c\" along a new axis, 1\n",
      "(3, 2, 6)\n",
      "[[[1 0 1 0 2 3]\n",
      "  [6 5 6 5 7 8]]\n",
      "\n",
      " [[1 3 0 1 2 0]\n",
      "  [6 8 5 6 7 5]]\n",
      "\n",
      " [[0 1 0 0 1 3]\n",
      "  [5 6 5 5 6 8]]]\n"
     ]
    }
   ],
   "source": [
    "# Join arrays along a new axis, 0\n",
    "print('Stack arrays \"b\" and \"c\" along a new axis, 0')\n",
    "z = np.stack((b, c), 0)\n",
    "print(z.shape)\n",
    "print(z)\n",
    "print()\n",
    "\n",
    "# Join arrays along a new axis, 1\n",
    "print('Stack arrays \"b\" and \"c\" along a new axis, 1')\n",
    "z = np.stack((b, c), 1)\n",
    "print(z.shape)\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Splitting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "split, hsplit (horizontal split) and vsplit (vertical split) can be used to split an array into equal-sized subarrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "array \"b\"\n",
      "[[1 0 1 0 2 3]\n",
      " [1 3 0 1 2 0]\n",
      " [0 1 0 0 1 3]]\n",
      "\n",
      "array \"c\"\n",
      "[[6 5 6 5 7 8]\n",
      " [6 8 5 6 7 5]\n",
      " [5 6 5 5 6 8]]\n"
     ]
    }
   ],
   "source": [
    "print('array \"b\"')\n",
    "print(b)\n",
    "print()\n",
    "\n",
    "print('array \"c\"')\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default, split splits by the axis 0. For 2D arrays, this means splitting vertically:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Split array \"b\"\n",
      "[array([[1, 0, 1, 0, 2, 3]]), array([[1, 3, 0, 1, 2, 0]]), array([[0, 1, 0, 0, 1, 3]])]\n",
      "\n",
      "Split array \"c\"\n",
      "[array([[6, 5, 6, 5, 7, 8]]), array([[6, 8, 5, 6, 7, 5]]), array([[5, 6, 5, 5, 6, 8]])]\n"
     ]
    }
   ],
   "source": [
    "print('Split array \"b\"')\n",
    "print(np.split(b, 3))\n",
    "print()\n",
    "\n",
    "print('Split array \"c\"')\n",
    "print(np.split(c, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's look at some ways to split horizontally:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Split array \"c\" into 3 parts along axis 1\n",
      "[array([[6, 5],\n",
      "       [6, 8],\n",
      "       [5, 6]]), array([[6, 5],\n",
      "       [5, 6],\n",
      "       [5, 5]]), array([[7, 8],\n",
      "       [7, 5],\n",
      "       [6, 8]])]\n",
      "\n",
      "Horizontally split array \"b\" into 2 parts\n",
      "[array([[1, 0, 1],\n",
      "       [1, 3, 0],\n",
      "       [0, 1, 0]]), array([[0, 2, 3],\n",
      "       [1, 2, 0],\n",
      "       [0, 1, 3]])]\n",
      "\n",
      "Horizontally split array \"b\" into 3 parts\n",
      "[array([[1, 0],\n",
      "       [1, 3],\n",
      "       [0, 1]]), array([[1, 0],\n",
      "       [0, 1],\n",
      "       [0, 0]]), array([[2, 3],\n",
      "       [2, 0],\n",
      "       [1, 3]])]\n"
     ]
    }
   ],
   "source": [
    "print('Split array \"c\" into 3 parts along axis 1')\n",
    "print(np.split(c, 3, axis=1))\n",
    "print()\n",
    "\n",
    "print('Horizontally split array \"b\" into 2 parts')\n",
    "print(np.hsplit(b, 2))\n",
    "print()\n",
    "\n",
    "print('Horizontally split array \"b\" into 3 parts')\n",
    "print(np.hsplit(b, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Append, insert and delete"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "array \"a\"\n",
      "[1 4 2 3 5 7 8 6]\n",
      "\n",
      "Values appended to array \"a\"\n",
      "[1 4 2 3 5 7 8 6 1 2]\n",
      "\n",
      "Values inserted to array \"a\"\n",
      "[1 4 2 0 0 3 5 7 8 6]\n",
      "\n",
      "Values deleted from array \"a\"\n",
      "[1 2 5 7 8 6]\n"
     ]
    }
   ],
   "source": [
    "print('array \"a\"')\n",
    "print(a)\n",
    "print()\n",
    "\n",
    "# Append values to the end of an array\n",
    "print('Values appended to array \"a\"')\n",
    "print(np.append(a, [1, 2]))\n",
    "print()\n",
    "\n",
    "# Insert values (0, 0) along the given axis (0) at the given index (3)\n",
    "print('Values inserted to array \"a\"')\n",
    "print(np.insert(a, 3, [0, 0], axis=0))\n",
    "print()\n",
    "\n",
    "# Delete the element at given locations (1) along an axis (0)\n",
    "print('Values deleted from array \"a\"')\n",
    "print(np.delete(a, [1, 3], axis=0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see some examples with 2D arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "array \"b\"\n",
      "[[1 0 1 0 2 3]\n",
      " [1 3 0 1 2 0]\n",
      " [0 1 0 0 1 3]]\n",
      "\n",
      "Values appended to array \"b\" along axis 0\n",
      "[[1 0 1 0 2 3]\n",
      " [1 3 0 1 2 0]\n",
      " [0 1 0 0 1 3]\n",
      " [1 2 3 4 5 6]]\n",
      "\n",
      "Values appended to array \"b\" along axis 1\n",
      "[[1 0 1 0 2 3 7]\n",
      " [1 3 0 1 2 0 8]\n",
      " [0 1 0 0 1 3 9]]\n",
      "\n",
      "Scalar values inserted to array \"b\" in column position 2\n",
      "[[1 0 5 1 0 2 3]\n",
      " [1 3 5 0 1 2 0]\n",
      " [0 1 5 0 0 1 3]]\n",
      "\n",
      "Column vector inserted to array \"b\" in column position 1\n",
      "[[1 1 0 1 0 2 3]\n",
      " [1 2 3 0 1 2 0]\n",
      " [0 3 1 0 0 1 3]]\n",
      "\n",
      "Row deleted from array \"b\"\n",
      "[[1 0 1 0 2 3]\n",
      " [0 1 0 0 1 3]]\n",
      "\n",
      "Column deleted from array \"b\"\n",
      "[[1 0 0 2 3]\n",
      " [1 3 1 2 0]\n",
      " [0 1 0 1 3]]\n"
     ]
    }
   ],
   "source": [
    "# 2d array \"b\"\n",
    "print('array \"b\"')\n",
    "print(b)\n",
    "print()\n",
    "\n",
    "# Append row of values to the end of a 2darray\n",
    "# Notice that the argument itself is a 2D array.\n",
    "print('Values appended to array \"b\" along axis 0')\n",
    "print(np.append(b, [[1, 2, 3, 4, 5, 6]], axis=0))\n",
    "print()\n",
    "\n",
    "# Append column of values to the end of a 2darray\n",
    "print('Values appended to array \"b\" along axis 1')\n",
    "print(np.append(b, [[7], [8], [9]], axis=1))\n",
    "print()\n",
    "\n",
    "# Insert values (5, 5, 5) along the given axis (1) at the given index (2)\n",
    "print('Scalar values inserted to array \"b\" in column position 2')\n",
    "print(np.insert(b, 2, 5, axis=1))\n",
    "print()\n",
    "\n",
    "# Insert values (1, 2, 3) along the given axis (1) at the given index (1)\n",
    "print('Column vector inserted to array \"b\" in column position 1')\n",
    "print(np.insert(b, [1], [[1],[2],[3]], axis=1))\n",
    "print()\n",
    "\n",
    "# Delete the row/column/array at given locations (1) along an axis (0)\n",
    "print('Row deleted from array \"b\"')\n",
    "print(np.delete(b, 1, axis=0))\n",
    "print()\n",
    "\n",
    "# Delete the row/column/array at given locations (2) along an axis (1)\n",
    "print('Column deleted from array \"b\"')\n",
    "print(np.delete(b, 2, axis=1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### summary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    change the shape of a NumPy array using reshape and flatten\n",
    "    change the size of a NumPy array using resize and broadcast_to\n",
    "    join arrays using concatenate and stack\n",
    "    split arrays using split\n",
    "    append, insert and delete items / subarrays from an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}