NumPy - Intermediate.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "a = np.array([ [[1],[2]], [[3],[4]], [[5],[6]]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[1],\n",
       "        [2]],\n",
       "\n",
       "       [[3],\n",
       "        [4]],\n",
       "\n",
       "       [[5],\n",
       "        [6]]])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = np.array([ [1,2], [3,4]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.array(range(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "y = x # Both x & y are pointing to same np.array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0, 99,  2,  3,  4,  5,  6,  7,  8,  9])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y[1] = 99\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "z = x.copy() #Makes a seperate copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "z[0] = 44"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([44, 99,  2,  3,  4,  5,  6,  7,  8,  9])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0, 99,  2,  3,  4,  5,  6,  7,  8,  9])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0, 99,  2,  3,  4],\n",
       "       [ 5,  6,  7,  8,  9]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.reshape((2,5)) # Changing the dimension of data\n",
    "#reshape takes only one argument, pass dim as tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = np.array([1,2,3])\n",
    "y = np.array([4,5,6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# [] -> This represents list - generally passing list/data\n",
    "# () -> Tuple or Set or Function call, passing meta data info"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.concatenate([x,y]) # pass a list to the function call"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 7, 9])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x + y #each elem of x "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(range(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.arange(10)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([0, 1, 2, 3, 4]), array([5, 6, 7, 8, 9])]"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.hsplit(x,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.random.randint(10,size=(4,6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4, 9, 4, 5, 2, 9],\n",
       "       [9, 1, 5, 2, 8, 2],\n",
       "       [6, 1, 8, 6, 3, 5],\n",
       "       [2, 7, 2, 9, 5, 5]])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([[1, 4, 1],\n",
       "        [3, 4, 7],\n",
       "        [3, 4, 5],\n",
       "        [7, 0, 2]]), array([[8, 6, 0],\n",
       "        [3, 9, 8],\n",
       "        [9, 0, 6],\n",
       "        [4, 0, 7]])]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.hsplit(x,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "a,b = np.vsplit(x,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4, 9, 4, 5, 2, 9],\n",
       "       [9, 1, 5, 2, 8, 2]])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[6, 1, 8, 6, 3, 5],\n",
       "       [2, 7, 2, 9, 5, 5]])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 4, 1, 8, 6, 0],\n",
       "       [3, 4, 7, 3, 9, 8],\n",
       "       [3, 4, 5, 9, 0, 6],\n",
       "       [7, 0, 2, 4, 0, 7]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.vstack([a,b])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 4, 1, 8, 6, 0],\n",
       "       [3, 4, 7, 3, 9, 8],\n",
       "       [3, 4, 5, 9, 0, 6],\n",
       "       [7, 0, 2, 4, 0, 7]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.concatenate([a,b]) #passing list of arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = np.arange(8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([0, 1, 2]), array([3, 4]), array([5, 6]), array([7])]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "xdata = np.split(x,[3,5,7])\n",
    "#help(np.split)\n",
    "xdata"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 4])"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 6, 7])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function split in module numpy.lib.shape_base:\n",
      "\n",
      "split(ary, indices_or_sections, axis=0)\n",
      "    Split an array into multiple sub-arrays.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    ary : ndarray\n",
      "        Array to be divided into sub-arrays.\n",
      "    indices_or_sections : int or 1-D array\n",
      "        If `indices_or_sections` is an integer, N, the array will be divided\n",
      "        into N equal arrays along `axis`.  If such a split is not possible,\n",
      "        an error is raised.\n",
      "    \n",
      "        If `indices_or_sections` is a 1-D array of sorted integers, the entries\n",
      "        indicate where along `axis` the array is split.  For example,\n",
      "        ``[2, 3]`` would, for ``axis=0``, result in\n",
      "    \n",
      "          - ary[:2]\n",
      "          - ary[2:3]\n",
      "          - ary[3:]\n",
      "    \n",
      "        If an index exceeds the dimension of the array along `axis`,\n",
      "        an empty sub-array is returned correspondingly.\n",
      "    axis : int, optional\n",
      "        The axis along which to split, default is 0.\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    sub-arrays : list of ndarrays\n",
      "        A list of sub-arrays.\n",
      "    \n",
      "    Raises\n",
      "    ------\n",
      "    ValueError\n",
      "        If `indices_or_sections` is given as an integer, but\n",
      "        a split does not result in equal division.\n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    array_split : Split an array into multiple sub-arrays of equal or\n",
      "                  near-equal size.  Does not raise an exception if\n",
      "                  an equal division cannot be made.\n",
      "    hsplit : Split array into multiple sub-arrays horizontally (column-wise).\n",
      "    vsplit : Split array into multiple sub-arrays vertically (row wise).\n",
      "    dsplit : Split array into multiple sub-arrays along the 3rd axis (depth).\n",
      "    concatenate : Join a sequence of arrays along an existing axis.\n",
      "    stack : Join a sequence of arrays along a new axis.\n",
      "    hstack : Stack arrays in sequence horizontally (column wise).\n",
      "    vstack : Stack arrays in sequence vertically (row wise).\n",
      "    dstack : Stack arrays in sequence depth wise (along third dimension).\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    >>> x = np.arange(9.0)\n",
      "    >>> np.split(x, 3)\n",
      "    [array([ 0.,  1.,  2.]), array([ 3.,  4.,  5.]), array([ 6.,  7.,  8.])]\n",
      "    \n",
      "    >>> x = np.arange(8.0)\n",
      "    >>> np.split(x, [3, 5, 6, 10])\n",
      "    [array([ 0.,  1.,  2.]),\n",
      "     array([ 3.,  4.]),\n",
      "     array([ 5.]),\n",
      "     array([ 6.,  7.]),\n",
      "     array([], dtype=float64)]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(np.split)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = np.random.randint(10,size=(4,6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([[9, 9],\n",
       "        [0, 0],\n",
       "        [8, 6],\n",
       "        [0, 6]]), array([[2, 1],\n",
       "        [6, 8],\n",
       "        [8, 7],\n",
       "        [9, 7]]), array([[3, 4],\n",
       "        [9, 3],\n",
       "        [7, 7],\n",
       "        [1, 0]])]"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.hsplit(x,[2,4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[9, 9, 2, 1, 3, 4],\n",
       "       [0, 0, 6, 8, 9, 3],\n",
       "       [8, 6, 8, 7, 7, 7],\n",
       "       [0, 6, 9, 7, 1, 0]])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Performance "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000 loops, best of 3: 429 µs per loop\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "m= np.arange(100000)\n",
    "np.sum(m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4, 7, 5, 6, 8, 1],\n",
       "       [3, 4, 2, 7, 4, 6]])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100 loops, best of 3: 9.5 ms per loop\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "a = range(100000)\n",
    "sum(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ZekeLabs\\Anaconda2\\envs\\gl-env\\lib\\site-packages\\ipykernel\\__main__.py:258: RuntimeWarning: overflow encountered in long_scalars\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 loops, best of 3: 20.6 ms per loop\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "a = np.arange(100000)\n",
    "sum(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000 loops, best of 3: 265 µs per loop\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "a = np.arange(100000)\n",
    "np.sum(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.add(a,a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000 loops, best of 3: 654 µs per loop\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "np.add(np.arange(100000),np.arange(100000))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000 loops, best of 3: 763 µs per loop\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "np.arange(100000) + np.arange(100000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  4,  9, 16, 25, 36, 49, 64, 81])"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.multiply(a,a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.98803162409286183"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sin(30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.0"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.log2(64)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.log10(1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  1.00000000e+00,   2.71828183e+00,   7.38905610e+00,\n",
       "         2.00855369e+01,   5.45981500e+01,   1.48413159e+02,\n",
       "         4.03428793e+02,   1.09663316e+03,   2.98095799e+03,\n",
       "         8.10308393e+03])"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.exp(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  1.,  1.,  1.,  1.],\n",
       "       [ 1.,  1.,  1.,  1.,  1.],\n",
       "       [ 1.,  1.,  1.,  1.,  1.],\n",
       "       [ 1.,  1.,  1.,  1.,  1.],\n",
       "       [ 1.,  1.,  1.,  1.,  1.]])"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones((5,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.,  0.,  0.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.,  0.,  0.]])"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((6,6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.add.reduce(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  3,  6, 10, 15, 21, 28, 36, 45])"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.add.accumulate(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.argmax(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.random.randint(10,size=(5,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[7, 8, 0, 7, 2],\n",
       "       [9, 4, 3, 4, 7],\n",
       "       [4, 0, 0, 2, 5],\n",
       "       [3, 3, 8, 5, 5],\n",
       "       [9, 8, 7, 3, 1]])"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([8, 9, 5, 8, 9])"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.max(a,axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([9, 8, 8, 7, 7])"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.max(a,axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.5599999999999996"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 4.8,  5.4,  2.2,  4.8,  5.6])"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean(a,axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.8153862967628438"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.std(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.0"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.median(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "data = pd.read_csv('president_heights.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>order</th>\n",
       "      <th>name</th>\n",
       "      <th>height(cm)</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>George Washington</td>\n",
       "      <td>189</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>John Adams</td>\n",
       "      <td>170</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>Thomas Jefferson</td>\n",
       "      <td>189</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>James Madison</td>\n",
       "      <td>163</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>James Monroe</td>\n",
       "      <td>183</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   order               name  height(cm)\n",
       "0      1  George Washington         189\n",
       "1      2         John Adams         170\n",
       "2      3   Thomas Jefferson         189\n",
       "3      4      James Madison         163\n",
       "4      5       James Monroe         183"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "heights = np.array(data['height(cm)'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([189, 170, 189, 163, 183, 171, 185, 168, 173, 183, 173, 173, 175,\n",
       "       178, 183, 193, 178, 173, 174, 183, 183, 168, 170, 178, 182, 180,\n",
       "       183, 178, 182, 188, 175, 179, 183, 193, 182, 183, 177, 185, 188,\n",
       "       188, 182, 185], dtype=int64)"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "heights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "179.73809523809524"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "heights.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "193"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "heights.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "179.73809523809524"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "heights.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([  1.,   2.,   3.,   5.,   3.,   6.,  12.,   3.,   5.,   2.]),\n",
       " array([ 163.,  166.,  169.,  172.,  175.,  178.,  181.,  184.,  187.,\n",
       "         190.,  193.]),\n",
       " <a list of 10 Patch objects>)"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAEACAYAAABI5zaHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nJES4A0BChDsAJPR/fU4AdhzdGeQAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x96ae748>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.hist(heights,color='red')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function hist in module matplotlib.pyplot:\n",
      "\n",
      "hist(x, bins=10, range=None, normed=False, weights=None, cumulative=False, bottom=None, histtype=u'bar', align=u'mid', orientation=u'vertical', rwidth=None, log=False, color=None, label=None, stacked=False, hold=None, data=None, **kwargs)\n",
      "    Plot a histogram.\n",
      "    \n",
      "    Compute and draw the histogram of *x*. The return value is a\n",
      "    tuple (*n*, *bins*, *patches*) or ([*n0*, *n1*, ...], *bins*,\n",
      "    [*patches0*, *patches1*,...]) if the input contains multiple\n",
      "    data.\n",
      "    \n",
      "    Multiple data can be provided via *x* as a list of datasets\n",
      "    of potentially different length ([*x0*, *x1*, ...]), or as\n",
      "    a 2-D ndarray in which each column is a dataset.  Note that\n",
      "    the ndarray form is transposed relative to the list form.\n",
      "    \n",
      "    Masked arrays are not supported at present.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    x : (n,) array or sequence of (n,) arrays\n",
      "        Input values, this takes either a single array or a sequency of\n",
      "        arrays which are not required to be of the same length\n",
      "    \n",
      "    bins : integer or array_like, optional\n",
      "        If an integer is given, `bins + 1` bin edges are returned,\n",
      "        consistently with :func:`numpy.histogram` for numpy version >=\n",
      "        1.3.\n",
      "    \n",
      "        Unequally spaced bins are supported if `bins` is a sequence.\n",
      "    \n",
      "        default is 10\n",
      "    \n",
      "    range : tuple or None, optional\n",
      "        The lower and upper range of the bins. Lower and upper outliers\n",
      "        are ignored. If not provided, `range` is (x.min(), x.max()). Range\n",
      "        has no effect if `bins` is a sequence.\n",
      "    \n",
      "        If `bins` is a sequence or `range` is specified, autoscaling\n",
      "        is based on the specified bin range instead of the\n",
      "        range of x.\n",
      "    \n",
      "        Default is ``None``\n",
      "    \n",
      "    normed : boolean, optional\n",
      "        If `True`, the first element of the return tuple will\n",
      "        be the counts normalized to form a probability density, i.e.,\n",
      "        ``n/(len(x)`dbin)``, i.e., the integral of the histogram will sum\n",
      "        to 1. If *stacked* is also *True*, the sum of the histograms is\n",
      "        normalized to 1.\n",
      "    \n",
      "        Default is ``False``\n",
      "    \n",
      "    weights : (n, ) array_like or None, optional\n",
      "        An array of weights, of the same shape as `x`.  Each value in `x`\n",
      "        only contributes its associated weight towards the bin count\n",
      "        (instead of 1).  If `normed` is True, the weights are normalized,\n",
      "        so that the integral of the density over the range remains 1.\n",
      "    \n",
      "        Default is ``None``\n",
      "    \n",
      "    cumulative : boolean, optional\n",
      "        If `True`, then a histogram is computed where each bin gives the\n",
      "        counts in that bin plus all bins for smaller values. The last bin\n",
      "        gives the total number of datapoints.  If `normed` is also `True`\n",
      "        then the histogram is normalized such that the last bin equals 1.\n",
      "        If `cumulative` evaluates to less than 0 (e.g., -1), the direction\n",
      "        of accumulation is reversed.  In this case, if `normed` is also\n",
      "        `True`, then the histogram is normalized such that the first bin\n",
      "        equals 1.\n",
      "    \n",
      "        Default is ``False``\n",
      "    \n",
      "    bottom : array_like, scalar, or None\n",
      "        Location of the bottom baseline of each bin.  If a scalar,\n",
      "        the base line for each bin is shifted by the same amount.\n",
      "        If an array, each bin is shifted independently and the length\n",
      "        of bottom must match the number of bins.  If None, defaults to 0.\n",
      "    \n",
      "        Default is ``None``\n",
      "    \n",
      "    histtype : {'bar', 'barstacked', 'step',  'stepfilled'}, optional\n",
      "        The type of histogram to draw.\n",
      "    \n",
      "        - 'bar' is a traditional bar-type histogram.  If multiple data\n",
      "          are given the bars are aranged side by side.\n",
      "    \n",
      "        - 'barstacked' is a bar-type histogram where multiple\n",
      "          data are stacked on top of each other.\n",
      "    \n",
      "        - 'step' generates a lineplot that is by default\n",
      "          unfilled.\n",
      "    \n",
      "        - 'stepfilled' generates a lineplot that is by default\n",
      "          filled.\n",
      "    \n",
      "        Default is 'bar'\n",
      "    \n",
      "    align : {'left', 'mid', 'right'}, optional\n",
      "        Controls how the histogram is plotted.\n",
      "    \n",
      "            - 'left': bars are centered on the left bin edges.\n",
      "    \n",
      "            - 'mid': bars are centered between the bin edges.\n",
      "    \n",
      "            - 'right': bars are centered on the right bin edges.\n",
      "    \n",
      "        Default is 'mid'\n",
      "    \n",
      "    orientation : {'horizontal', 'vertical'}, optional\n",
      "        If 'horizontal', `~matplotlib.pyplot.barh` will be used for\n",
      "        bar-type histograms and the *bottom* kwarg will be the left edges.\n",
      "    \n",
      "    rwidth : scalar or None, optional\n",
      "        The relative width of the bars as a fraction of the bin width.  If\n",
      "        `None`, automatically compute the width.\n",
      "    \n",
      "        Ignored if `histtype` is 'step' or 'stepfilled'.\n",
      "    \n",
      "        Default is ``None``\n",
      "    \n",
      "    log : boolean, optional\n",
      "        If `True`, the histogram axis will be set to a log scale. If `log`\n",
      "        is `True` and `x` is a 1D array, empty bins will be filtered out\n",
      "        and only the non-empty (`n`, `bins`, `patches`) will be returned.\n",
      "    \n",
      "        Default is ``False``\n",
      "    \n",
      "    color : color or array_like of colors or None, optional\n",
      "        Color spec or sequence of color specs, one per dataset.  Default\n",
      "        (`None`) uses the standard line color sequence.\n",
      "    \n",
      "        Default is ``None``\n",
      "    \n",
      "    label : string or None, optional\n",
      "        String, or sequence of strings to match multiple datasets.  Bar\n",
      "        charts yield multiple patches per dataset, but only the first gets\n",
      "        the label, so that the legend command will work as expected.\n",
      "    \n",
      "        default is ``None``\n",
      "    \n",
      "    stacked : boolean, optional\n",
      "        If `True`, multiple data are stacked on top of each other If\n",
      "        `False` multiple data are aranged side by side if histtype is\n",
      "        'bar' or on top of each other if histtype is 'step'\n",
      "    \n",
      "        Default is ``False``\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    n : array or list of arrays\n",
      "        The values of the histogram bins. See **normed** and **weights**\n",
      "        for a description of the possible semantics. If input **x** is an\n",
      "        array, then this is an array of length **nbins**. If input is a\n",
      "        sequence arrays ``[data1, data2,..]``, then this is a list of\n",
      "        arrays with the values of the histograms for each of the arrays\n",
      "        in the same order.\n",
      "    \n",
      "    bins : array\n",
      "        The edges of the bins. Length nbins + 1 (nbins left edges and right\n",
      "        edge of last bin).  Always a single array even when multiple data\n",
      "        sets are passed in.\n",
      "    \n",
      "    patches : list or list of lists\n",
      "        Silent list of individual patches used to create the histogram\n",
      "        or list of such list if multiple input datasets.\n",
      "    \n",
      "    Other Parameters\n",
      "    ----------------\n",
      "    kwargs : `~matplotlib.patches.Patch` properties\n",
      "    \n",
      "    See also\n",
      "    --------\n",
      "    hist2d : 2D histograms\n",
      "    \n",
      "    Notes\n",
      "    -----\n",
      "    Until numpy release 1.5, the underlying numpy histogram function was\n",
      "    incorrect with `normed`=`True` if bin sizes were unequal.  MPL\n",
      "    inherited that error.  It is now corrected within MPL when using\n",
      "    earlier numpy versions.\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    .. plot:: mpl_examples/statistics/histogram_demo_features.py\n",
      "    \n",
      "    Notes\n",
      "    -----\n",
      "    \n",
      "    In addition to the above described arguments, this function can take a\n",
      "    **data** keyword argument. If such a **data** argument is given, the\n",
      "    following arguments are replaced by **data[<arg>]**:\n",
      "    \n",
      "    * All arguments with the following names: 'x', 'weights'.\n",
      "    \n",
      "    \n",
      "    \n",
      "    \n",
      "    Additional kwargs: hold = [True|False] overrides default hold state\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(plt.hist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The slowest run took 9.74 times longer than the fastest. This could mean that an intermediate result is being cached.\n",
      "100000 loops, best of 3: 3.98 µs per loop\n"
     ]
    }
   ],
   "source": [
    "%timeit np.arange(1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 loops, best of 3: 75.4 ms per loop\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "l = range(100000)\n",
    "for i in l:\n",
    "    l[i] + l[i]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000 loops, best of 3: 594 µs per loop\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "l = np.arange(100000)\n",
    "l + l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.5.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}