numpy-exercises.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NumPy Basics\n",
    "\n",
    "Numpy is one of the most useful library for Data Science with Python\n",
    "\n",
    "Numpy basic data type is a ndarray => n dimensional array\n",
    "\n",
    "Different tasks will be detailed by comments or text.\n",
    "\n",
    "For further reference and resources, it's advised to check out the [NumPy documentation](https://numpy.org/devdocs/user/index.html).\n",
    "\n",
    "#### Importance of Numpy\n",
    "\n",
    "Numpy is used due to it is written by C and so that it is very fast.\n",
    "If you are dealing with numbers and these numbers operations are too much, strongly advice you to use numpy\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importing NumPy as its abbreviation 'np'\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n",
      "[[1 2 3]\n",
      " [4 5 6]]\n",
      "[[[ 1  2  3]\n",
      "  [ 4  5  6]]\n",
      "\n",
      " [[ 7  8  9]\n",
      "  [10 11 12]]\n",
      "\n",
      " [[13 14 15]\n",
      "  [16 17 18]]]\n"
     ]
    }
   ],
   "source": [
    "# Creating a 1-dimensional NumPy array using np.array()\n",
    "arr1 = np.array([1,2,3])\n",
    "print(arr1)\n",
    "# Creating a 2-dimensional NumPy array using np.array()\n",
    "arr2 = np.array([[1,2,3],\n",
    "                [4,5,6]])\n",
    "print(arr2)\n",
    "# Creating a 3-dimensional Numpy array using np.array()\n",
    "arr3 = np.array([[[1,2,3], [4,5,6]],\n",
    "                [[7,8,9], [10,11,12]],\n",
    "                [[13,14,15], [16,17,18]]])\n",
    "print(arr3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we've you've created 3 different arrays, let's find details about them.\n",
    "\n",
    "Find the shape, number of dimensions, data type, size and type of each array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((3,), 1, dtype('int64'))"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Attributes of 1-dimensional array (shape, \n",
    "# number of dimensions, data type, size and type)\n",
    "arr1.shape, arr1.ndim, arr1.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((2, 3), 2, dtype('int64'))"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Attributes of 2-dimensional array\n",
    "arr2.shape, arr2.ndim, arr2.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((3, 2, 3), 3, dtype('int64'))"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Attributes of 3-dimensional array\n",
    "arr3.shape, arr3.ndim, arr3.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   0  1  2\n",
       "0  1  2  3\n",
       "1  4  5  6"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Import pandas and create a DataFrame out of one\n",
    "# of the arrays you've created\n",
    "import pandas as pd\n",
    "df = pd.DataFrame(arr2)\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1.],\n",
       "       [1., 1.],\n",
       "       [1., 1.],\n",
       "       [1., 1.],\n",
       "       [1., 1.],\n",
       "       [1., 1.],\n",
       "       [1., 1.],\n",
       "       [1., 1.],\n",
       "       [1., 1.],\n",
       "       [1., 1.]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create an array of shape (10, 2) with only ones\n",
    "ones = np.ones((10,2))\n",
    "ones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[0., 0., 0.],\n",
       "        [0., 0., 0.]],\n",
       "\n",
       "       [[0., 0., 0.],\n",
       "        [0., 0., 0.]],\n",
       "\n",
       "       [[0., 0., 0.],\n",
       "        [0., 0., 0.]],\n",
       "\n",
       "       [[0., 0., 0.],\n",
       "        [0., 0., 0.]],\n",
       "\n",
       "       [[0., 0., 0.],\n",
       "        [0., 0., 0.]],\n",
       "\n",
       "       [[0., 0., 0.],\n",
       "        [0., 0., 0.]],\n",
       "\n",
       "       [[0., 0., 0.],\n",
       "        [0., 0., 0.]]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create an array of shape (7, 2, 3) of only zeros\n",
    "zeros = np.zeros((7,2,3))\n",
    "zeros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  3,  6,  9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48,\n",
       "       51, 54, 57, 60, 63, 66, 69, 72, 75, 78, 81, 84, 87, 90, 93, 96, 99])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create an array within a range of 0 and 100 with step 3\n",
    "# arange(minVal,maxVal, stepover)\n",
    "range_arr = np.arange(0,100,3)\n",
    "range_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[6, 2],\n",
       "       [0, 2],\n",
       "       [6, 6],\n",
       "       [2, 7],\n",
       "       [0, 2],\n",
       "       [8, 8],\n",
       "       [6, 6]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a random array with numbers between 0 and 10 of size (7, 2)\n",
    "rand_arr = np.random.randint(0, 10, size=(7,2))\n",
    "rand_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.567798  , 0.60143635, 0.78437936, 0.69394645, 0.69632779],\n",
       "       [0.83750139, 0.69039159, 0.9134839 , 0.69863296, 0.8353217 ],\n",
       "       [0.27910081, 0.74906481, 0.73074605, 0.80758887, 0.57197611]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a random array of floats between 0 & 1 of shape (3, 5)\n",
    "rand_arr2 = np.random.random((3,5))\n",
    "rand_arr2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[6, 3, 7, 4, 6, 9],\n",
       "       [2, 6, 7, 4, 3, 7],\n",
       "       [7, 2, 5, 4, 1, 7],\n",
       "       [5, 1, 4, 0, 9, 5]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Set the random seed to 42\n",
    "# random created arrays only first time randomized after that alwys it gives the same result\n",
    "# thus it is used you can reran each cell with seed and without seed\n",
    "np.random.seed(42)\n",
    "\n",
    "# Create a random array of numbers between 0 & 10 of size (4, 6)\n",
    "rand_arr3 = np.random.randint(0, 10, size=(4,6))\n",
    "rand_arr3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run the cell above again, what happens?\n",
    "\n",
    "Are the numbers in the array different or the same? Why do think this is?\n",
    "=>Due to seed function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 9])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Find the unique numbers in the array you just created\n",
    "np.unique(rand_arr3)\n",
    "#this function gives the how many different values in your array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Find the 0'th index of the latest array you created\n",
    "rand_arr3[3][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 1])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get the first 2 rows of latest array you created\n",
    "rand_arr3[3][:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[6, 3, 7, 4, 6, 9],\n",
       "       [2, 6, 7, 4, 3, 7]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get the first 2 values of the first 2 rows of the latest array\n",
    "rand_arr3[:2][:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[6 3 7 4 6]\n",
      " [9 2 6 7 4]\n",
      " [3 7 7 2 5]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a random array of numbers between 0 & 10 and an array of ones\n",
    "# both of size (3, 5), save them both to variables\n",
    "np.random.seed(42)\n",
    "rand_arr4 = np.random.randint(0, 10, size=(3,5))\n",
    "ones = np.ones((3,5))\n",
    "print(rand_arr4)\n",
    "ones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 7.,  4.,  8.,  5.,  7.],\n",
       "       [10.,  3.,  7.,  8.,  5.],\n",
       "       [ 4.,  8.,  8.,  3.,  6.]])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Add the two arrays together\n",
    "rand_arr4 + ones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create another array of ones of shape (5, 3)\n",
    "ones2 = np.ones((5,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "operands could not be broadcast together with shapes (3,5) (5,3) ",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-29-8c8dd82e25b7>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Try add the array of ones and the other most recent array together\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mones\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mones2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (3,5) (5,3) "
     ]
    }
   ],
   "source": [
    "# Try add the array of ones and the other most recent array together\n",
    "ones + ones2\n",
    "# this wont work due to their shapes are not compatible"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you try the last cell, it produces an error. Why do think this is?\n",
    "\n",
    "How would you fix it?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create another array of ones of shape (3, 5)\n",
    "ones3 = np.ones((3,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2., 2., 2., 2., 2.],\n",
       "       [2., 2., 2., 2., 2.],\n",
       "       [2., 2., 2., 2., 2.]])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Subtract the new array of ones from the other most recent array\n",
    "arr_sum= ones3 + ones\n",
    "arr_sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4., 4., 4., 4., 4.],\n",
       "       [4., 4., 4., 4., 4.],\n",
       "       [4., 4., 4., 4., 4.]])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Multiplication\n",
    "arr_sum * arr_sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[8., 8., 8., 8., 8.],\n",
       "       [8., 8., 8., 8., 8.],\n",
       "       [8., 8., 8., 8., 8.]])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Take the latest array to the power of 3 using '**'\n",
    "arr_sum ** 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4., 4., 4., 4., 4.],\n",
       "       [4., 4., 4., 4., 4.],\n",
       "       [4., 4., 4., 4., 4.]])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Do the same thing with np.square()\n",
    "np.square(arr_sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[6, 3, 7, 4, 6],\n",
       "       [9, 2, 6, 7, 4],\n",
       "       [3, 7, 7, 2, 5]])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Find the mean of the latest array using np.mean()\n",
    "np.random.seed(42)\n",
    "arr = np.random.randint(0, 10, size=(3,5))\n",
    "print(np.mean(arr))\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Find the maximum of the latest array using np.max()\n",
    "np.max(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Find the minimum of the latest array using np.min()\n",
    "np.min(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.039607805437114"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Find the standard deviation of the latest array\n",
    "np.std(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.160000000000001"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Find the variance of the latest array\n",
    "np.var(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 5)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[[6],\n",
       "        [3],\n",
       "        [7],\n",
       "        [4],\n",
       "        [6]],\n",
       "\n",
       "       [[9],\n",
       "        [2],\n",
       "        [6],\n",
       "        [7],\n",
       "        [4]],\n",
       "\n",
       "       [[3],\n",
       "        [7],\n",
       "        [7],\n",
       "        [2],\n",
       "        [5]]])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Reshape the latest array to (3, 5, 1)\n",
    "print(arr.shape)\n",
    "arr.reshape(3,5,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5, 3)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[6, 9, 3],\n",
       "       [3, 2, 7],\n",
       "       [7, 6, 7],\n",
       "       [4, 7, 2],\n",
       "       [6, 4, 5]])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Transpose the latest array\n",
    "arr_t = arr.T\n",
    "print(arr_t.shape)\n",
    "arr_t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What does the transpose do?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[5 8 9]\n",
      " [5 0 0]\n",
      " [1 7 6]]\n",
      "[[9 2]\n",
      " [4 5]\n",
      " [2 4]]\n"
     ]
    }
   ],
   "source": [
    "# Create two arrays of random integers between 0 to 10\n",
    "# one of size (3, 3) the other of size (3, 2)\n",
    "np.random.seed(1)\n",
    "a1 = np.random.randint(0,10, size=(3,3))\n",
    "a2 = np.random.randint(0,10, size=(3,2))\n",
    "print(a1)\n",
    "print(a2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[95, 86],\n",
       "       [45, 10],\n",
       "       [49, 61]])"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Perform a dot product on the two newest arrays you created\n",
    "np.dot(a1,a2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create two arrays of random integers between 0 to 10\n",
    "# both of size (4, 3)\n",
    "np.random.seed(1)\n",
    "a3 = np.random.randint(0,10, size=(4,3))\n",
    "a4 = np.random.randint(0,10, size=(4,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "shapes (4,3) and (4,3) not aligned: 3 (dim 1) != 4 (dim 0)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-60-360688785031>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Perform a dot product on the two newest arrays you created\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0ma4\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<__array_function__ internals>\u001b[0m in \u001b[0;36mdot\u001b[0;34m(*args, **kwargs)\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: shapes (4,3) and (4,3) not aligned: 3 (dim 1) != 4 (dim 0)"
     ]
    }
   ],
   "source": [
    "# Perform a dot product on the two newest arrays you created\n",
    "np.dot(a3,a4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It doesn't work. How would you fix it\n",
    "\n",
    "Dot product is actually does matrix multiplication so that first array column size must match second array row size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 77, 105, 116,  89],\n",
       "       [ 25,  10,  35,  35],\n",
       "       [ 43,  72,  76,  43],\n",
       "       [ 65,  54,  85,  87]])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Take the latest two arrays, perform a transpose on one of them and then perform \n",
    "# a dot product on them both\n",
    "np.dot(a3,a4.T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how performing a transpose allows the dot product to happen.\n",
    "\n",
    "Why is this?\n",
    "\n",
    "Checking out the documentation on [`np.dot()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.dot.html) may help, as well as reading [Math is Fun's guide on the dot product](https://www.mathsisfun.com/algebra/vectors-dot-product.html).\n",
    "\n",
    "Let's now compare arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False,  True,  True],\n",
       "       [ True, False, False],\n",
       "       [False, False,  True],\n",
       "       [ True,  True, False]])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Compare the two arrays with '>'\n",
    "a3 > a4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What happens when you compare the arrays with `>`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ True,  True,  True],\n",
       "       [ True, False, False],\n",
       "       [False, False,  True],\n",
       "       [ True,  True, False]])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Compare the two arrays with '>='\n",
    "a3 >= a4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[False,  True,  True],\n",
       "       [False, False, False],\n",
       "       [False, False, False],\n",
       "       [ True, False, False]])"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Find which elements of the first array are greater than 7\n",
    "print(a3[0][1])\n",
    "a3 > 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ True, False, False],\n",
       "       [False, False, False],\n",
       "       [False, False, False],\n",
       "       [False, False, False]])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Which parts of each array are equal? (try using '==')\n",
    "a3 == a4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[5, 8, 9],\n",
       "       [0, 0, 5],\n",
       "       [1, 6, 7],\n",
       "       [2, 4, 9]])"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Sort one of the arrays you just created in ascending order\n",
    "np.sort(a3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [1, 2, 0],\n",
       "       [0, 2, 1],\n",
       "       [1, 2, 0]])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Sort the indexes of one of the arrays you just created\n",
    "np.argsort(a3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "# Find the index with the maximum value in one of the arrays you've created\n",
    "print(np.max(a3))\n",
    "print(np.argmax(a3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# Find the index with the minimum value in one of the arrays you've created\n",
    "print(np.min(a3))\n",
    "print(np.argmin(a3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Find the indexes with the maximum values down the verticial axis\n",
    "# of one of the arrays you created\n",
    "np.argmax(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 0, 1, 0])"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Find the indexes with the minimum values across the horizontal axis\n",
    "# of one of the arrays you created\n",
    "np.argmax(a3, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.13376944, -1.09989127, -0.17242821, -0.87785842,  0.04221375],\n",
       "       [ 0.58281521, -1.10061918,  1.14472371,  0.90159072,  0.50249434],\n",
       "       [ 0.90085595, -0.68372786, -0.12289023, -0.93576943, -0.26788808]])"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create an array of normally distributed random numbers\n",
    "np.random.randn(3, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  1.,  12.,  23.,  34.,  45.,  56.,  67.,  78.,  89., 100.])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create an array with 10 evenly spaced numbers between 1 and 100\n",
    "np.linspace(1, 100, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### I hope this will be helpful for you"
   ]
  }
 ],
 "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}