03 - Numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 03. NumPy\n",
    "\n",
    "- N-dimensional array\n",
    "- Random number generation (random sampling)\n",
    "- Vectorized operations\n",
    "- Linear algebra\n",
    "- Probability distributions\n",
    "- Statistical analysis\n",
    "- np.NaN (similar to the Python None, represents a missing/null/non-existent value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1. Random number generation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 4, 7, 7, 4, 0, 7, 2, 2, 3, 1, 6, 1, 5, 1, 8, 7, 4, 1, 5, 5, 8, 3, 1, 8, 8, 0, 7, 5, 0, 2, 1, 2, 7, 6, 5, 5, 1, 5, 5, 7, 1, 6, 1, 0, 4, 0, 2, 4, 8, 8, 1, 7, 3, 6, 0, 8, 1, 9, 9, 9, 0, 5, 9, 9, 5, 8, 7, 8, 8, 1, 7, 9, 2, 5, 7, 4, 7, 4, 7, 8, 0, 9, 3, 4, 2, 8, 7, 0, 0, 2, 7, 4, 5, 1, 0, 1, 5, 6, 8]\n"
     ]
    }
   ],
   "source": [
    "# generate and print 100 random number between 0 and 9 using Python standard library random\n",
    "import random\n",
    "x = []\n",
    "for i in range(100):\n",
    "    x.append(random.randint(0,9))     # Python random standard library generate one random number at a time\n",
    "print(x)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "y = np.array(x)\n",
    "type(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3 4 7 7 4 0 7 2 2 3 1 6 1 5 1 8 7 4 1 5 5 8 3 1 8 8 0 7 5 0 2 1 2 7 6 5 5\n",
      " 1 5 5 7 1 6 1 0 4 0 2 4 8 8 1 7 3 6 0 8 1 9 9 9 0 5 9 9 5 8 7 8 8 1 7 9 2\n",
      " 5 7 4 7 4 7 8 0 9 3 4 2 8 7 0 0 2 7 4 5 1 0 1 5 6 8]\n"
     ]
    }
   ],
   "source": [
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[9 0 4 2 6 2 3 3 9 4 9 1 8 1 2 3 8 6 3 0 1 3 4 4 4 8 5 4 4 3 8 4 9 1 3 1 4\n",
      " 9 8 9 9 3 3 6 0 6 2 6 8 4 1 5 7 8 6 8 9 2 4 6 3 0 0 9 9 9 7 6 9 8 4 0 7 0\n",
      " 4 6 0 7 6 1 0 9 4 7 4 5 5 4 5 4 0 4 5 2 1 3 5 1 1 5]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# generate and print 100 random number between 0 and 9 using NumPy\n",
    "import numpy as np\n",
    "z = np.random.randint(0,10,100)   # Numpy can generate many random number efficiently\n",
    "print(z)\n",
    "type(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2. Creation of a NumPy Array\n",
    "- create an array from a list\n",
    "- create an array of randomly generated numbersnp.random.randint()\n",
    "- create an array using arange(start, stop, step, dtype)\n",
    "- create an array using np.linspace(start, stop, number of values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 8 3 4 7 8 7 8 5 0 8 0 7 8 3 8 6 0 0 0 1 0 0 5 0 5 6 0 5 5 4 7 1 4 4 4 4\n",
      " 3 6 4 0 8 9 7 1 6 7 9 4 1 0 1 4 6 7 8 9 5 6 1 8 3 8 5 5 6 9 3 1 6 9 1 2 4\n",
      " 1 6 0 5 0 4 8 7 1 1 9 3 2 3 4 1 5 6 5 2 0 7 6 7 3 9]\n"
     ]
    }
   ],
   "source": [
    "# create an array from a list - method #1\n",
    "z = np.array(x)\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 8 3 4 7 8 7 8 5 0 8 0 7 8 3 8 6 0 0 0 1 0 0 5 0 5 6 0 5 5 4 7 1 4 4 4 4\n",
      " 3 6 4 0 8 9 7 1 6 7 9 4 1 0 1 4 6 7 8 9 5 6 1 8 3 8 5 5 6 9 3 1 6 9 1 2 4\n",
      " 1 6 0 5 0 4 8 7 1 1 9 3 2 3 4 1 5 6 5 2 0 7 6 7 3 9]\n"
     ]
    }
   ],
   "source": [
    "# convert a list to an array - method #2\n",
    "z = np.asarray(x)\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5 1 9 4 8 6 3 0 6 1 8 9 8 9 8 8 5 5 0 3 8 6 4 6 9 6 8 3 4 7 5 0 2 1 3 0 9\n",
      " 7 4 8 3 2 8 7 8 9 9 5 6 1 0 4 2 3 4 3 7 2 2 3 5 9 3 7 9 2 0 3 3 3 0 5 6 7\n",
      " 0 7 1 1 6 9 9 8 8 1 5 1 8 4 1 4 2 9 5 7 3 2 6 6 7 6]\n"
     ]
    }
   ],
   "source": [
    "# create an array of randomly generated numbersnp.random.randint() #3\n",
    "z = np.random.randint(0,10,100)  \n",
    "print(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10. 20. 30. 40. 50. 60. 70. 80. 90.]\n"
     ]
    }
   ],
   "source": [
    "# create an array using arange(start, stop, step, dtype) #4\n",
    "z = np.arange(10, 100, 10, np.float64)\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10.  12.5 15.  17.5 20. ]\n"
     ]
    }
   ],
   "source": [
    "# create an array using np.linspace(start, stop, number of values) #5\n",
    "z = np.linspace(10, 20, 5)\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3. Operations\n",
    "- shape: the structure of the array\n",
    "- reshape(): change the structure of the array\n",
    "- ndim: number of dimensions\n",
    "- size: number of elements\n",
    "- itemsize: the size in bytes of the element\n",
    "- dtype: the data type of the element\n",
    "- \\[row,colum\\] or \\[row\\]\\[column\\]: retrieve an item from an array based on its position\n",
    "- sum(), mean(), median(), min(), max(), var(), std()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5 0 4 7 4 5 7 2 7 4 9 3 2 3 5 8 7 0 8 7 7 7 9 6]\n"
     ]
    }
   ],
   "source": [
    "a = np.random.randint(0,10,24)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(24,)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "126"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.sum()    # compare with Python sum(list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(126, 5.25, 0, 9, 6.520833333333333, 2.553592241007427, 5.5)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(a), np.mean(a), np.min(a), np.max(a), np.var(a), np.std(a), np.median(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[5 0 4 7 4 5]\n",
      " [7 2 7 4 9 3]\n",
      " [2 3 5 8 7 0]\n",
      " [8 7 7 7 9 6]]\n"
     ]
    }
   ],
   "source": [
    "b = a.reshape(4,6)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(4, 6)\n"
     ]
    }
   ],
   "source": [
    "print(b.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.itemsize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int32')"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# access an element in an array - method #1\n",
    "b[2,3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# access an element in an array - method #2\n",
    "b[0][0]"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}