NumPy 2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# More about NumPy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 8 94  8 56  1  3  4  5  7]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([8,94,8,56,1,3,4,5,7])\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "index_gt10 = np.where(arr>10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([1, 3], dtype=int64),)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index_gt10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([94, 56])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[index_gt10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([94, 56])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[arr>10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False,  True, False,  True, False, False, False, False, False])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr>10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['lt10', 'gt10', 'lt10', 'gt10', 'lt10', 'lt10', 'lt10', 'lt10',\n",
       "       'lt10'], dtype='<U4')"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.where(arr>10, 'gt10', 'lt10')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 8, 94,  8, 56,  1,  3,  4,  5,  7])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "94"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.argmax()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[arr.argmin()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.argmin()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.min()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# read and write csv file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "#np.genfromtxt(), np.loadtxt()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = np.genfromtxt('https://raw.githubusercontent.com/selva86/datasets/master/Auto.csv',delimiter=',', \n",
    "                     skip_header = 1, filling_values= -1000, dtype = 'float')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[   18.     8.   307. ...    70.     1. -1000.]\n",
      " [   15.     8.   350. ...    70.     1. -1000.]\n",
      " [   18.     8.   318. ...    70.     1. -1000.]\n",
      " ...\n",
      " [   32.     4.   135. ...    82.     1. -1000.]\n",
      " [   28.     4.   120. ...    82.     1. -1000.]\n",
      " [   31.     4.   119. ...    82.     1. -1000.]]\n"
     ]
    }
   ],
   "source": [
    "print(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(392, 9)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[   18.,     8.,   307., ...,    70.,     1., -1000.],\n",
       "       [   15.,     8.,   350., ...,    70.,     1., -1000.],\n",
       "       [   18.,     8.,   318., ...,    70.,     1., -1000.],\n",
       "       ...,\n",
       "       [   32.,     4.,   135., ...,    82.,     1., -1000.],\n",
       "       [   28.,     4.,   120., ...,    82.,     1., -1000.],\n",
       "       [   31.,     4.,   119., ...,    82.,     1., -1000.]])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.800e+01,  8.000e+00,  3.070e+02,  1.300e+02,  3.504e+03,\n",
       "         1.200e+01,  7.000e+01,  1.000e+00, -1.000e+03],\n",
       "       [ 1.500e+01,  8.000e+00,  3.500e+02,  1.650e+02,  3.693e+03,\n",
       "         1.150e+01,  7.000e+01,  1.000e+00, -1.000e+03],\n",
       "       [ 1.800e+01,  8.000e+00,  3.180e+02,  1.500e+02,  3.436e+03,\n",
       "         1.100e+01,  7.000e+01,  1.000e+00, -1.000e+03]])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[   18. ,     8. ,   307. ,   130. ,  3504. ,    12. ,    70. ,\n",
       "            1. , -1000. ],\n",
       "       [   15. ,     8. ,   350. ,   165. ,  3693. ,    11.5,    70. ,\n",
       "            1. , -1000. ],\n",
       "       [   18. ,     8. ,   318. ,   150. ,  3436. ,    11. ,    70. ,\n",
       "            1. , -1000. ]])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.set_printoptions(suppress= True)\n",
    "data[:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "data2 = np.genfromtxt('https://raw.githubusercontent.com/selva86/datasets/master/Auto.csv',delimiter=',', \n",
    "                     skip_header = 1, dtype = object)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[b'18', b'8', b'307', b'130', b'3504', b'12', b'70', b'1',\n",
       "        b'\"chevrolet chevelle malibu\"'],\n",
       "       [b'15', b'8', b'350', b'165', b'3693', b'11.5', b'70', b'1',\n",
       "        b'\"buick skylark 320\"'],\n",
       "       [b'18', b'8', b'318', b'150', b'3436', b'11', b'70', b'1',\n",
       "        b'\"plymouth satellite\"']], dtype=object)"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data2[:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.savetxt('data.csv',data, delimiter=',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.save('data.npy', data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.savez('data2.npz', data, data2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = np.load('data.npy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[   18.,     8.,   307., ...,    70.,     1., -1000.],\n",
       "       [   15.,     8.,   350., ...,    70.,     1., -1000.],\n",
       "       [   18.,     8.,   318., ...,    70.,     1., -1000.],\n",
       "       ...,\n",
       "       [   32.,     4.,   135., ...,    82.,     1., -1000.],\n",
       "       [   28.,     4.,   120., ...,    82.,     1., -1000.],\n",
       "       [   31.,     4.,   119., ...,    82.,     1., -1000.]])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "d2 = np.load('data2.npz')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['arr_0', 'arr_1']"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d2.files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[b'18', b'8', b'307', ..., b'70', b'1',\n",
       "        b'\"chevrolet chevelle malibu\"'],\n",
       "       [b'15', b'8', b'350', ..., b'70', b'1', b'\"buick skylark 320\"'],\n",
       "       [b'18', b'8', b'318', ..., b'70', b'1', b'\"plymouth satellite\"'],\n",
       "       ...,\n",
       "       [b'32', b'4', b'135', ..., b'82', b'1', b'\"dodge rampage\"'],\n",
       "       [b'28', b'4', b'120', ..., b'82', b'1', b'\"ford ranger\"'],\n",
       "       [b'31', b'4', b'119', ..., b'82', b'1', b'\"chevy s-10\"']],\n",
       "      dtype=object)"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d2['arr_1']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# concat with row and col wise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr1 = np.zeros([4,4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr2 = np.ones([4,4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "#np.concatenate, np.vstack, np.r_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.],\n",
       "       [1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.concatenate([arr1, arr2], axis = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.],\n",
       "       [1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.vstack([arr1, arr2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.],\n",
       "       [1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.r_[arr1, arr2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0., 1., 1., 1., 1.],\n",
       "       [0., 0., 0., 0., 1., 1., 1., 1.],\n",
       "       [0., 0., 0., 0., 1., 1., 1., 1.],\n",
       "       [0., 0., 0., 0., 1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.concatenate([arr1, arr2], axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0., 1., 1., 1., 1.],\n",
       "       [0., 0., 0., 0., 1., 1., 1., 1.],\n",
       "       [0., 0., 0., 0., 1., 1., 1., 1.],\n",
       "       [0., 0., 0., 0., 1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.hstack([arr1, arr2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0., 1., 1., 1., 1.],\n",
       "       [0., 0., 0., 0., 1., 1., 1., 1.],\n",
       "       [0., 0., 0., 0., 1., 1., 1., 1.],\n",
       "       [0., 0., 0., 0., 1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.c_[arr1, arr2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# sort a numpy array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.random.randint(1,10, [10,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[6, 5, 9, 9, 5],\n",
       "       [3, 9, 5, 9, 9],\n",
       "       [1, 8, 9, 7, 7],\n",
       "       [7, 1, 7, 1, 6],\n",
       "       [4, 6, 2, 4, 6],\n",
       "       [1, 4, 3, 2, 4],\n",
       "       [1, 8, 5, 7, 5],\n",
       "       [8, 5, 1, 3, 4],\n",
       "       [8, 1, 8, 1, 3],\n",
       "       [1, 8, 2, 6, 9]])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 1, 1, 1, 3],\n",
       "       [1, 1, 2, 1, 4],\n",
       "       [1, 4, 2, 2, 4],\n",
       "       [1, 5, 3, 3, 5],\n",
       "       [3, 5, 5, 4, 5],\n",
       "       [4, 6, 5, 6, 6],\n",
       "       [6, 8, 7, 7, 6],\n",
       "       [7, 8, 8, 7, 7],\n",
       "       [8, 8, 9, 9, 9],\n",
       "       [8, 9, 9, 9, 9]])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sort(arr, axis = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[5, 5, 6, 9, 9],\n",
       "       [3, 5, 9, 9, 9],\n",
       "       [1, 7, 7, 8, 9],\n",
       "       [1, 1, 6, 7, 7],\n",
       "       [2, 4, 4, 6, 6],\n",
       "       [1, 2, 3, 4, 4],\n",
       "       [1, 5, 5, 7, 8],\n",
       "       [1, 3, 4, 5, 8],\n",
       "       [1, 1, 3, 8, 8],\n",
       "       [1, 2, 6, 8, 9]])"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sort(arr, axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorted_index = arr[:, 0].argsort()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 8, 9, 7, 7],\n",
       "       [1, 4, 3, 2, 4],\n",
       "       [1, 8, 5, 7, 5],\n",
       "       [1, 8, 2, 6, 9],\n",
       "       [3, 9, 5, 9, 9],\n",
       "       [4, 6, 2, 4, 6],\n",
       "       [6, 5, 9, 9, 5],\n",
       "       [7, 1, 7, 1, 6],\n",
       "       [8, 5, 1, 3, 4],\n",
       "       [8, 1, 8, 1, 3]])"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[sorted_index]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[6, 5, 9, 9, 5],\n",
       "       [3, 9, 5, 9, 9],\n",
       "       [1, 8, 9, 7, 7],\n",
       "       [7, 1, 7, 1, 6],\n",
       "       [4, 6, 2, 4, 6],\n",
       "       [1, 4, 3, 2, 4],\n",
       "       [1, 8, 5, 7, 5],\n",
       "       [8, 5, 1, 3, 4],\n",
       "       [8, 1, 8, 1, 3],\n",
       "       [1, 8, 2, 6, 9]])"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# working with dates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = np.datetime64('2019-06-02 23:10:00')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.datetime64('2019-06-02T23:10:00')"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.datetime64('2019-06-02T23:26:40')"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d + 1000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "oneday = np.timedelta64(1, 'D')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.timedelta64(1,'D')"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "oneday"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.datetime64('2019-06-02T23:10:01')"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.datetime64('2019-06-03T23:10:00')"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d + oneday"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "oneminute = np.timedelta64(1, 'm')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.datetime64('2019-06-02T23:11:00')"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d + oneminute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['2019-06-02', '2019-06-04', '2019-06-06', '2019-06-08',\n",
       "       '2019-06-10', '2019-06-12', '2019-06-14', '2019-06-16',\n",
       "       '2019-06-18', '2019-06-20', '2019-06-22', '2019-06-24',\n",
       "       '2019-06-26', '2019-06-28', '2019-06-30', '2019-07-02',\n",
       "       '2019-07-04', '2019-07-06', '2019-07-08', '2019-07-10',\n",
       "       '2019-07-12', '2019-07-14', '2019-07-16', '2019-07-18',\n",
       "       '2019-07-20', '2019-07-22', '2019-07-24', '2019-07-26',\n",
       "       '2019-07-28', '2019-07-30', '2019-08-01', '2019-08-03',\n",
       "       '2019-08-05', '2019-08-07', '2019-08-09', '2019-08-11',\n",
       "       '2019-08-13', '2019-08-15', '2019-08-17', '2019-08-19',\n",
       "       '2019-08-21', '2019-08-23', '2019-08-25', '2019-08-27',\n",
       "       '2019-08-29', '2019-08-31', '2019-09-02', '2019-09-04',\n",
       "       '2019-09-06', '2019-09-08', '2019-09-10', '2019-09-12',\n",
       "       '2019-09-14', '2019-09-16', '2019-09-18', '2019-09-20',\n",
       "       '2019-09-22', '2019-09-24', '2019-09-26', '2019-09-28',\n",
       "       '2019-09-30', '2019-10-02', '2019-10-04', '2019-10-06',\n",
       "       '2019-10-08', '2019-10-10', '2019-10-12', '2019-10-14',\n",
       "       '2019-10-16', '2019-10-18', '2019-10-20', '2019-10-22',\n",
       "       '2019-10-24', '2019-10-26', '2019-10-28', '2019-10-30',\n",
       "       '2019-11-01', '2019-11-03', '2019-11-05', '2019-11-07',\n",
       "       '2019-11-09', '2019-11-11', '2019-11-13', '2019-11-15',\n",
       "       '2019-11-17', '2019-11-19', '2019-11-21', '2019-11-23',\n",
       "       '2019-11-25', '2019-11-27', '2019-11-29', '2019-12-01',\n",
       "       '2019-12-03', '2019-12-05', '2019-12-07', '2019-12-09',\n",
       "       '2019-12-11', '2019-12-13', '2019-12-15', '2019-12-17',\n",
       "       '2019-12-19', '2019-12-21', '2019-12-23', '2019-12-25',\n",
       "       '2019-12-27', '2019-12-29', '2019-12-31', '2020-01-02',\n",
       "       '2020-01-04', '2020-01-06', '2020-01-08', '2020-01-10',\n",
       "       '2020-01-12', '2020-01-14', '2020-01-16', '2020-01-18',\n",
       "       '2020-01-20', '2020-01-22', '2020-01-24', '2020-01-26',\n",
       "       '2020-01-28', '2020-01-30', '2020-02-01', '2020-02-03',\n",
       "       '2020-02-05', '2020-02-07', '2020-02-09', '2020-02-11',\n",
       "       '2020-02-13', '2020-02-15', '2020-02-17', '2020-02-19',\n",
       "       '2020-02-21', '2020-02-23', '2020-02-25', '2020-02-27',\n",
       "       '2020-02-29', '2020-03-02', '2020-03-04', '2020-03-06',\n",
       "       '2020-03-08', '2020-03-10', '2020-03-12', '2020-03-14',\n",
       "       '2020-03-16', '2020-03-18', '2020-03-20', '2020-03-22',\n",
       "       '2020-03-24', '2020-03-26', '2020-03-28', '2020-03-30',\n",
       "       '2020-04-01', '2020-04-03', '2020-04-05', '2020-04-07',\n",
       "       '2020-04-09', '2020-04-11', '2020-04-13', '2020-04-15',\n",
       "       '2020-04-17', '2020-04-19', '2020-04-21', '2020-04-23',\n",
       "       '2020-04-25', '2020-04-27', '2020-04-29', '2020-05-01',\n",
       "       '2020-05-03', '2020-05-05', '2020-05-07', '2020-05-09',\n",
       "       '2020-05-11', '2020-05-13', '2020-05-15', '2020-05-17',\n",
       "       '2020-05-19', '2020-05-21', '2020-05-23', '2020-05-25',\n",
       "       '2020-05-27', '2020-05-29', '2020-05-31'], dtype='datetime64[D]')"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dates = np.arange(np.datetime64('2019-06-02'), np.datetime64('2020-06-02'), 2)\n",
    "dates"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numpy Advanced Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "#vectorize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "def foo(x):\n",
    "    if x%2 == 1:\n",
    "        return x**2\n",
    "    else:\n",
    "        return x/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "121"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "foo(11)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "foo_v = np.vectorize(foo, otypes=[float])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[6, 5, 9, 9, 5],\n",
       "       [3, 9, 5, 9, 9],\n",
       "       [1, 8, 9, 7, 7],\n",
       "       [7, 1, 7, 1, 6],\n",
       "       [4, 6, 2, 4, 6],\n",
       "       [1, 4, 3, 2, 4],\n",
       "       [1, 8, 5, 7, 5],\n",
       "       [8, 5, 1, 3, 4],\n",
       "       [8, 1, 8, 1, 3],\n",
       "       [1, 8, 2, 6, 9]])"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 3., 25., 81., 81., 25.],\n",
       "       [ 9., 81., 25., 81., 81.],\n",
       "       [ 1.,  4., 81., 49., 49.],\n",
       "       [49.,  1., 49.,  1.,  3.],\n",
       "       [ 2.,  3.,  1.,  2.,  3.],\n",
       "       [ 1.,  2.,  9.,  1.,  2.],\n",
       "       [ 1.,  4., 25., 49., 25.],\n",
       "       [ 4., 25.,  1.,  9.,  2.],\n",
       "       [ 4.,  1.,  4.,  1.,  9.],\n",
       "       [ 1.,  4.,  1.,  3., 81.]])"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "foo_v(arr)"
   ]
  },
  {
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}