NumPy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NumPy\n",
    "\n",
    "Numpy stands for Numerical Python. Numpy(Numerical Python) is the core library for scientific computing in Python. It provides a high-performance multidimensional array object, and tools for working with arrays. It contains the data structures needed for storing and accessing arrays. It has simple operations and functions for computation of arrays. In addition to numeric data types, NumPy can store other data types such as strings, boolean, and etc.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NumPy Installation\n",
    "It is possible to install numpy on Jupyter notebook or the command prompt using the following command.\n",
    "\n",
    "```sh\n",
    "pip install numpy\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importing NumPy\n",
    "Numpy can be imported as follows\n",
    "\n",
    "If we want to use the numpy module without renaming we import it as follows.\n",
    "```py\n",
    "import numpy\n",
    "```\n",
    "It is common to rename the numpy module as np. To rename the name numpy to np we use the keyword *as* and the importing looks like as follows\n",
    "```py\n",
    "import numpy as np\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 244,
   "metadata": {},
   "outputs": [],
   "source": [
    "# How ot import numpy\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let us import matplot.lib  and seaborn for data visualization\n",
    "# installation of matplotlib and seaborn is required\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "sns.set()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 246,
   "metadata": {},
   "outputs": [],
   "source": [
    "## import stats for some statistical methods\n",
    "from scipy import stats"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NumPy Version\n",
    "Checking of the numPy version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 247,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NumPy: 1.19.2\n"
     ]
    }
   ],
   "source": [
    "# How check the version of numpy package\n",
    "print('NumPy:', np.__version__)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating of NumPy Arrays\n",
    "We can change Python list and tuple to NumPy array.\n",
    "Example of list and tuple:\n",
    "```py\n",
    "lst = [1, 2, 3, 4,5] # list\n",
    "tpl = (1, 2, 3, 4, 5) # tuple\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating NumPy array from Python lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Type :  <class 'list'>\n",
      "[1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "# creating python list\n",
    "lst = [1, 2, 3, 4, 5]\n",
    "# Checking data types\n",
    "print('Type : ', type(lst))\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 249,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0, 1, 2], [3, 4, 5], [6, 7, 8]]\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "lst_of_lsts = [[0, 1, 2], [3,4,5],[6,7,8]]\n",
    "print(lst_of_lsts)\n",
    "print(type(lst_of_lsts))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The numPy array has a *ndarry* data type which refers to n dimensional array. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 250,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Type: <class 'numpy.ndarray'>\n",
      "[1 2 3 4 5]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array(lst)\n",
    "print('Type:', type(arr))\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 251,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 2]\n",
      " [3 4 5]\n",
      " [6 7 8]]\n"
     ]
    }
   ],
   "source": [
    "two_dim_arr = np.array(lst_of_lsts)\n",
    "print(two_dim_arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating NumPy arrays with different data types\n",
    "It is possible to create a numpy array with different data types with dtype "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating integer NumPy array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 252,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n",
      "[1 2 3 4 5]\n",
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "# Python list\n",
    "lst = [1,2,3,4,5]\n",
    "print(lst)\n",
    "\n",
    "arr_int = np.array(lst, dtype='int')\n",
    "print(arr_int)\n",
    "print(type(arr_int))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating floating number NumPy array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n",
      "[1. 2. 3. 4. 5.]\n",
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "# Python list\n",
    "lst = [1,2,3,4,5]\n",
    "print(lst)\n",
    "\n",
    "arr_float = np.array(python_list, dtype='float')\n",
    "print(arr_float)\n",
    "print(type(arr_float))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating complex NumPy array\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 254,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n",
      "[1.+0.j 2.+0.j 3.+0.j 4.+0.j 5.+0.j]\n",
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "# Python list\n",
    "lst = [1,2,3,4,5]\n",
    "print(lst)\n",
    "\n",
    "arr_complex = np.array(lst, dtype='complex')\n",
    "print(arr_complex)\n",
    "print(type(arr_complex))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating String NumPy array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n",
      "['1' '2' '3' '4' '5']\n",
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "# Python list\n",
    "lst = [1,2,3,4,5]\n",
    "print(lst)\n",
    "arr_str = np.array(lst, dtype='str')\n",
    "print(arr_str)\n",
    "print(type(arr_str))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 256,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Apple' 'Avocado' 'Banana' 'Mango' 'Orange']\n"
     ]
    }
   ],
   "source": [
    "fruits = ['Apple','Avocado', 'Banana', 'Mango', 'Orange']\n",
    "fruits_arr = np.array(fruits)\n",
    "print(fruits_arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating Boolean NumPy Arrays\n",
    "Creating a boolean a NumPy array from list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "[False  True  True False False]\n"
     ]
    }
   ],
   "source": [
    "arr_bool = np.array([0, 1, -1, 0, 0], dtype=bool)\n",
    "print(type(arr_bool))\n",
    "print(arr_bool)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Summary of creating NumPy array with different data types*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 258,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5]\n",
      "[1. 2. 3. 4. 5.]\n",
      "[ True  True  True False  True  True  True  True]\n",
      "[1.+0.j 2.+0.j 3.+0.j 4.+0.j 5.+0.j]\n",
      "['1' '2' '3' '4' '5.0']\n"
     ]
    }
   ],
   "source": [
    "np_int_arr = np.array([1,2,3,4,5.0], dtype = 'int')\n",
    "np_float_arr = np.array([1,2,3,4,5.0], dtype = 'float')\n",
    "np_bool_arr = np.array([-3, -2, -1, 0,2,3,4,5.0], dtype = 'bool')\n",
    "np_complex_arr = np.array([1, 2,3,4,5.0], dtype = 'complex')\n",
    "np_str_arr = np.array([1,2,3,4,5.0], dtype = 'str')\n",
    "\n",
    "print(np_int_arr)\n",
    "print(np_float_arr)\n",
    "print(np_bool_arr)\n",
    "print(np_complex_arr)\n",
    "print(np_str_arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nested list can create multidimensional numPy arrays. It is possible to create a multidimensional array using Python list of lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 259,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 2]\n",
      " [3 4 5]\n",
      " [6 7 8]]\n"
     ]
    }
   ],
   "source": [
    "lst_of_lsts = [[0,1,2], [3,4,5], [6,7,8]]\n",
    "two_dim_arr = np.array(lst_of_lsts)\n",
    "print(two_dim_arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### NumPy array attributes\n",
    "The numPy array has different attributes that give more information about the array such as *ndim*, *shape*, *size*, *dtype*, *itemsize*\n",
    "- ndim - returns the dimension of the numPy array\n",
    "- shape - returns the number of rows and columns of a numPy array\n",
    "- size - the total number of elements in the numPy array\n",
    "- dtype - returns the data type of the numPy array \n",
    "- itemsize - returns the size in bytes of each elements in the numPy array\n",
    "\n",
    "The NumPy *shape* method provide the shape of the array as a tuple. The first is the row and the second is the column. If the array is just one dimensional it returns the size of the array(n,)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 260,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NumPy array dimension:  1\n",
      "NumPy array shape:  1\n",
      "NumPy array size:  5\n",
      "NumPy array data type:  int32\n",
      "NumPy array item size:  4\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([1, 2, 3, 4,5])\n",
    "print('NumPy array dimension: ', arr.ndim)\n",
    "print('NumPy array shape: ', arr.ndim)\n",
    "print('NumPy array size: ', arr.size)\n",
    "print('NumPy array data type: ', arr.dtype)\n",
    "print('NumPy array item size: ', arr.itemsize)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating Multidimensional Array Using NumPy\n",
    "We can create different dimension numPy array."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### NumPy array without dimension or zero deminsion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 261,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "The numPy n-d:0,shape:(), size:1, date type:int32, itemsize:4\n"
     ]
    }
   ],
   "source": [
    "ten = np.array(10)\n",
    "print(ten)\n",
    "print(f'The numPy n-d:{ten.ndim},shape:{ten.shape}, size:{ten.size}, date type:{ten.dtype}, itemsize:{ten.itemsize}') "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use simple function that provides information about the numPy array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 262,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_numpy_array_info(arr):\n",
    "    print(f'The numPy n-d:{arr.ndim},shape:{arr.shape}, size:{arr.size}, date type:{arr.dtype}, itemsize:{arr.itemsize}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### One dimension numPy array\n",
    "A list can create a one dimensional numPy array.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 263,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n",
      "[1 2 3 4 5]\n",
      "The numPy n-d:1,shape:(5,), size:5, date type:int32, itemsize:4\n"
     ]
    }
   ],
   "source": [
    "lst = [1, 2, 3, 4, 5]\n",
    "arr = np.array(lst)\n",
    "print(lst)\n",
    "print(arr)\n",
    "get_numpy_array_info(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Two dimensional numPy array\n",
    "A list of list can create a 2-d numPy array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 271,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n",
      "The numPy n-d:1,shape:(5,), size:5, date type:int32, itemsize:4\n"
     ]
    }
   ],
   "source": [
    "lst = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
    "two_dim_arr  = np.array(lst)\n",
    "print(lst)\n",
    "print(two_dim_arr)\n",
    "get_numpy_array_info(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 272,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n",
      "Dim: 2\n",
      "Shape:  (3, 3)\n",
      "Size: 9\n",
      "Data type: int32\n"
     ]
    }
   ],
   "source": [
    "# 2 Dimension Array\n",
    "two_dim_arr = np.array([(1,2,3),(4,5,6), (7,8,9)])\n",
    "print(type (two_dim_arr))\n",
    "print(two_dim_arr)\n",
    "print('Dim:', two_dim_arr.ndim)\n",
    "print('Shape: ', two_dim_arr.shape)\n",
    "print('Size:', two_dim_arr.size)\n",
    "print('Data type:', two_dim_arr.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Three dimensional numPy array\n",
    "List of lists of list create a 3-d numPy array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 291,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[1, 2, 3], [4, 5, 6], [7, 8, 9]]]\n",
      "[[[1 2 3]\n",
      "  [4 5 6]\n",
      "  [7 8 9]]]\n",
      "The numPy n-d:3,shape:(1, 3, 3), size:9, date type:int32, itemsize:4\n"
     ]
    }
   ],
   "source": [
    "lst = [[[1, 2, 3], [4, 5, 6], [7, 8, 9]]]\n",
    "three_dim_arr = np.array(lst)\n",
    "print(lst)\n",
    "print(three_dim_arr)\n",
    "get_numpy_array_info(two_dim_arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Converting NumPy array to list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 292,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5]\n",
      "[[[1, 2, 3], [4, 5, 6], [7, 8, 9]]]\n"
     ]
    }
   ],
   "source": [
    "lst = [1, 2, 3, 4, 5]\n",
    "arr = np.array(lst)\n",
    "print(arr)\n",
    "lst = arr.tolist()\n",
    "lst_of_lsts = two_dim_arr.tolist()\n",
    "print(lst_of_lsts )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 308,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "print(lst)\n",
    "print(type(lst))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating NumPy Array from Tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 309,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "tpl = (1,2,3,4,5)\n",
    "print(type(tpl))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 310,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "numpy_array_from_tuple: [1 2 3 4 5]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array(tpl)\n",
    "print(type(arr))\n",
    "print('numpy_array_from_tuple:',arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 311,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[1 2 3]\n",
      "  [4 5 6]\n",
      "  [7 8 9]]]\n"
     ]
    }
   ],
   "source": [
    "print(two_dim_arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 312,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "She of numpy_two_dimensional_array:  (1, 3, 3)\n"
     ]
    }
   ],
   "source": [
    "print('She of numpy_two_dimensional_array: ', two_dim_arr.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Size of a NumPy array\n",
    "In NumPy to know the number of items in a NumPy array list we use size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 313,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = [1, 2, 3, 4, 5]\n",
    "arr = np.array(lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 314,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Size:  5\n"
     ]
    }
   ],
   "source": [
    "print('Size: ', arr.size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 315,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 2]\n",
      " [3 4 5]\n",
      " [6 7 8]]\n"
     ]
    }
   ],
   "source": [
    "print(np_two_dim_arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 316,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Size:  9\n"
     ]
    }
   ],
   "source": [
    "print('Size: ', np_two_dim_arr.size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Type of NumPy Array\n",
    "Type of data types: str, int, float, complex, bool, list, None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 317,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-3 -2 -1  0  1  2  3]\n",
      "int32\n",
      "[-3. -2. -1.  0.  1.  2.  3.]\n",
      "float64\n"
     ]
    }
   ],
   "source": [
    "int_lists = [-3, -2, -1, 0, 1, 2,3]\n",
    "int_arr = np.array(int_lists)\n",
    "print(int_arr)\n",
    "print(int_arr.dtype)\n",
    "float_arr = np.array(int_lists, dtype=float)\n",
    "print(float_arr)\n",
    "print(float_arr.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterating NumPy Array\n",
    "\n",
    "We can iterate through each elements of numPy array using loops. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 318,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dim: 1\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "# 1-d array\n",
    "arr = np.array([1, 2, 3, 4, 5])\n",
    "print('Dim:', arr.ndim)\n",
    "for item in arr:\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 319,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dim: 2\n",
      "[1 2]\n",
      "[3 4]\n",
      "[5 6]\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "# 2-d array\n",
    "arr = np.array([[1, 2], [3, 4], [5,6]])\n",
    "print('Dim:', arr.ndim)\n",
    "for item in arr:\n",
    "    print(item)\n",
    "    \n",
    "\n",
    "for item in arr:\n",
    "    for i in item:\n",
    "        print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 320,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dim: 3\n",
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]]\n",
      "[[ 7  8]\n",
      " [ 9 10]\n",
      " [11 12]]\n"
     ]
    }
   ],
   "source": [
    "# 3-d array\n",
    "arr = np.array([[[1, 2], [3, 4], [5, 6]], [[7, 8], [9, 10], [11, 12]]])\n",
    "print('Dim:', arr.ndim)\n",
    "for item in arr:\n",
    "    print(item)\n",
    "    \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Iterating using ndenumerator method allow to access the element with the location of the specific element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 321,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "((0, 0, 0), 1)\n",
      "((0, 0, 1), 2)\n",
      "((0, 1, 0), 3)\n",
      "((0, 1, 1), 4)\n",
      "((0, 2, 0), 5)\n",
      "((0, 2, 1), 6)\n",
      "((1, 0, 0), 7)\n",
      "((1, 0, 1), 8)\n",
      "((1, 1, 0), 9)\n",
      "((1, 1, 1), 10)\n",
      "((1, 2, 0), 11)\n",
      "((1, 2, 1), 12)\n"
     ]
    }
   ],
   "source": [
    "for x in np.ndenumerate(arr):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mathematical Operation Using NumPy\n",
    "Numpy array is not like exactly like python list. To do mathematical operation in pyhton list we have to loop through the items but numpy can allow to do any mathematical operation without looping. Mathematical Operation:\n",
    "\n",
    "- Addition (+)  \n",
    "- Subtraction (-)  \n",
    "- Multiplication (*)  \n",
    "- Division (/)  \n",
    "- Modules (%)  \n",
    "- Floor Division(//)  \n",
    "- Exponential(**)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Addition\n",
    "Adding to scalar value is easy but add some value on a python list is not an easy operation. However, numPy array made it easy to do arithemtic operation without a use of any loops."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 323,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "original array:  [1 2 3 4 5]\n",
      "[11 12 13 14 15]\n"
     ]
    }
   ],
   "source": [
    "# Mathematical Operation\n",
    "# Addition\n",
    "arr = np.array([1, 2, 3, 4, 5])\n",
    "print('original array: ',arr)\n",
    "ten_plus_original = arr  + 10\n",
    "print(ten_plus_original)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Subtraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 325,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "original array:  [1 2 3 4 5]\n",
      "[-9 -8 -7 -6 -5]\n"
     ]
    }
   ],
   "source": [
    "# Subtraction\n",
    "arr = np.array([1, 2, 3, 4, 5])\n",
    "print('original array: ',arr)\n",
    "ten_minus_original = arr  - 10\n",
    "print(ten_minus_original)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Multiplication\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 326,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "original array:  [1 2 3 4 5]\n",
      "[10 20 30 40 50]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([1, 2, 3, 4, 5])\n",
    "print('original array: ', arr)\n",
    "ten_times_original = arr * 10\n",
    "print(ten_times_original)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 327,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23\n",
      " 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47\n",
      " 48 49]\n",
      "[ 0  2  4  6  8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40 42 44 46\n",
      " 48 50 52 54 56 58 60 62 64 66 68 70 72 74 76 78 80 82 84 86 88 90 92 94\n",
      " 96 98]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# let's  seee some use cases\n",
    "\n",
    "x = np.array(range(0,50))\n",
    "y = x * 2\n",
    "print(x)\n",
    "print(y)\n",
    "plt.scatter(x,y, c='brown')\n",
    "plt.title('X vs Y')\n",
    "plt.xlabel('X Axis')\n",
    "plt.ylabel('Y Axis')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Division"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 336,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "original array:  [1 2 3 4 5]\n",
      "[0.1 0.2 0.3 0.4 0.5]\n"
     ]
    }
   ],
   "source": [
    "# Division\n",
    "arr = np.array([1, 2, 3, 4, 5])\n",
    "print('original array: ', arr)\n",
    "ten_times_original =arr  / 10\n",
    "print(ten_times_original)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 337,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "original array:  [1 2 3 4 5]\n",
      "[1 2 0 1 2]\n"
     ]
    }
   ],
   "source": [
    "### Modulus\n",
    "# Modulus; Finding the remainder\n",
    "arr = np.array([1, 2, 3, 4, 5])\n",
    "print('original array: ',arr)\n",
    "ten_times_original = arr % 3\n",
    "print(ten_times_original)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modulos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 343,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "original array:  [ 1  2  3  4  5 11]\n",
      "[0 0 0 0 0 1]\n"
     ]
    }
   ],
   "source": [
    "#modulous: the division result without the remainder\n",
    "arr = np.array([1, 2, 3, 4, 5, 11])\n",
    "print('original array: ', arr)\n",
    "ten_times_original = arr // 10\n",
    "print(ten_times_original)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Floor Division"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 344,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "original array:  [ 1  2  3  4  5 11]\n",
      "[0 0 0 0 0 1]\n"
     ]
    }
   ],
   "source": [
    "# Floor division: the division result without the remainder\n",
    "arr = np.array([1, 2, 3, 4, 5, 11])\n",
    "print('original array: ', arr)\n",
    "ten_times_original = arr // 10\n",
    "print(ten_times_original)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exponential"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 359,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "original array:  [1 2 3 4 5]\n",
      "[ 1  4  9 16 25]\n"
     ]
    }
   ],
   "source": [
    "# Exponential is finding some number the power of another:\n",
    "arr = np.array([1, 2, 3, 4, 5])\n",
    "print('original array: ', arr)\n",
    "ten_times_original = arr  ** 2\n",
    "print(ten_times_original)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Converting Data Types\n",
    "We can convert the data types of numpy array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Converting Data Types from Int to Float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 366,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "np_int_arr = np.array([1,2,3,4])\n",
    "print(np_int_arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 367,
   "metadata": {},
   "outputs": [],
   "source": [
    "np_float_arr = np_int_arr.astype('float')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 368,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1. 2. 3. 4.]\n"
     ]
    }
   ],
   "source": [
    "print(np_float_arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Converting Data Types \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 369,
   "metadata": {},
   "outputs": [],
   "source": [
    "# to int\n",
    "np_int_arr = np_float_arr.astype('int')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 370,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "print(np_int_arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 371,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1. 2. 3. 4.]\n"
     ]
    }
   ],
   "source": [
    "#to float\n",
    "\n",
    "np_float_arr = np_int_arr.astype('float')\n",
    "print(np_float_arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 372,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ True  True False  True  True  True]\n"
     ]
    }
   ],
   "source": [
    "# Converting Data Types Int to Boolean\n",
    "np_bool_arr = np.array([-3, -2, 0, 1,2,3]).astype('bool')\n",
    "print(np_bool_arr)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 373,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['1' '2' '3' '4']\n"
     ]
    }
   ],
   "source": [
    "# int to string\n",
    "np_str_arr = np_int_arr.astype('str')\n",
    "print(np_str_arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Getting items from a numpy array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 374,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First row: [1 2 3]\n",
      "Second row: [4 5 6]\n",
      "Third row:  [7 8 9]\n"
     ]
    }
   ],
   "source": [
    "# 2 Dimension Array\n",
    "two_dim_arr = np.array([[1,2,3],[4,5,6], [7,8,9]])\n",
    "first_row = two_dim_arr[0]\n",
    "second_row = two_dim_arr[1]\n",
    "third_row = two_dim_arr[2]\n",
    "print('First row:', first_row)\n",
    "print('Second row:', second_row)\n",
    "print('Third row: ', third_row)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 375,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First column: [1 4 7]\n",
      "Second column: [2 5 8]\n",
      "Third column:  [3 6 9]\n",
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n"
     ]
    }
   ],
   "source": [
    "first_column= two_dim_arr[:,0]\n",
    "second_column = two_dim_arr[:,1]\n",
    "third_column = two_dim_arr[:,2]\n",
    "print('First column:', first_column)\n",
    "print('Second column:', second_column)\n",
    "print('Third column: ', third_column)\n",
    "print(two_dim_arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NumPy array Indexing\n",
    "\n",
    "Accessing one dimensional array elements is similar to accessing list elements. The first element can be accessed by index 0. See the example below. Negative indexing is also possible. The last element is at -1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 376,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([1, 2, 3, 4, 5])\n",
    "print(arr[0])\n",
    "print(arr[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Accessing two or more dimensional array elements is a bit different from accessing ordinary list. In order to access a 2-D array element, we use the numbers separated by a comma.\n",
    "The first numbers reperesents the dimension and the second number refers to the index of the lement.Let's see an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 377,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n",
      "3\n",
      "dim: 2\n"
     ]
    }
   ],
   "source": [
    "# 2-D\n",
    "lst_lst =[[1,2,3],[4,5,6],[7,8,9]]\n",
    "two_dim_arr = np.array(lst_lst)\n",
    "print(two_dim_arr)\n",
    "print(two_dim_arr[0, 2])\n",
    "print('dim:', two_dim_arr.ndim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 378,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[1 2 3]\n",
      "  [4 5 6]\n",
      "  [7 8 9]]]\n",
      "9\n",
      "dim: 3\n"
     ]
    }
   ],
   "source": [
    "# 3-D\n",
    "\n",
    "lst_lst_lst = [[[1,2,3],[4,5,6],[7,8,9]]]\n",
    "three_dim_arr = np.array(lst_lst_lst)\n",
    "print(three_dim_arr)\n",
    "print(three_dim_arr[0, 2, 2]) # the\n",
    "print('dim:', three_dim_arr.ndim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Slicing some parts of Numpy array\n",
    "Slicing in numpy is similar to slicing in python list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 379,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5]\n",
      "[1 2 3 4 5]\n",
      "[1 2 3 4 5]\n",
      "[1 3 5]\n",
      "[1 2 3]\n",
      "[4 5]\n"
     ]
    }
   ],
   "source": [
    "# [start:end:step]\n",
    "# [:] \n",
    "arr = np.array([1, 2, 3, 4, 5])\n",
    "print(arr)\n",
    "print(arr[:])\n",
    "print(arr[::])\n",
    "print(arr[::2]) # 2 is a step\n",
    "print(arr[0:3])\n",
    "print(arr[3:])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 380,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n"
     ]
    }
   ],
   "source": [
    "# Gives the same numPy array\n",
    "two_dim_arr = np.array([[1,2,3],[4,5,6], [7,8,9]])\n",
    "print(two_dim_arr[::])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 381,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First row [[1 2 3]\n",
      " [4 5 6]]\n",
      "[1 4 7]\n",
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n",
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n",
      "[[1 2]\n",
      " [4 5]\n",
      " [7 8]]\n",
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "two_dim_arr = np.array([[1,2,3],[4,5,6], [7,8,9]])\n",
    "print('First row', two_dim_arr[0:2]) # slices the first two rows\n",
    "print(two_dim_arr[0:3, 0]) # slices the first item in each column\n",
    "first_two_rows_and_columns = two_dim_arr[0:3, 0:2]\n",
    "print(two_dim_arr[:])\n",
    "print(two_dim_arr)\n",
    "print(first_two_rows_and_columns)\n",
    "print(type(two_dim_arr))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 382,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([8, 9])"
      ]
     },
     "execution_count": 382,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "two_dim_arr[2, 1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 383,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3,  7],\n",
       "       [ 4,  5,  6, 15],\n",
       "       [ 7,  8,  9, 24],\n",
       "       [10, 11, 12, 33]])"
      ]
     },
     "execution_count": 383,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Slicing out the middle four items\n",
    "two_dim_arr_2= np.array([[1,2,3,7],[4,5,6, 15], [7,8,9,24],  [10,11,12, 33]])\n",
    "two_dim_arr_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 384,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[5, 6],\n",
       "       [8, 9]])"
      ]
     },
     "execution_count": 384,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "two_dim_arr_2[1:3, 1:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 385,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3,  7],\n",
       "       [ 4, 25, 25, 15],\n",
       "       [ 7, 25, 25, 24],\n",
       "       [10, 11, 12, 33]])"
      ]
     },
     "execution_count": 385,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Assigning \n",
    "two_dim_arr_2[1:3, 1:3] = 25\n",
    "two_dim_arr_2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to reverse the rows and the whole array?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 386,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6],\n",
       "       [7, 8, 9]])"
      ]
     },
     "execution_count": 386,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "two_dim_arr[::]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 387,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[7, 8, 9],\n",
       "       [4, 5, 6],\n",
       "       [1, 2, 3]])"
      ]
     },
     "execution_count": 387,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "two_dim_arr[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reverse the row and column positions\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 388,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[9, 8, 7],\n",
       "       [6, 5, 4],\n",
       "       [3, 2, 1]])"
      ]
     },
     "execution_count": 388,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "two_dim_arr = np.array([[1,2,3],[4,5,6], [7,8,9]])\n",
    "two_dim_arr[::-1,::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 389,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[9, 8, 7],\n",
       "       [6, 5, 4],\n",
       "       [3, 2, 1]])"
      ]
     },
     "execution_count": 389,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "two_dim_arr[::-1, ::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 390,
   "metadata": {},
   "outputs": [],
   "source": [
    "## How to represent missing values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 391,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n",
      "[[ 1  2  3]\n",
      " [ 4 55 44]\n",
      " [ 7  8  9]]\n"
     ]
    }
   ],
   "source": [
    "print(two_dim_arr)\n",
    "two_dim_arr[1,1] = 55\n",
    "two_dim_arr[1,2] = 44\n",
    "print(two_dim_arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### NumPy Zeros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 392,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0],\n",
       "       [0, 0, 0],\n",
       "       [0, 0, 0]])"
      ]
     },
     "execution_count": 392,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Numpy Zeroes\n",
    "# numpy.zeros(shape, dtype=float, order='C')\n",
    "numpy_zeroes = np.zeros((3,3),dtype=int)\n",
    "numpy_zeroes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numpy ones\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 393,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 1 1 1 1]\n",
      " [1 1 1 1 1]\n",
      " [1 1 1 1 1]]\n"
     ]
    }
   ],
   "source": [
    "# Numpy ones\n",
    "numpy_ones = np.ones((3,5),dtype=int,order='C')\n",
    "print(numpy_ones)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 394,
   "metadata": {},
   "outputs": [],
   "source": [
    "twos = numpy_ones * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 395,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 2 2 2 2]\n",
      " [2 2 2 2 2]\n",
      " [2 2 2 2 2]]\n"
     ]
    }
   ],
   "source": [
    "print(twos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### NumPy Full to create identical itmes\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 396,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[4 4 4 4 4]\n",
      " [4 4 4 4 4]\n",
      " [4 4 4 4 4]]\n"
     ]
    }
   ],
   "source": [
    "np_full = np.full((3, 5), fill_value=4)\n",
    "print(np_full)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### NumPy Eye\n",
    "\n",
    "The eye function creates an identity matrix, that is, a matrix with elements on the diagonal are set to one, and non-diagonal elements are set to zero:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 397,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 0 0]\n",
      " [0 1 0]\n",
      " [0 0 1]]\n"
     ]
    }
   ],
   "source": [
    "np_eye = np.eye(3, dtype=int)\n",
    "print(np_eye)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 398,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 0 0 0 0]\n",
      " [0 1 0 0 0]\n",
      " [0 0 1 0 0]\n",
      " [0 0 0 1 0]\n",
      " [0 0 0 0 1]]\n"
     ]
    }
   ],
   "source": [
    "np_eye2 = np.eye(5, dtype=int)\n",
    "print(np_eye2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### NumPy Empty\n",
    "The NumPy *empty* method returns a new array of given shape and type, with random values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 399,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 1., 0.],\n",
       "       [0., 1., 1., 1.]])"
      ]
     },
     "execution_count": 399,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.empty((2, 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 400,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 400,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.empty((2, 2), dtype=int)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Shape and Reshape a numPy array\n",
    "The *shape* attribute provide the dimension of the numPy array. The reshape method takes arguments and reshape the array to a different dimension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 401,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(12,)"
      ]
     },
     "execution_count": 401,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nums = np.arange(12)\n",
    "nums.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 402,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0  1  2  3  4  5  6  7  8  9 10 11]\n",
      "[[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]]\n",
      "2\n",
      "(3, 4)\n"
     ]
    }
   ],
   "source": [
    "nums = np.arange(12)\n",
    "print(nums)\n",
    "new_arr = nums.reshape(3, 4)\n",
    "print(new_arr)\n",
    "print(new_arr.ndim) # 2-d\n",
    "print(new_arr.shape) # 3 rows and 3 columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 403,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0  1  2  3  4  5  6  7  8  9 10 11]\n",
      "[[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]]\n"
     ]
    }
   ],
   "source": [
    "nums = np.arange(12)\n",
    "print(nums)\n",
    "new_arr = nums.reshape(3, 4)\n",
    "print(new_arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reshape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 404,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n",
      "(2, 3)\n",
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# numpy.reshape(), numpy.flatten()\n",
    "first_shape  = np.array([(1,2,3), (4,5,6)])\n",
    "print(first_shape)\n",
    "print(first_shape.shape)\n",
    "reshaped = first_shape.reshape(3,2)\n",
    "print(reshaped)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Flatten\n",
    "The flaten method changes the numPy array to 1-dimensional array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 405,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6]\n",
      "Shape: (6,) Dim: 1\n"
     ]
    }
   ],
   "source": [
    "flattened = reshaped.flatten()\n",
    "print(flattened)\n",
    "print('Shape:', flattened.shape, 'Dim:', flattened.ndim)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 406,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[ 1  2]\n",
      "  [ 3  4]]\n",
      "\n",
      " [[ 5  6]\n",
      "  [ 7  8]]\n",
      "\n",
      " [[ 9 10]\n",
      "  [11 12]]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])\n",
    "newarr = arr.reshape(3, 2, 2)\n",
    "print(newarr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Concatenating Numpy arrays\n",
    "By default the NumPy concatenate method joins the arrays along axis 0. To join the arrays horizontally, add parameter axis=1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 407,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(2)\n",
    "y = np.arange(2, 5)\n",
    "z = np.concatenate((x, y))\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 408,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(1, 10).reshape(3,3)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 412,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]\n",
      " [1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n"
     ]
    }
   ],
   "source": [
    "# concant\n",
    "print(np.concatenate((x, x), axis = 0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 413,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3 1 2 3]\n",
      " [4 5 6 4 5 6]\n",
      " [7 8 9 7 8 9]]\n"
     ]
    }
   ],
   "source": [
    "# concant\n",
    "print(np.concatenate((x, x), axis=1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Joining with stack method\n",
    "It is possible to join horizontally or vertically by changing the value of axis to 0 or 1. The default axis value is zero and that means a horizontal join.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 421,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "concatenating list: [5 7 9]\n",
      "[[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    " ## Horitzontal Stack\n",
    "np_list_one = np.array([1,2,3])\n",
    "np_list_two = np.array([4,5,6])\n",
    "print('concatenating list:', np_list_one + np_list_two)\n",
    "print(np.stack((np_list_one, np_list_two))) # default axis value is zero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 425,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5 7 9]\n",
      "[[1 4]\n",
      " [2 5]\n",
      " [3 6]]\n"
     ]
    }
   ],
   "source": [
    " ## Horitzontal Stack\n",
    "np_list_one = np.array([1,2,3])\n",
    "np_list_two = np.array([4,5,6])\n",
    "print( np_list_one + np_list_two)\n",
    "print(np.stack((np_list_one, np_list_two), axis=1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Horizontal Stack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 426,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5 7 9]\n",
      "Horizontal Append:\n",
      " [1 2 3 4 5 6]\n"
     ]
    }
   ],
   "source": [
    " ## Horitzontal Stack\n",
    "np_list_one = np.array([1,2,3])\n",
    "np_list_two = np.array([4,5,6])\n",
    "print(np_list_one + np_list_two)\n",
    "print('Horizontal Append:\\n', np.hstack((np_list_one, np_list_two)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Vertical Stack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 427,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vertical Append: [[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    " ## Vertical Stack\n",
    "print('Vertical Append:', np.vstack((np_list_one, np_list_two)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generating Random Numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 437,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 437,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Generating a random integers between 0 and 10 inclusive\n",
    "\n",
    "random_int = np.random.randint(0, 11)\n",
    "random_int"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 438,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.4099787844112669\n"
     ]
    }
   ],
   "source": [
    "# Generate a random float  number between 0 and 0.999..\n",
    "random_float = np.random.random()\n",
    "print(random_float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 439,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.22587659 0.0188218  0.1005489  0.22376462 0.86790537]\n"
     ]
    }
   ],
   "source": [
    " # Generate a random numpy array of float  numbers\n",
    "random_floats = np.random.random(5)\n",
    "print(random_floats)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 441,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.16948871 0.58021159 0.4058133 ]\n",
      " [0.15162521 0.42037159 0.52096055]]\n"
     ]
    }
   ],
   "source": [
    "# Random numbers between [0,1) of shape 2,3\n",
    "np_random_nums = np.random.random(size=(2, 3))\n",
    "print(np_random_nums)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 443,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.16948871, 0.58021159, 0.4058133 , 0.15162521, 0.42037159,\n",
       "       0.52096055])"
      ]
     },
     "execution_count": 443,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np_random_nums.shape\n",
    "np_random_nums.flatten()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 444,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.12099852, 0.05660326],\n",
       "       [0.69331399, 0.8406786 ]])"
      ]
     },
     "execution_count": 444,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## Random numbers between [0, 1] of shape 2, 2\n",
    "rand = np.random.rand(2,2)\n",
    "rand"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 449,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 8, 2, 5])"
      ]
     },
     "execution_count": 449,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " # Generating a random integers between 2 and 11, and creating a one row array\n",
    "random_int = np.random.randint(2,10, size= 4)\n",
    "random_int"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 451,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[9, 9, 3, 5],\n",
       "       [3, 4, 2, 3]])"
      ]
     },
     "execution_count": 451,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " # Generating a random integers between 2 and 11, and creating 2-dim array\n",
    "random_ints = np.random.randint(2,10, size=(2,4))\n",
    "random_ints"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 452,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[7, 5, 9],\n",
       "       [8, 5, 7],\n",
       "       [3, 6, 3]])"
      ]
     },
     "execution_count": 452,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Generating a random integers between 0 and 10, [0, 10)\n",
    "random_int = np.random.randint(2,10, size=(3,3))\n",
    "random_int"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 453,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[8, 2, 7],\n",
       "       [6, 2, 7],\n",
       "       [3, 8, 9]])"
      ]
     },
     "execution_count": 453,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Generating a random integers between 0 and 10, [0, 10)\n",
    "random_int = np.random.randint(2,10,(3,3))\n",
    "random_int"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 457,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['u' 'u' 'i']\n"
     ]
    }
   ],
   "source": [
    "print(np.random.choice(['a', 'e', 'i', 'o', 'u'], size=3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 459,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['h' 't' 'y' 'o' 'y']\n"
     ]
    }
   ],
   "source": [
    "print(np.random.choice(list('Python'), size=5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 462,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nNa3RMvCtyIebVkbmEy7lkKG\n",
      "24\n"
     ]
    }
   ],
   "source": [
    "random_id = np.random.choice(list('abcdefghijklmnopkrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'), size=24).tolist()\n",
    "random_id = ''.join(random_id)\n",
    "print(random_id)\n",
    "print(len(random_id))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 468,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CJGmWahaGYgC\n",
      "Stg3zm\n",
      "eSoiGdkz1wPgeyQ7MOBV6wWU\n"
     ]
    }
   ],
   "source": [
    "def generate_random_id(n = 12):\n",
    "    random_id = np.random.choice(list('abcdefghijklmnopkrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'), size = n).tolist()\n",
    "    random_id = ''.join(random_id)\n",
    "    return random_id\n",
    "\n",
    "print(generate_random_id())\n",
    "print(generate_random_id(6))\n",
    "print(generate_random_id(24))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generating random data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 472,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "[-9.09125352e-03 -8.40358293e-01 -8.79495448e-01 -9.44144541e-02\n",
      " -2.27699460e-01 -5.23188528e-01 -3.27116558e-01 -9.61947088e-01\n",
      " -3.68652591e-01 -6.84148999e-01 -6.39685163e-03 -6.76768498e-02\n",
      " -2.18129853e-01 -9.01380247e-01 -4.24606130e-01 -4.14084199e-01\n",
      " -1.69767803e-01 -7.83344411e-01 -6.37814720e-02 -5.92400457e-01\n",
      " -7.12388759e-01 -9.41375494e-01 -7.17421556e-01 -1.14963817e-01\n",
      " -8.43083349e-01 -3.90743028e-01 -4.92756774e-01 -7.97481607e-01\n",
      " -9.52791541e-01 -7.10127285e-01 -8.43260962e-01 -3.12651822e-01\n",
      " -5.68688931e-02 -2.91650420e-02 -1.36216117e-01 -4.60461495e-01\n",
      " -6.76362399e-01 -5.08259844e-01 -7.15531881e-01 -3.11324087e-01\n",
      " -6.02793104e-01 -3.70027385e-02 -3.79979242e-01 -2.59870216e-01\n",
      " -4.36218322e-02 -7.63578896e-01 -6.47027340e-03 -3.79266317e-01\n",
      " -4.04224549e-03 -3.44907121e-01 -3.57242331e-01 -9.21954753e-01\n",
      " -7.44045315e-02 -8.45647078e-01 -7.80209001e-01 -9.07885277e-01\n",
      " -9.83812403e-01 -7.05245358e-02 -7.38523741e-01 -4.89655720e-01\n",
      " -5.65514888e-01 -3.17580037e-01 -8.80281878e-01 -7.60121034e-01\n",
      " -4.10095886e-02 -9.79172451e-01 -3.98421793e-01 -6.96631633e-01\n",
      " -4.83739568e-02 -2.02266888e-01 -6.62963076e-01 -7.36773137e-01\n",
      " -8.03914227e-01 -5.78607924e-01 -4.54958253e-01 -1.67396289e-01\n",
      " -6.50449806e-01 -4.42404361e-01 -1.55549250e-01 -6.41896947e-01\n",
      " -6.53318839e-01 -5.30748093e-01 -8.97816915e-01 -2.83987823e-01\n",
      " -3.47466019e-01 -9.62180601e-02 -7.62139018e-01 -9.02718891e-01\n",
      " -5.82781813e-01 -9.86450244e-01 -5.51358058e-01 -7.37433663e-01\n",
      " -6.04949871e-01 -4.91438847e-01 -4.50302870e-01 -3.06437665e-01\n",
      " -9.82949978e-02 -1.50993560e-01 -6.43313038e-01 -7.52067985e-01\n",
      " -4.26257121e-01 -8.70073441e-01 -7.64453068e-01 -8.91880955e-01\n",
      " -5.22640303e-01 -7.79619677e-01 -7.07316894e-01 -4.27452778e-01\n",
      " -7.89869967e-02 -8.27971164e-01 -8.13974792e-01 -1.87508955e-01\n",
      " -6.46155953e-01 -4.42914243e-01 -5.00627129e-02 -3.37932521e-01\n",
      " -6.57893682e-02 -9.95659249e-02 -8.85698064e-01 -3.56874695e-01\n",
      " -6.58388598e-01 -6.03151279e-01 -5.84837636e-01 -9.81092762e-01\n",
      " -4.68323041e-01 -2.45465949e-01 -7.40622075e-01 -9.41265816e-01\n",
      " -2.14822006e-01 -8.80119056e-01 -7.01649180e-01 -4.72683939e-01\n",
      " -6.28784457e-01 -5.52344501e-01 -5.62941992e-01 -1.02595250e-01\n",
      " -6.26977082e-02 -9.24681235e-01 -1.62174271e-01 -3.27026942e-01\n",
      " -8.86587646e-02 -5.89784090e-01 -4.97082230e-01 -1.09442615e-01\n",
      " -3.98730851e-01 -6.07873616e-02 -3.88360815e-01 -2.72666190e-03\n",
      " -1.02037833e-01 -3.76195164e-01 -6.64060088e-01 -8.50042907e-01\n",
      " -6.44240074e-01 -3.73994910e-01 -9.46436748e-01 -4.48696670e-01\n",
      " -7.34609935e-01 -7.02230827e-01 -5.48038179e-01 -2.97613024e-01\n",
      " -2.55060023e-01 -9.99522266e-01 -6.13501857e-01 -4.66328089e-01\n",
      " -1.65721655e-01 -7.98019911e-01 -7.00210978e-01 -4.74665741e-01\n",
      " -5.33299845e-01 -6.15881321e-01 -3.21854531e-01 -4.85273407e-01\n",
      " -9.34869946e-01 -4.96868876e-01 -5.12256788e-01 -3.22979599e-01\n",
      " -6.57913565e-01 -3.37510890e-01 -2.82605385e-01 -2.14533438e-01\n",
      " -3.25656396e-01 -7.05637459e-01 -6.76891260e-01 -6.65553764e-01\n",
      " -9.36368895e-01 -3.45044624e-01 -1.96783627e-01 -6.65823651e-01\n",
      " -5.72011835e-01 -7.51585320e-01 -8.44602130e-01 -8.35441957e-01\n",
      " -7.33346050e-01 -2.57886036e-01 -1.01192072e-01 -3.70613366e-01\n",
      " -5.05542482e-01 -6.43174768e-01 -6.71057048e-01 -5.69940925e-01\n",
      " -3.87337897e-01 -8.58897933e-02 -5.78138430e-01 -5.06169934e-02\n",
      " -1.30218462e-01 -2.56730783e-01 -5.17631412e-01 -5.65810331e-01\n",
      " -7.41288181e-01 -9.24435827e-01 -8.99764849e-01 -3.84986851e-01\n",
      " -3.92028145e-01 -7.51903789e-01 -6.57576187e-01 -3.37204047e-01\n",
      " -8.25572520e-01 -9.99171310e-01 -1.53819167e-01 -3.17831730e-01\n",
      " -3.04560778e-01 -6.50340987e-01 -3.51773141e-02 -4.77287709e-01\n",
      " -6.97317203e-01 -5.93264340e-01 -1.29222077e-01 -2.49933569e-01\n",
      " -7.65139795e-01 -9.96162973e-01 -9.96749990e-01 -3.47278891e-02\n",
      " -5.19038236e-01 -9.42266877e-01 -3.44311072e-01 -8.85344938e-01\n",
      " -3.32595446e-01 -5.80004164e-01 -5.94196221e-01 -9.15677798e-01\n",
      " -4.05136719e-01 -7.41539090e-01 -7.66380716e-01 -8.61183473e-01\n",
      " -8.36947218e-01 -2.93229965e-01 -9.78695733e-01 -3.05617200e-01\n",
      " -8.82777187e-01 -9.83995307e-03 -4.05399957e-01 -2.79485766e-01\n",
      " -4.93987041e-01 -9.98215246e-01 -4.61992609e-01 -7.07156212e-01\n",
      " -7.82267396e-01 -5.89034867e-01 -8.19188262e-01 -8.92549616e-01\n",
      " -3.88720183e-01 -6.74493776e-01 -2.11544540e-01 -9.83257892e-02\n",
      " -1.15841069e-01 -1.15083673e-01 -9.60345131e-01 -9.90101391e-01\n",
      " -5.58456486e-01 -6.84325869e-01 -1.35080915e-01 -4.95093017e-02\n",
      " -7.86404342e-01 -5.36482470e-01 -6.44533669e-01 -9.88593111e-02\n",
      " -7.93474834e-01 -8.60769286e-01 -8.71253934e-01 -3.21464717e-02\n",
      " -5.16638692e-01 -9.57817028e-01 -8.65753204e-01 -7.92996841e-01\n",
      " -1.36461393e-01 -2.52266881e-01 -9.91484360e-01 -1.41314282e-01\n",
      " -5.25215776e-03 -1.66478613e-01 -2.27626434e-01 -4.26623895e-01\n",
      " -6.11495222e-01 -3.59483744e-01 -3.18532903e-01 -5.60501162e-01\n",
      " -5.00967131e-01 -5.63295023e-01 -1.49888437e-01 -9.42934411e-01\n",
      " -9.09182090e-01 -6.61630148e-02 -3.51944536e-01 -3.62340374e-01\n",
      " -1.43617591e-01 -7.40823443e-01 -1.22211851e-01 -7.32738092e-01\n",
      " -9.35143574e-01 -9.75145857e-01 -4.61810840e-01 -8.28055335e-01\n",
      " -6.01987435e-01 -9.88477665e-01 -2.17868535e-01 -7.54459318e-01\n",
      " -1.25501239e-01 -2.63983714e-01 -5.57296394e-01 -6.45660116e-01\n",
      " -6.01295139e-01 -1.15841711e-01 -4.08155951e-02 -9.51983316e-01\n",
      " -7.71406035e-01 -2.69257996e-01 -9.94786220e-01 -3.88728819e-01\n",
      " -7.12973100e-01 -5.80980760e-01 -7.02998008e-01 -7.11802980e-01\n",
      " -1.91380736e-01 -7.68405575e-01 -7.53935457e-01 -6.89821003e-01\n",
      " -5.65689175e-01 -3.74439164e-01 -8.51726842e-01 -6.81030247e-02\n",
      " -6.67815310e-01 -1.79084784e-01 -1.47317663e-01 -2.83058415e-01\n",
      " -1.22378985e-01 -2.13217742e-01 -8.93472809e-01 -5.86647568e-01\n",
      " -3.69006658e-01 -7.35375413e-01 -8.07788283e-01 -7.89662506e-01\n",
      " -9.87344663e-01 -9.75386757e-01 -8.76213332e-01 -1.63828470e-01\n",
      " -9.16758391e-01 -8.40678481e-01 -1.33479371e-01 -9.85772169e-01\n",
      " -3.81129674e-01 -7.09585134e-02 -3.26610127e-02 -7.30842301e-01\n",
      " -6.93598996e-01 -9.25981159e-01 -4.64448108e-01 -8.04834761e-01\n",
      " -6.36165948e-01 -5.29370000e-01 -1.79168378e-01 -6.68695177e-01\n",
      " -8.20150466e-01 -6.34654178e-02 -8.28706904e-01 -2.67364589e-01\n",
      " -5.09468155e-01 -1.49679724e-01 -7.23700425e-01 -6.21000545e-01\n",
      " -4.19703621e-01 -6.27808022e-03 -1.97136983e-01 -1.89525087e-01\n",
      " -6.78832532e-01 -7.44607047e-01 -2.00702824e-02 -1.02791040e-01\n",
      " -8.19675533e-01 -1.47260048e-01 -4.10811880e-01 -9.62408760e-01\n",
      " -6.86564328e-01 -2.54317569e-01 -3.38333047e-01 -2.92461190e-01\n",
      " -7.25841361e-01 -1.75036879e-01 -8.95984011e-01 -4.93106348e-01\n",
      " -6.79158848e-01 -9.36033168e-01 -2.70307285e-01 -2.11151838e-01\n",
      " -3.86692436e-01 -3.49096228e-01 -6.62543416e-01 -3.63812166e-01\n",
      " -3.64456742e-01 -1.10551061e-01 -8.49837453e-01 -7.69692162e-01\n",
      " -7.35774726e-01 -1.80656467e-01 -1.08886331e-01 -8.36991495e-01\n",
      " -3.02562759e-01 -5.36846387e-01 -2.40457140e-01 -7.04869956e-01\n",
      " -1.44033394e-01 -1.12242269e-01 -1.10678888e-01 -5.56886832e-01\n",
      " -7.42636611e-01 -8.42135089e-01 -4.79250677e-01 -3.14963640e-01\n",
      " -4.40478754e-02 -2.47199066e-01 -3.30796205e-01 -6.79699579e-02\n",
      " -9.71217690e-01 -8.17959759e-01 -1.35556155e-01 -1.76005533e-02\n",
      " -2.18124211e-01 -3.16961592e-01 -7.33405385e-01 -7.40109949e-01\n",
      " -6.07917933e-01 -6.68331857e-01 -3.39349401e-01 -9.98156308e-01\n",
      " -7.63057798e-01 -7.05795832e-01 -5.30601100e-01 -4.30082153e-01\n",
      " -5.13100910e-02 -4.54945501e-01 -8.93837237e-01 -4.42733713e-01\n",
      " -2.16941669e-01 -2.05976607e-01 -9.97681233e-01 -4.72030112e-01\n",
      " -4.58353470e-01 -1.51931927e-02 -1.92689307e-01 -3.38183108e-02\n",
      " -5.53727237e-01 -9.16822553e-01 -5.42647594e-01 -8.73143460e-01\n",
      " -5.28927261e-01 -3.08100392e-01 -2.58699708e-02 -8.98373391e-01\n",
      " -2.28071951e-01 -6.30761239e-01 -1.91219859e-01 -8.07374045e-01\n",
      " -7.78050647e-01 -2.04879758e-01 -4.45938294e-01 -2.82586499e-01\n",
      " -1.29250197e-01 -7.95026768e-01 -8.67929657e-01 -8.62292975e-01\n",
      " -1.83161296e-01 -8.56890578e-01 -1.37317619e-01 -5.15942315e-01\n",
      " -5.05053383e-01 -2.59385733e-01 -9.20107193e-01 -9.64454644e-02\n",
      " -1.28840839e-01 -7.52393192e-01 -9.48006094e-01 -2.24645200e-01\n",
      " -3.80318976e-01 -4.75010363e-01 -4.44796623e-01 -4.37406535e-01\n",
      " -1.44475265e-01 -9.85740734e-01 -8.93568811e-01 -3.71681925e-01\n",
      " -7.89857931e-01 -7.86768244e-01 -7.77224275e-01 -4.59383823e-01\n",
      " -1.26270030e-01 -8.67161718e-01 -5.04346058e-01 -2.83957685e-01\n",
      " -3.68021708e-01 -3.96817361e-01 -4.71051259e-01 -1.55159475e-01\n",
      " -5.94737894e-01 -6.69134146e-01 -2.48529058e-01 -3.20933640e-01\n",
      " -9.06480079e-01 -2.32594522e-02 -5.38459839e-01 -3.04577544e-01\n",
      " -8.73791327e-01 -4.24407881e-01 -5.59877907e-01 -1.00941622e-01\n",
      " -8.86662957e-01 -8.56911893e-01 -7.08927203e-01 -1.24575757e-01\n",
      " -5.06617668e-01 -1.41829134e-01 -4.09456998e-01 -3.68221684e-01\n",
      " -8.36961898e-01 -4.53577034e-02 -9.40222081e-01 -6.97676101e-01\n",
      " -9.94463876e-03 -8.93813999e-01 -4.93004078e-01 -3.03564794e-01\n",
      " -9.11170965e-01 -6.61298713e-01 -6.37074945e-01 -8.85379463e-01\n",
      " -1.07627577e-01 -5.33595332e-01 -4.55975395e-01 -7.18544191e-01\n",
      " -6.61865709e-01 -4.57499437e-01 -6.52428506e-01 -8.54346187e-01\n",
      " -5.72068013e-01 -8.96772156e-01 -1.74839026e-01 -1.23340181e-01\n",
      " -4.47662924e-01 -1.38948137e-01 -8.76790783e-01 -6.49358102e-01\n",
      " -3.11685996e-01 -5.52747164e-01 -7.93849553e-01 -3.30262083e-01\n",
      " -6.94793902e-01 -8.52315414e-01 -7.77946258e-01 -2.76710730e-01\n",
      " -3.06067410e-01 -3.62399556e-01 -2.26118094e-01 -3.12492416e-01\n",
      " -9.12348264e-01 -2.72186639e-01 -6.87880841e-01 -5.66583169e-01\n",
      " -1.02798450e-01 -9.82885253e-02 -3.89313317e-01 -2.50401374e-01\n",
      " -1.41508631e-01 -1.39656527e-01 -2.27498319e-01 -6.63546159e-01\n",
      " -9.43010798e-01 -6.21110114e-01 -6.34268458e-03 -5.29849515e-01\n",
      " -5.08815501e-01 -6.10746695e-01 -9.35588264e-01 -8.13037231e-01\n",
      " -4.01500413e-01 -2.60935444e-01 -6.00221229e-01 -3.62194817e-01\n",
      " -2.14248874e-01 -7.61522886e-01 -7.52012626e-01 -3.69794392e-01\n",
      " -4.53588691e-01 -2.01286553e-01 -6.81360906e-01 -4.16805625e-02\n",
      " -5.06014565e-01 -5.07811097e-03 -3.98319148e-01 -9.52122760e-01\n",
      " -1.02284811e-01 -9.27469487e-01 -4.80100177e-01 -8.86314197e-01\n",
      " -5.05692939e-01 -5.95014418e-01 -1.85824975e-01 -4.66254476e-01\n",
      " -8.82956030e-01 -5.72538258e-01 -4.98513645e-01 -1.28254334e-01\n",
      " -1.07403909e-01 -2.86057475e-01 -9.07674766e-01 -7.21903455e-01\n",
      " -3.03648427e-01 -5.77545049e-01 -1.21599791e-01 -1.61869031e-01\n",
      " -2.05493275e-01 -4.97487568e-01 -2.92396176e-01 -3.19082578e-01\n",
      " -1.11640626e-01 -1.33131076e-01 -3.38560699e-01 -6.43009534e-01\n",
      " -6.80399138e-01 -8.24073269e-01 -4.05286097e-01 -2.71622632e-01\n",
      " -5.26737751e-01 -4.74230477e-02 -8.73741666e-01 -2.21980059e-01\n",
      " -5.87758843e-01 -5.09674034e-01 -9.13371709e-01 -7.82121632e-01\n",
      " -5.45266800e-01 -7.63887586e-01 -8.65748989e-01 -8.26263598e-01\n",
      " -2.67911627e-01 -7.26266830e-01 -8.09583040e-02 -9.85146216e-01\n",
      " -2.56089127e-02 -1.64809929e-01 -2.74455794e-01 -3.49077729e-02\n",
      " -2.71447221e-01 -9.54964840e-01 -4.66253591e-01 -8.42942654e-01\n",
      " -1.25950910e-01 -5.08171157e-01 -1.35057946e-01 -1.11678716e-01\n",
      " -2.74902048e-01 -6.00354619e-01 -3.20581272e-01 -8.67920733e-01\n",
      " -6.22654145e-01 -7.33704979e-01 -5.98508325e-02 -9.01038996e-01\n",
      " -2.48900941e-01 -2.11004609e-01 -9.73678482e-01 -6.09342806e-01\n",
      " -5.88418286e-01 -2.46310697e-01 -2.92801148e-01 -8.46108068e-01\n",
      " -3.22031567e-01 -3.89929687e-01 -6.07270865e-01 -6.41747829e-01\n",
      " -3.81521488e-01 -1.11867860e-01 -5.68121145e-01 -9.26790391e-01\n",
      " -3.99991989e-01 -5.51946321e-01 -2.73823007e-01 -3.62588735e-01\n",
      " -7.88998547e-01 -8.15281034e-01 -3.97489289e-01 -6.81550029e-01\n",
      " -8.25023542e-01 -3.45214792e-01 -3.26827935e-01 -1.10032137e-01\n",
      " -6.72221873e-01 -1.11207990e-01 -4.85526944e-01 -3.60834839e-01\n",
      " -8.70627907e-03 -6.66085654e-01 -4.93781561e-01 -4.91343717e-01\n",
      " -3.76566663e-01 -3.26703417e-01 -1.74310274e-01 -3.85874731e-01\n",
      " -2.94563048e-01 -2.13172914e-01 -6.86297450e-01 -9.84862855e-01\n",
      " -8.72874307e-01 -5.35365259e-01 -2.51796984e-01 -5.21241798e-01\n",
      " -6.88322504e-01 -2.53894500e-01 -2.40435066e-01 -8.62163753e-02\n",
      " -1.43199758e-01 -7.76774147e-01 -4.39788242e-01 -7.69186093e-01\n",
      " -2.07767258e-01 -6.69708383e-01 -8.95077623e-01 -6.36279140e-01\n",
      " -9.28267508e-01 -3.88004956e-01 -6.76538773e-01 -8.63696076e-01\n",
      " -6.36777479e-01 -3.95031390e-02 -9.17621416e-01 -8.55711614e-01\n",
      " -4.85137481e-01 -5.05726644e-01 -4.59966044e-01 -8.71378380e-01\n",
      " -8.29505341e-02 -4.77789814e-01 -1.50425696e-01 -9.89326753e-01\n",
      " -3.62671287e-01 -2.95418705e-01 -2.88597029e-01 -1.90833104e-01\n",
      " -5.01303814e-01 -1.28283743e-01 -5.69556693e-01 -2.44218262e-01\n",
      " -5.04592776e-01 -1.56431559e-01 -9.19247796e-01 -1.75858431e-01\n",
      " -9.05918171e-01 -1.73817710e-01 -4.34140631e-01 -3.49641358e-01\n",
      " -8.56498075e-02 -9.38306806e-01 -9.52891770e-01 -2.04812858e-01\n",
      " -6.66771475e-01 -8.63524001e-01 -4.28048900e-01 -8.53772418e-01\n",
      " -9.19651632e-02 -6.49610155e-01 -7.79941118e-01 -8.73702218e-01\n",
      " -5.75110296e-01 -4.39070221e-02 -5.90266788e-01 -9.84308266e-01\n",
      " -9.29713084e-01 -7.13946616e-01 -1.93238842e-01 -7.65058017e-01\n",
      " -5.33595946e-01 -8.55440104e-01 -2.60201751e-02 -6.31526782e-01\n",
      " -6.57428368e-02 -9.58935369e-01 -2.77523868e-02 -5.52044297e-01\n",
      " -4.91748404e-01 -7.02776297e-01 -4.86908320e-01 -8.63472430e-01\n",
      " -4.77240883e-01 -3.32036295e-01 -3.73407831e-01 -8.73624993e-01\n",
      " -8.29869204e-01 -6.55429397e-01 -2.67449811e-01 -9.97129002e-01\n",
      " -7.55217248e-01 -7.47212602e-02 -3.55878986e-01 -8.53150256e-01\n",
      " -5.90009140e-01 -5.41496831e-01 -4.73855298e-01 -9.71941809e-01\n",
      " -6.00172350e-01 -7.50578073e-01 -4.03267751e-01 -9.32181659e-01\n",
      " -1.23867210e-01 -1.50227287e-02 -5.04648881e-01 -1.19683825e-01\n",
      " -1.82884276e-01 -2.57320656e-01 -5.97539574e-01 -7.75699620e-01\n",
      " -2.97271410e-02 -4.82183658e-01 -8.09848034e-01 -8.31741837e-01\n",
      " -4.04808459e-01 -8.95798909e-01 -8.78340813e-01 -1.79750242e-01\n",
      " -8.03534542e-01 -6.33632028e-01 -1.45280990e-01 -1.72748301e-01\n",
      " -4.58711839e-01 -6.10252736e-01 -2.26634334e-02 -3.85670269e-01\n",
      " -7.64973256e-01 -8.61428630e-01 -3.76912584e-01 -1.85491984e-01\n",
      " -2.71270358e-01 -2.94237663e-01 -6.02198881e-01 -6.02629601e-01\n",
      " -8.80842674e-01 -1.70082933e-01 -6.53802206e-01 -8.04055309e-01\n",
      " -1.35894646e-01 -9.08049364e-02 -7.44874052e-01 -6.24513608e-01\n",
      " -4.01936843e-01 -2.58214521e-01 -8.80261524e-01 -9.07873147e-01\n",
      " -1.53252840e-01 -1.75388432e-01 -1.01026023e-02 -3.83350378e-02\n",
      " -3.57265589e-01 -1.07587994e-01 -9.16388983e-02 -5.86761849e-01\n",
      " -3.35170862e-01 -7.13463245e-01 -6.11045877e-02 -9.24726092e-01\n",
      " -4.24151355e-01 -3.45454947e-01 -8.20532690e-01 -9.55210586e-01\n",
      " -1.57068722e-01 -7.64868945e-01 -6.75555981e-01 -2.83507775e-01\n",
      " -1.33702738e-02 -3.36469682e-01 -3.52793797e-01 -3.10528493e-01\n",
      " -3.97607498e-01 -5.90274600e-01 -3.94829685e-02 -1.03347053e-01\n",
      " -8.83076279e-01 -8.83357206e-02 -8.73067129e-01 -1.14440653e-02\n",
      " -9.58451624e-01 -7.00036409e-01 -9.17225394e-01 -8.66625229e-01\n",
      " -5.27143879e-01 -7.72015732e-04 -3.51143356e-01 -1.05171720e-01\n",
      " -1.10169342e-01 -5.34932148e-01 -9.37853368e-01 -1.41728176e-01\n",
      " -7.52560034e-01 -1.85308128e-01 -3.17547846e-01 -1.05786021e-01\n",
      " -4.83941321e-01 -3.24382433e-01 -3.40343880e-01 -7.11463943e-02\n",
      " -4.56709716e-01 -6.56453137e-02 -1.36291424e-01 -4.50104738e-01\n",
      " -2.45934492e-01 -8.97392656e-01 -9.69192507e-01 -2.47896073e-01\n",
      " -5.68533668e-01 -4.86964461e-01 -8.00318297e-01 -5.27482204e-02\n",
      " -1.28558278e-01 -2.38929996e-01 -2.77317343e-01 -4.99822068e-01\n",
      " -6.64836601e-01 -2.93121925e-01 -6.41386194e-01 -8.81857436e-01\n",
      " -4.27242727e-02 -7.88725436e-01 -2.06128326e-01 -9.04953249e-01\n",
      " -5.68104260e-02 -3.54145177e-01 -6.09799928e-01 -1.86624032e-02\n",
      " -9.93589695e-01 -6.91763892e-01 -5.25763460e-02 -4.23367747e-01\n",
      " -8.87818642e-01 -1.62130680e-01 -4.59453463e-01 -2.58128457e-01\n",
      " -4.67774665e-02 -7.81380097e-01 -6.03549725e-01 -2.51698844e-01\n",
      " -2.48995408e-01 -4.82420354e-01 -4.66475501e-01 -3.16441250e-01\n",
      " -4.88282775e-01 -4.40692086e-01 -6.66634339e-01 -3.38033499e-02\n",
      " -9.73897838e-02 -8.98570559e-01 -3.52642930e-01 -1.88851207e-01\n",
      " -3.50963698e-01 -9.45113166e-01 -4.03880092e-02 -9.48656827e-01\n",
      " -3.41201756e-01 -4.46203594e-01 -6.86271913e-01 -7.89559579e-01\n",
      " -2.88492950e-01 -7.03700587e-02 -6.07904522e-02 -7.34148456e-01\n",
      " -9.80883032e-01 -4.64164389e-01 -1.36495818e-01 -9.87945164e-01\n",
      " -1.37384228e-01 -6.42479760e-01 -6.26907534e-01 -9.75912934e-01\n",
      " -4.30686876e-02 -7.41080768e-01 -2.91928805e-01 -2.46066119e-01\n",
      " -4.26342595e-01 -4.76224141e-01 -1.65097779e-01 -1.60329429e-01\n",
      " -9.22698012e-01 -5.84489340e-01 -8.91026562e-01 -1.28803037e-01]\n"
     ]
    }
   ],
   "source": [
    "# first argument min, second argument max and third argument is size\n",
    "s = np.random.uniform(-1, 0, 1000)\n",
    "print(np.all(s <= 0))\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 475,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "count, bins, ignored = plt.hist(s, 10, density=True)\n",
    "plt.plot(bins, np.ones_like(bins), linewidth=2, color='r')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 476,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([68.80039957, 57.06427274, 90.00446115, ..., 84.40814004,\n",
       "       57.12822484, 87.91751196])"
      ]
     },
     "execution_count": 476,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# np.random.normal(mu, sigma, size)\n",
    "# mu - mean, sigma - sigma -standard deviation, size - number of obsevations\n",
    "normal_array = np.random.normal(79, 15, 10000)\n",
    "normal_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 480,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.hist(normal_array,bins=50, color='lightgreen', density=True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Maintaining the same generated data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes we would not like to generate a new set of data instead we would like to keep what we created. To keep the created data we can use the *seed* method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5 0 3 3 7 9 3 5 2 4 7 6 8 8 1 6 7 7 8 1 5]\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(0)\n",
    "integers = np.random.randint(0, 10, 21)\n",
    "print(integers)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-0.94154201  1.94603199 -2.55629824  2.87474136 -0.15540913  2.17926033\n",
      "  0.19308534  2.83733422  2.33654627  1.89437189  2.17097407  4.7644489\n",
      " -0.81204747  0.53289068 -2.71142745 -0.22820506 -1.68846173  1.41128162\n",
      " -0.79757235 -1.65439307 -0.8314894  -1.04902439  1.62620254 -0.45850126\n",
      "  4.32343475 -1.91386286  0.13462166  0.41299767 -0.91376265 -2.11995153]\n"
     ]
    }
   ],
   "source": [
    "data = np.random.normal(0, 2, 30)\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 2, 6, 1, 3, 9, 6, 1, 0, 1, 9, 0, 0, 9, 3, 4, 0, 0, 4, 1, 7])"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "generator = np.random.RandomState(seed=123)  # RandomState is a class, so we give the seed to its constructor\n",
    "generator.randint(0, 10, 21)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matrix in NumPy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "four_by_four_matrix = np.matrix(np.ones((4,4), dtype=float))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[1., 1., 1., 1.],\n",
       "        [1., 1., 1., 1.],\n",
       "        [1., 1., 1., 1.],\n",
       "        [1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "four_by_four_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[1., 1., 1., 1.],\n",
       "        [1., 1., 1., 1.],\n",
       "        [2., 2., 2., 2.],\n",
       "        [1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.asarray(four_by_four_matrix)[2] = 2\n",
    "four_by_four_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2. 2. 2. 2.]\n",
      " [2. 2. 2. 2.]\n",
      " [4. 4. 4. 4.]\n",
      " [2. 2. 2. 2.]]\n",
      "[[4. 4. 4. 4.]\n",
      " [4. 4. 4. 4.]\n",
      " [8. 8. 8. 8.]\n",
      " [4. 4. 4. 4.]]\n"
     ]
    }
   ],
   "source": [
    "A = four_by_four_matrix * 2\n",
    "B = four_by_four_matrix * 4\n",
    "print(A)\n",
    "print(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 6.  6.  6.  6.]\n",
      " [ 6.  6.  6.  6.]\n",
      " [12. 12. 12. 12.]\n",
      " [ 6.  6.  6.  6.]]\n"
     ]
    }
   ],
   "source": [
    "A_plus_B = A + B\n",
    "print(A_plus_B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-2. -2. -2. -2.]\n",
      " [-2. -2. -2. -2.]\n",
      " [-4. -4. -4. -4.]\n",
      " [-2. -2. -2. -2.]]\n"
     ]
    }
   ],
   "source": [
    "A_minus_B = A - B\n",
    "print(A_minus_B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-2. -2. -2. -2.]\n",
      " [-2. -2. -2. -2.]\n",
      " [-4. -4. -4. -4.]\n",
      " [-2. -2. -2. -2.]]\n"
     ]
    }
   ],
   "source": [
    "A_times_B = A - B\n",
    "print(A_times_B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[-2., -2., -4., -2.],\n",
       "        [-2., -2., -4., -2.],\n",
       "        [-2., -2., -4., -2.],\n",
       "        [-2., -2., -4., -2.]])"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.transpose(A_times_B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numpy numpy.arange()\n",
    "\n",
    "#### What is arrange?\n",
    "Sometimes, you want to create values that are evenly spaced within a defined interval. For instance, you want to create values from 1 to 10; you can use numpy.arange() function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 11, 2)"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# creating list using range(starting, stop, step)\n",
    "lst = range(0, 11, 2)\n",
    "lst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "2\n",
      "4\n",
      "6\n",
      "8\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "for l in lst:\n",
    "    print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,\n",
       "       17, 18, 19])"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Similar to range arange numpy.arange(start, stop, step)\n",
    "whole_numbers = np.arange(0, 20, 1)\n",
    "whole_numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,\n",
       "       18, 19])"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "natural_numbers = np.arange(1, 20, 1)\n",
    "natural_numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  3,  5,  7,  9, 11, 13, 15, 17, 19])"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "odd_numbers = np.arange(1, 20, 2)\n",
    "odd_numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2,  4,  6,  8, 10, 12, 14, 16, 18])"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "even_numbers = np.arange(2, 20, 2)\n",
    "even_numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating sequence of numbers using linspace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.        , 1.44444444, 1.88888889, 2.33333333, 2.77777778,\n",
       "       3.22222222, 3.66666667, 4.11111111, 4.55555556, 5.        ])"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# numpy.linspace(start, end, size, endpoint) the end is included by default\n",
    "# numpy.logspace() in Python with Example\n",
    "# For instance, it can be used to create 10 values from 1 to 5 evenly spaced.\n",
    "np.linspace(1.0, 5.0, num=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1. , 1.8, 2.6, 3.4, 4.2])"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# not to include the last value in the interval\n",
    "np.linspace(1.0, 5.0, num=5, endpoint=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.linspace(-10, 10, num=50)\n",
    "y = 2 * x  + 2\n",
    "plt.scatter(x, y)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.linspace(-10, 10, num=50)\n",
    "y = x ** 2\n",
    "plt.scatter(x, y)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.linspace(-10, 10, num=50)\n",
    "y = x ** 2 - 25\n",
    "plt.scatter(x, y)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.linspace(-10, 10, num=50)\n",
    "y = -x ** 2 + 25\n",
    "plt.scatter(x, y)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [],
   "source": [
    "# LogSpace\n",
    "# LogSpace returns even spaced numbers on a log scale. Logspace has the same parameters as np.linspace.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  100.        ,   464.15888336,  2154.43469003, 10000.        ])"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Syntax:\n",
    "\n",
    "# numpy.logspace(start, stop, num, endpoint)\n",
    "\n",
    "np.logspace(2, 4.0, num=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [],
   "source": [
    "# to check the size of an array\n",
    "x = np.array([1,2,3], dtype=np.complex128)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.+0.j, 2.+0.j, 3.+0.j])"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.itemsize"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NumPy Statistical Functions with Example\n",
    "NumPy has quite useful statistical functions for finding minimum, maximum, mean, median, percentile,standard deviation and variance, etc from the given elements in the array. The functions are explained as follows − Statistical function Numpy is equipped with the robust statistical function as listed below\n",
    "\n",
    "Numpy Functions\n",
    "- Min np.min()\n",
    "- Max np.max()\n",
    "- Percentile(25, 50, 75) using np.percentile(arr, 25)\n",
    "- Mean np.mean()\n",
    "- Median np.median()\n",
    "- Varience np.var(data)\n",
    "- Percentile\n",
    "- Standard deviation np.std()\n",
    "\n",
    "stats.mode(data)  \n",
    "\n",
    "## Using Numpy to calculate statistical measures\n",
    "It is easy to calcualte the statistical measures such as mean, median, standard deviation, varience etc \n",
    "# A set of age of students in python class\n",
    "\n",
    "data = [19, 20, 22, 33, 45, 60, 25, 24, 40, 20, 15, 22, 24, 26, 26, 28, 27, 24, 35, 40, 40, 24, 38, 40, 28, 23] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7506861412184562"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.random()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.60783067, 0.32504723, 0.03842543])"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.random(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[8, 9, 9, 9],\n",
       "       [8, 9, 9, 9],\n",
       "       [5, 9, 8, 7]])"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.randint(5, 10, (3, 4)) # does not inlcued the last value [5, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1.79093312,  0.773805  , -1.02161028, -2.36126437, -0.05636446])"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.normal(0, 2, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.85666374,  0.13303444,  0.6049438 , -1.26864419],\n",
       "       [-0.72548233, -1.3449209 , -0.71910632, -1.62629256],\n",
       "       [-3.4525652 ,  0.35485228, -0.80356187, -3.26039669]])"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.normal(0, 2, (3, 4)) # mean = 0, stdev = 2, 3 x 4 array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "min:  1\n",
      "max:  55\n",
      "25th percentile 3.0\n",
      "50th percentile 7.0\n",
      "75th percentile 9.0\n",
      "mean:  14.78\n",
      "mode:  ModeResult(mode=array([[1, 2, 3]]), count=array([[1, 1, 1]]))\n",
      "median:  7.0\n",
      "sd:  18.91\n"
     ]
    }
   ],
   "source": [
    "from scipy import stats\n",
    "np_normal_dis = np.random.normal(5, 0.5, 100)\n",
    "np_normal_dis\n",
    "## min, max, mean, median, sd\n",
    "print('min: ', two_dim_arr.min())\n",
    "print('max: ', two_dim_arr.max())\n",
    "print('25th percentile', np.percentile(two_dim_arr, 25))\n",
    "print('50th percentile', np.percentile(two_dim_arr, 50))\n",
    "print('75th percentile', np.percentile(two_dim_arr, 75))\n",
    "print('mean: ',round(two_dim_arr.mean(), 2))\n",
    "print('mode: ', stats.mode(two_dim_arr)) # numpy has no mode method\n",
    "print('median: ', np.median(two_dim_arr))\n",
    "print('sd: ', round(two_dim_arr.std(), 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3]\n",
      " [ 4 55 44]\n",
      " [ 7  8  9]]\n",
      "Column with minimum:  [1 2 3]\n",
      "Column with maximum:  [ 7 55 44]\n",
      "=== Row ==\n",
      "Row with minimum:  [1 4 7]\n",
      "Row with maximum:  [ 3 55  9]\n"
     ]
    }
   ],
   "source": [
    "print(two_dim_arr)\n",
    "print('Column with minimum: ', np.amin(two_dim_arr, axis=0))\n",
    "print('Column with maximum: ', np.amax(two_dim_arr, axis=0))\n",
    "print('=== Row ==')\n",
    "print('Row with minimum: ', np.amin(two_dim_arr, axis=1))\n",
    "print('Row with maximum: ', np.amax(two_dim_arr, axis=1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to create repeating sequences?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tile:    [1 2 3 1 2 3 1 2 3]\n",
      "Repeat:  [1 1 1 2 2 2 3 3 3]\n"
     ]
    }
   ],
   "source": [
    "a = [1,2,3]\n",
    "\n",
    "# Repeat whole of 'a' two times\n",
    "print('Tile:   ', np.tile(a, 3))\n",
    "\n",
    "# Repeat each element of 'a' two times\n",
    "print('Repeat: ', np.repeat(a, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "min:  3.4769284726000365\n",
      "max:  6.58548738664509\n",
      "mean:  4.9757236255377535\n",
      "median:  4.974828091188378\n",
      "mode:  ModeResult(mode=array([3.47692847]), count=array([1]))\n",
      "sd:  0.4859817987330746\n"
     ]
    }
   ],
   "source": [
    "from scipy import stats\n",
    "np_normal_dis = np.random.normal(5, 0.5, 1000) # mean, standard deviation, number of samples\n",
    "np_normal_dis\n",
    "## min, max, mean, median, sd\n",
    "print('min: ', np.min(np_normal_dis))\n",
    "print('max: ', np.max(np_normal_dis))\n",
    "print('mean: ', np.mean(np_normal_dis))\n",
    "print('median: ', np.median(np_normal_dis))\n",
    "print('mode: ', stats.mode(np_normal_dis))\n",
    "print('sd: ', np.std(np_normal_dis))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.hist(np_normal_dis, color=\"grey\", bins=30)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x  = np.random.normal(28, 15, 100000)\n",
    "ax = sns.histplot(x, kde=True, linewidth=0)\n",
    "ax.set(xlabel='x', ylabel='y', title='X vs Y')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Linear Algebra"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [],
   "source": [
    "# numpy.dot(): Dot Product in Python using Numpy\n",
    "# Dot Product\n",
    "# Numpy is powerful library for matrices computation. For instance, you can compute the dot product with np.dot\n",
    "\n",
    "# Syntax\n",
    "\n",
    "# numpy.dot(x, y, out=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dot Product"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## Linear algebra\n",
    "### Dot product: product of two arrays\n",
    "f = np.array([1,2,3])\n",
    "g = np.array([4,5,3])\n",
    "### 1*4+2*5 + 3*3\n",
    "np.dot(f, g)  # 23"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### NumPy Matrix Multiplication with np.matmul()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n",
      "[[5 6]\n",
      " [7 8]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[19, 22],\n",
       "       [43, 50]])"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### Matmul: matruc product of two arrays\n",
    "h = np.array([[1,2],[3,4]])\n",
    "i = np.array([[5,6],[7,8]])\n",
    "### 1*5+2*7 = 19\n",
    "print(h)\n",
    "print(i)\n",
    "np.matmul(h, i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Determinant 2*2 matrix\n",
    "### 5*8-7*6np.linalg.det(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.999999999999999"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.det(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [],
   "source": [
    "Z = np.zeros((8,8))\n",
    "Z[1::2,::2] = 1\n",
    "Z[::2,1::2] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 1., 0., 1., 0., 1., 0., 1.],\n",
       "       [1., 0., 1., 0., 1., 0., 1., 0.],\n",
       "       [0., 1., 0., 1., 0., 1., 0., 1.],\n",
       "       [1., 0., 1., 0., 1., 0., 1., 0.],\n",
       "       [0., 1., 0., 1., 0., 1., 0., 1.],\n",
       "       [1., 0., 1., 0., 1., 0., 1., 0.],\n",
       "       [0., 1., 0., 1., 0., 1., 0., 1.],\n",
       "       [1., 0., 1., 0., 1., 0., 1., 0.]])"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Z"
   ]
  },
  {
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}