Day_8-9_Numpy and Pandas.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numpy\n",
    "\n",
    "Numpy is another module like matplotlib, csv, math that  provides you with an array data structure that holds some benefits over Python lists, such as: being more compact, faster access in reading and writing items, being more convenient and more efficient.\n",
    "\n",
    "Numpy = Numeric Python\n",
    "\n",
    "\n",
    "\n",
    "NumPy is a Python library that is the core library for scientific computing in Python. It contains a collection of tools and techniques that can be used to solve on a computer mathematical models of problems in Science and Engineering. One of these tools is a high-performance multidimensional array object that is a powerful data structure for efficient computation of arrays and matrices. To work with these arrays, there’s a huge amount of high-level mathematical functions operate on these matrices and arrays\n",
    "\n",
    "#### What is a Numpy Array?\n",
    "NumPy arrays are a like python lists. But they are different on following points. \n",
    "\n",
    "An array is a grid of values of same type. \n",
    "\n",
    "Eg. \n",
    "\n",
    "```\n",
    "[[1 2 3 4]\n",
    " [5 6 7 8]]\n",
    "[[1 2 3 4]\n",
    " [5 6 7 8]]\n",
    "[[[ 1  2  3  4]\n",
    "  [ 5  6  7  8]]\n",
    "\n",
    " [[ 1  2  3  4]\n",
    "  [ 9 10 11 12]]]\n",
    "```\n",
    "\n",
    "The arrays hold and represent any data in structured way. \n",
    "\n",
    "Generally an array has few properties \n",
    "\n",
    "1. data - where is the data? The memory location\n",
    "2. datatype - what type of data ? (dtype)\n",
    "3. shape - how much data?\n",
    "\n",
    "```python\n",
    "my_array.data\n",
    "my_array.dtype\n",
    "my_array.shape\n",
    "```\n",
    "\n",
    "#### Axis \n",
    "![axis](./images/axis.png)\n",
    "\n",
    "Rows are axis 0 and Columns are axis 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### How to make numpy arrays?\n",
    "\n",
    "1. By Passing a list "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np \n",
    "a = np.array([1,2,3])\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<memory at 0x10ff4d888>\n",
      "int64\n",
      "(3,)\n",
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "print(a.data)\n",
    "print(a.dtype)\n",
    "print(a.shape)\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.5  2.   3. ]\n",
      " [ 4.   5.   6. ]]\n",
      "float64\n",
      "(2, 3)\n"
     ]
    }
   ],
   "source": [
    "#Creating 2-D arrays\n",
    "b = np.array([(1.5,2,3), (4,5,6)], dtype = float)\n",
    "print(b)\n",
    "print(b.dtype)\n",
    "print(b.shape)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[ 1.5  2.   3. ]\n",
      "  [ 4.   5.   6. ]]\n",
      "\n",
      " [[ 3.   2.   1. ]\n",
      "  [ 4.   5.   6. ]]]\n",
      "float64\n",
      "(2, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "#Creating 3D arrays \n",
    "c = np.array([[(1.5,2,3), (4,5,6)], [(3,2,1), (4,5,6)]],\n",
    "dtype = float)\n",
    "print(c)\n",
    "print(c.dtype)\n",
    "print(c.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What different datatypes can be taken. More info at the [documentation](https://docs.scipy.org/doc/numpy-1.10.4/user/basics.types.html) , commonly used are \n",
    "\n",
    "1. int64\n",
    "2. int32\n",
    "3. float64\n",
    "4. float32\n",
    "5. complex\n",
    "6. bool"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Many times we don't know the data that will be put inside the array so what we can do is create arrays with some value and then replace those values \n",
    "\n",
    "```python\n",
    "# Create an array of ones\n",
    "np.ones((3,4))\n",
    "\n",
    "# Create an array of zeros\n",
    "np.zeros((2,3,4),dtype=np.int16)\n",
    "\n",
    "# Create an array with random values\n",
    "np.random.random((2,2))\n",
    "\n",
    "# Create an empty array\n",
    "np.empty((3,2))\n",
    "\n",
    "# Create a full array a constant value\n",
    "np.full((2,2),7)\n",
    "\n",
    "# Create an array of evenly-spaced values\n",
    "np.arange(10,25,5)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  1.,  1.,  1.],\n",
       "       [ 1.,  1.,  1.,  1.],\n",
       "       [ 1.,  1.,  1.,  1.]])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones((3,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[0, 0, 0, 0],\n",
       "        [0, 0, 0, 0],\n",
       "        [0, 0, 0, 0]],\n",
       "\n",
       "       [[0, 0, 0, 0],\n",
       "        [0, 0, 0, 0],\n",
       "        [0, 0, 0, 0]]], dtype=int16)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((2,3,4),dtype=np.int16)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.80030682,  0.10652471],\n",
       "       [ 0.87841342,  0.1430539 ]])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.random((2,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  1.72723371e-077,   1.73060100e-077,   2.30341581e-314],\n",
       "       [  2.30346015e-314,   2.30346818e-314,   2.30346441e-314],\n",
       "       [  2.25435565e-314,   0.00000000e+000,   2.23748262e-314]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#what the hell this function does?\n",
    "\n",
    "np.empty((3,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[9, 9],\n",
       "       [9, 9]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.full((2,2),9)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 12, 14, 16, 18, 20, 22, 24])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create an array of evenly-spaced values\n",
    "np.arange(10,26,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(10,26)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(26,10,-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10 13 16 19 22]\n",
      "float64\n",
      "[ 10.  13.  16.  19.  22.]\n"
     ]
    }
   ],
   "source": [
    "#chnging the data type of the array \n",
    "\n",
    "x = np.arange(10,25,3)\n",
    "print(x)\n",
    "x = x.astype(float)\n",
    "print(x.dtype)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Broadcasting\n",
    "\n",
    "\n",
    "Allows numpy to work with arrays of different shapes for arithmetic operations\n",
    "\n",
    "Rules for Broadcasting\n",
    "\n",
    "The operations can be performed when the two dimension of two arrays are compatible. \n",
    "\n",
    "1. The dimensions are compatible when they are same\n",
    "\n",
    "eg. (3,4) and (3,4)\n",
    "\n",
    "2. The dimensions are also compatible when one of them is 1. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 4)\n",
      "(3, 4)\n",
      "[[ 1.52523631  1.47851231  1.03523357  1.02160921]\n",
      " [ 1.95811681  1.46177662  1.39491882  1.15447735]\n",
      " [ 1.54664765  1.06706567  1.23577024  1.21884514]]\n",
      "(3, 4)\n"
     ]
    }
   ],
   "source": [
    "## When the dimensions are equal \n",
    "\n",
    "# Initialize `x`\n",
    "x = np.ones((3,4))\n",
    "\n",
    "# Check shape of `x`\n",
    "print(x.shape)\n",
    "\n",
    "# Initialize `y`\n",
    "y = np.random.random((3,4))\n",
    "\n",
    "# Check shape of `y`\n",
    "print(y.shape)\n",
    "\n",
    "# Add `x` and `y`\n",
    "z = x + y\n",
    "\n",
    "print(z)\n",
    "print(z.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(4, 3)\n",
      "(3,)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  0., -1.],\n",
       "       [ 1.,  0., -1.],\n",
       "       [ 1.,  0., -1.],\n",
       "       [ 1.,  0., -1.]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Initialize `x`\n",
    "x = np.ones((3,4))\n",
    "x = x.T\n",
    "# Check shape of `x`\n",
    "print(x.shape)\n",
    "\n",
    "# Initialize `y`\n",
    "y = np.arange(3)\n",
    "\n",
    "# Check shape of `y`\n",
    "print(y.shape)\n",
    "x-y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 4)\n",
      "[[ 1.  1.  1.  1.]\n",
      " [ 1.  1.  1.  1.]\n",
      " [ 1.  1.  1.  1.]]\n",
      "(4,)\n",
      "[0 1 2 3]\n",
      "[[ 1.  0. -1. -2.]\n",
      " [ 1.  0. -1. -2.]\n",
      " [ 1.  0. -1. -2.]]\n"
     ]
    }
   ],
   "source": [
    "# When one of the array dimension is 1\n",
    "# Import `numpy` as `np`\n",
    "import numpy as np\n",
    "\n",
    "# Initialize `x`\n",
    "x = np.ones((3,4))\n",
    "\n",
    "# Check shape of `x`\n",
    "print(x.shape)\n",
    "print(x)\n",
    "# Initialize `y`\n",
    "y = np.arange(4)\n",
    "\n",
    "# Check shape of `y`\n",
    "print(y.shape)\n",
    "print(y)\n",
    "\n",
    "# Subtract `x` and `y`\n",
    "z = x - y \n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the dimensions are not compatible then we get Value error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 4)\n",
      "(4, 3)\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "operands could not be broadcast together with shapes (3,4) (4,3) ",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-30-2d3eb2d83a34>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     12\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;31m# Subtract `x` and `y`\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m \u001b[0mx\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (3,4) (4,3) "
     ]
    }
   ],
   "source": [
    "# Initialize `x`\n",
    "x = np.ones((3,4))\n",
    "\n",
    "# Check shape of `x`\n",
    "print(x.shape)\n",
    "\n",
    "# Initialize `y`\n",
    "y = np.random.random((4,3))\n",
    "\n",
    "# Check shape of `y`\n",
    "print(y.shape)\n",
    "\n",
    "# Subtract `x` and `y`\n",
    "x - y "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To test what the size of the resulting array is after you have done the computations! You’ll see that the size is actually the maximum size along each dimension of the input arrays.\n",
    "\n",
    "\n",
    " If you want to make use of broadcasting, you will rely a lot on the shape and dimensions of the arrays with which you’re working.\n",
    "But what if the dimensions are not compatible?\n",
    "What if they are not equal or if one of them is not equal to 1?\n",
    "You’ll have to fix this by manipulating your array! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Array Operations \n",
    "\n",
    "We can use the simple operators but we have functions also \n",
    "\n",
    "```\n",
    "np.add()\n",
    "np.subtract()\n",
    "np.multiply()\n",
    "np.divide()\n",
    "np.remainder()\n",
    "```\n",
    "\n",
    "#### Mathematical operations\n",
    "```\n",
    "np.exp()\n",
    "np.sin()\n",
    "np.log()\n",
    "np.cos()\n",
    "np.sqrt()\n",
    "np.dot()\n",
    "np.median(x)\n",
    "```\n",
    "\n",
    "\n",
    "#### Functions commonly used by us\n",
    "\n",
    "function name | description\n",
    "-------------|--------------\n",
    "a.sum()\t|Array-wise sum\n",
    "a.min()\t|Array-wise minimum value\n",
    "b.max(axis=0)\t|Maximum value of an array row\n",
    "b.cumsum(axis=1)|\tCumulative sum of the elements\n",
    "a.mean()\t|Mean\n",
    "np.std(b)\t|Standard deviation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [3 4 5]]\n",
      "[[ 2  4  6]\n",
      " [ 6  8 10]]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1,2,3],[3,4,5]])\n",
    "print(x)\n",
    "\n",
    "x = x * 2 \n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "x = np.array([[1,2,3],[3,4,5]])\n",
    "\n",
    "np.median(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [3 4 5]] \n",
      " [[10 20 30]\n",
      " [30 40 50]]\n",
      "[[ 10  40  90]\n",
      " [ 90 160 250]]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1,2,3],[3,4,5]])\n",
    "y = np.array([[10,20,30],[30,40,50]])\n",
    "print(x,'\\n',y)\n",
    "\n",
    "z = x * y \n",
    "print(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [3 4 5]] \n",
      " [[10 20 30]\n",
      " [30 40 50]\n",
      " [50 60 70]]\n",
      "[[220 280 340]\n",
      " [400 520 640]]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1,2,3],[3,4,5]])\n",
    "y = np.array([[10,20,30],[30,40,50],[50,60,70]])\n",
    "print(x,'\\n',y)\n",
    "\n",
    "z = np.dot(x,y) \n",
    "print(z)\n",
    "# np.dot(x,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Subsets, Slicing and Indexing\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[10 20 30]\n",
      " [30 40 50]\n",
      " [50 60 70]]\n"
     ]
    }
   ],
   "source": [
    "# Regular Arrays index \n",
    "# [][] [,]\n",
    "\n",
    "\n",
    "y = np.array([[10,20,30],[30,40,50],[50,60,70]])\n",
    "\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "40\n",
      "40\n",
      "[[20 30]\n",
      " [40 50]]\n"
     ]
    }
   ],
   "source": [
    "# to get 40 \n",
    "print(y[1][1])\n",
    "\n",
    "print( y[1,1] )\n",
    "\n",
    "print(y[:2,1: ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([10, 20, 30, 30, 40])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_filter = (y <= 40)\n",
    "print(type(my_filter))\n",
    "y[my_filter]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 30, 50])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# first column get \n",
    "\n",
    "y[ : , 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10, 20],\n",
       "       [30, 40],\n",
       "       [50, 60]])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#get first 2 columns\n",
    "y [: ,:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  0.,  0.],\n",
       "       [ 0.,  1.,  0.],\n",
       "       [ 0.,  0.,  1.]])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.eye(3,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[10 20 30]\n",
      " [30 40 50]\n",
      " [50 60 70]]\n",
      "[[10 20 30 30 40 50 50 60 70]]\n",
      "[10 20 30 30 40 50 50 60 70]\n",
      "[[10 20 30]\n",
      " [30 40 50]\n",
      " [50 60 70]]\n"
     ]
    }
   ],
   "source": [
    "# reshaping\n",
    "print(y)\n",
    "print(y.reshape(1,9))\n",
    "\n",
    "#special case -1\n",
    "print(y.reshape(-1))\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.16158645,  0.5016914 ,  0.29069675,  0.83610517],\n",
       "       [ 0.80189286,  0.31496101,  0.68242368,  0.46461197],\n",
       "       [ 0.01226678,  0.29007112,  0.55545979,  0.02813327],\n",
       "       [ 0.43018296,  0.71130723,  0.08064317,  0.52171489]])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = np.random.random((4,4))\n",
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.16158645,  0.5016914 ,  0.29069675,  0.83610517,  0.80189286,\n",
       "        0.31496101,  0.68242368,  0.46461197,  0.01226678,  0.29007112,\n",
       "        0.55545979,  0.02813327,  0.43018296,  0.71130723,  0.08064317,\n",
       "        0.52171489])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.reshape(-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[[ 0.16158645,  0.5016914 ],\n",
       "         [ 0.29069675,  0.83610517]],\n",
       "\n",
       "        [[ 0.80189286,  0.31496101],\n",
       "         [ 0.68242368,  0.46461197]]],\n",
       "\n",
       "\n",
       "       [[[ 0.01226678,  0.29007112],\n",
       "         [ 0.55545979,  0.02813327]],\n",
       "\n",
       "        [[ 0.43018296,  0.71130723],\n",
       "         [ 0.08064317,  0.52171489]]]])"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.reshape(2,2,2,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0.16158645,  0.5016914 ,  0.29069675,  0.83610517],\n",
       "        [ 0.80189286,  0.31496101,  0.68242368,  0.46461197]],\n",
       "\n",
       "       [[ 0.01226678,  0.29007112,  0.55545979,  0.02813327],\n",
       "        [ 0.43018296,  0.71130723,  0.08064317,  0.52171489]]])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.reshape(2,2,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0.16158645,  0.5016914 ],\n",
       "        [ 0.29069675,  0.83610517],\n",
       "        [ 0.80189286,  0.31496101],\n",
       "        [ 0.68242368,  0.46461197]],\n",
       "\n",
       "       [[ 0.01226678,  0.29007112],\n",
       "        [ 0.55545979,  0.02813327],\n",
       "        [ 0.43018296,  0.71130723],\n",
       "        [ 0.08064317,  0.52171489]]])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.reshape(2,4,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.16158645,  0.5016914 ,  0.29069675,  0.83610517],\n",
       "       [ 0.80189286,  0.31496101,  0.68242368,  0.46461197],\n",
       "       [ 0.01226678,  0.29007112,  0.55545979,  0.02813327],\n",
       "       [ 0.43018296,  0.71130723,  0.08064317,  0.52171489]])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.16158645],\n",
       "       [ 0.5016914 ],\n",
       "       [ 0.29069675],\n",
       "       [ 0.83610517],\n",
       "       [ 0.80189286],\n",
       "       [ 0.31496101],\n",
       "       [ 0.68242368],\n",
       "       [ 0.46461197],\n",
       "       [ 0.01226678],\n",
       "       [ 0.29007112],\n",
       "       [ 0.55545979],\n",
       "       [ 0.02813327],\n",
       "       [ 0.43018296],\n",
       "       [ 0.71130723],\n",
       "       [ 0.08064317],\n",
       "       [ 0.52171489]])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.reshape(16,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.16158645,  0.5016914 ,  0.29069675,  0.83610517,  0.80189286,\n",
       "        0.31496101,  0.68242368,  0.46461197,  0.01226678,  0.29007112,\n",
       "        0.55545979,  0.02813327,  0.43018296,  0.71130723,  0.08064317,\n",
       "        0.52171489])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.reshape(2,4,2).reshape(-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.16158645,  0.5016914 ,  0.29069675,  0.83610517,  0.80189286,\n",
       "        0.31496101,  0.68242368,  0.46461197,  0.01226678,  0.29007112,\n",
       "        0.55545979,  0.02813327,  0.43018296,  0.71130723,  0.08064317,\n",
       "        0.52171489])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.reshape(4,4).reshape(-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 6.,  0.,  0.],\n",
       "       [ 0.,  6.,  0.],\n",
       "       [ 0.,  0.,  6.],\n",
       "       [ 0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.]])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.eye(5,3)*6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.16158645,  0.5016914 ,  0.29069675,  0.83610517],\n",
       "       [ 0.80189286,  0.31496101,  0.68242368,  0.46461197],\n",
       "       [ 0.01226678,  0.29007112,  0.55545979,  0.02813327],\n",
       "       [ 0.43018296,  0.71130723,  0.08064317,  0.52171489]])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.68374849467875"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.79007976,  2.26388952,  0.88593096,  1.74384825])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.sum(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.40592905,  1.81803076,  1.60922339,  1.8505653 ])"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.sum(axis = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.44751994052880983"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.mean(axis=1)[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.7900797621152393"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y[0].sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.4059290477493025"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y[:,0].sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from sklearn import datasets "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "iris_data = datasets.load_iris()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5.1,  3.5,  1.4,  0.2],\n",
       "       [ 4.9,  3. ,  1.4,  0.2],\n",
       "       [ 4.7,  3.2,  1.3,  0.2],\n",
       "       [ 4.6,  3.1,  1.5,  0.2],\n",
       "       [ 5. ,  3.6,  1.4,  0.2],\n",
       "       [ 5.4,  3.9,  1.7,  0.4],\n",
       "       [ 4.6,  3.4,  1.4,  0.3],\n",
       "       [ 5. ,  3.4,  1.5,  0.2],\n",
       "       [ 4.4,  2.9,  1.4,  0.2],\n",
       "       [ 4.9,  3.1,  1.5,  0.1],\n",
       "       [ 5.4,  3.7,  1.5,  0.2],\n",
       "       [ 4.8,  3.4,  1.6,  0.2],\n",
       "       [ 4.8,  3. ,  1.4,  0.1],\n",
       "       [ 4.3,  3. ,  1.1,  0.1],\n",
       "       [ 5.8,  4. ,  1.2,  0.2],\n",
       "       [ 5.7,  4.4,  1.5,  0.4],\n",
       "       [ 5.4,  3.9,  1.3,  0.4],\n",
       "       [ 5.1,  3.5,  1.4,  0.3],\n",
       "       [ 5.7,  3.8,  1.7,  0.3],\n",
       "       [ 5.1,  3.8,  1.5,  0.3],\n",
       "       [ 5.4,  3.4,  1.7,  0.2],\n",
       "       [ 5.1,  3.7,  1.5,  0.4],\n",
       "       [ 4.6,  3.6,  1. ,  0.2],\n",
       "       [ 5.1,  3.3,  1.7,  0.5],\n",
       "       [ 4.8,  3.4,  1.9,  0.2],\n",
       "       [ 5. ,  3. ,  1.6,  0.2],\n",
       "       [ 5. ,  3.4,  1.6,  0.4],\n",
       "       [ 5.2,  3.5,  1.5,  0.2],\n",
       "       [ 5.2,  3.4,  1.4,  0.2],\n",
       "       [ 4.7,  3.2,  1.6,  0.2],\n",
       "       [ 4.8,  3.1,  1.6,  0.2],\n",
       "       [ 5.4,  3.4,  1.5,  0.4],\n",
       "       [ 5.2,  4.1,  1.5,  0.1],\n",
       "       [ 5.5,  4.2,  1.4,  0.2],\n",
       "       [ 4.9,  3.1,  1.5,  0.1],\n",
       "       [ 5. ,  3.2,  1.2,  0.2],\n",
       "       [ 5.5,  3.5,  1.3,  0.2],\n",
       "       [ 4.9,  3.1,  1.5,  0.1],\n",
       "       [ 4.4,  3. ,  1.3,  0.2],\n",
       "       [ 5.1,  3.4,  1.5,  0.2],\n",
       "       [ 5. ,  3.5,  1.3,  0.3],\n",
       "       [ 4.5,  2.3,  1.3,  0.3],\n",
       "       [ 4.4,  3.2,  1.3,  0.2],\n",
       "       [ 5. ,  3.5,  1.6,  0.6],\n",
       "       [ 5.1,  3.8,  1.9,  0.4],\n",
       "       [ 4.8,  3. ,  1.4,  0.3],\n",
       "       [ 5.1,  3.8,  1.6,  0.2],\n",
       "       [ 4.6,  3.2,  1.4,  0.2],\n",
       "       [ 5.3,  3.7,  1.5,  0.2],\n",
       "       [ 5. ,  3.3,  1.4,  0.2],\n",
       "       [ 7. ,  3.2,  4.7,  1.4],\n",
       "       [ 6.4,  3.2,  4.5,  1.5],\n",
       "       [ 6.9,  3.1,  4.9,  1.5],\n",
       "       [ 5.5,  2.3,  4. ,  1.3],\n",
       "       [ 6.5,  2.8,  4.6,  1.5],\n",
       "       [ 5.7,  2.8,  4.5,  1.3],\n",
       "       [ 6.3,  3.3,  4.7,  1.6],\n",
       "       [ 4.9,  2.4,  3.3,  1. ],\n",
       "       [ 6.6,  2.9,  4.6,  1.3],\n",
       "       [ 5.2,  2.7,  3.9,  1.4],\n",
       "       [ 5. ,  2. ,  3.5,  1. ],\n",
       "       [ 5.9,  3. ,  4.2,  1.5],\n",
       "       [ 6. ,  2.2,  4. ,  1. ],\n",
       "       [ 6.1,  2.9,  4.7,  1.4],\n",
       "       [ 5.6,  2.9,  3.6,  1.3],\n",
       "       [ 6.7,  3.1,  4.4,  1.4],\n",
       "       [ 5.6,  3. ,  4.5,  1.5],\n",
       "       [ 5.8,  2.7,  4.1,  1. ],\n",
       "       [ 6.2,  2.2,  4.5,  1.5],\n",
       "       [ 5.6,  2.5,  3.9,  1.1],\n",
       "       [ 5.9,  3.2,  4.8,  1.8],\n",
       "       [ 6.1,  2.8,  4. ,  1.3],\n",
       "       [ 6.3,  2.5,  4.9,  1.5],\n",
       "       [ 6.1,  2.8,  4.7,  1.2],\n",
       "       [ 6.4,  2.9,  4.3,  1.3],\n",
       "       [ 6.6,  3. ,  4.4,  1.4],\n",
       "       [ 6.8,  2.8,  4.8,  1.4],\n",
       "       [ 6.7,  3. ,  5. ,  1.7],\n",
       "       [ 6. ,  2.9,  4.5,  1.5],\n",
       "       [ 5.7,  2.6,  3.5,  1. ],\n",
       "       [ 5.5,  2.4,  3.8,  1.1],\n",
       "       [ 5.5,  2.4,  3.7,  1. ],\n",
       "       [ 5.8,  2.7,  3.9,  1.2],\n",
       "       [ 6. ,  2.7,  5.1,  1.6],\n",
       "       [ 5.4,  3. ,  4.5,  1.5],\n",
       "       [ 6. ,  3.4,  4.5,  1.6],\n",
       "       [ 6.7,  3.1,  4.7,  1.5],\n",
       "       [ 6.3,  2.3,  4.4,  1.3],\n",
       "       [ 5.6,  3. ,  4.1,  1.3],\n",
       "       [ 5.5,  2.5,  4. ,  1.3],\n",
       "       [ 5.5,  2.6,  4.4,  1.2],\n",
       "       [ 6.1,  3. ,  4.6,  1.4],\n",
       "       [ 5.8,  2.6,  4. ,  1.2],\n",
       "       [ 5. ,  2.3,  3.3,  1. ],\n",
       "       [ 5.6,  2.7,  4.2,  1.3],\n",
       "       [ 5.7,  3. ,  4.2,  1.2],\n",
       "       [ 5.7,  2.9,  4.2,  1.3],\n",
       "       [ 6.2,  2.9,  4.3,  1.3],\n",
       "       [ 5.1,  2.5,  3. ,  1.1],\n",
       "       [ 5.7,  2.8,  4.1,  1.3],\n",
       "       [ 6.3,  3.3,  6. ,  2.5],\n",
       "       [ 5.8,  2.7,  5.1,  1.9],\n",
       "       [ 7.1,  3. ,  5.9,  2.1],\n",
       "       [ 6.3,  2.9,  5.6,  1.8],\n",
       "       [ 6.5,  3. ,  5.8,  2.2],\n",
       "       [ 7.6,  3. ,  6.6,  2.1],\n",
       "       [ 4.9,  2.5,  4.5,  1.7],\n",
       "       [ 7.3,  2.9,  6.3,  1.8],\n",
       "       [ 6.7,  2.5,  5.8,  1.8],\n",
       "       [ 7.2,  3.6,  6.1,  2.5],\n",
       "       [ 6.5,  3.2,  5.1,  2. ],\n",
       "       [ 6.4,  2.7,  5.3,  1.9],\n",
       "       [ 6.8,  3. ,  5.5,  2.1],\n",
       "       [ 5.7,  2.5,  5. ,  2. ],\n",
       "       [ 5.8,  2.8,  5.1,  2.4],\n",
       "       [ 6.4,  3.2,  5.3,  2.3],\n",
       "       [ 6.5,  3. ,  5.5,  1.8],\n",
       "       [ 7.7,  3.8,  6.7,  2.2],\n",
       "       [ 7.7,  2.6,  6.9,  2.3],\n",
       "       [ 6. ,  2.2,  5. ,  1.5],\n",
       "       [ 6.9,  3.2,  5.7,  2.3],\n",
       "       [ 5.6,  2.8,  4.9,  2. ],\n",
       "       [ 7.7,  2.8,  6.7,  2. ],\n",
       "       [ 6.3,  2.7,  4.9,  1.8],\n",
       "       [ 6.7,  3.3,  5.7,  2.1],\n",
       "       [ 7.2,  3.2,  6. ,  1.8],\n",
       "       [ 6.2,  2.8,  4.8,  1.8],\n",
       "       [ 6.1,  3. ,  4.9,  1.8],\n",
       "       [ 6.4,  2.8,  5.6,  2.1],\n",
       "       [ 7.2,  3. ,  5.8,  1.6],\n",
       "       [ 7.4,  2.8,  6.1,  1.9],\n",
       "       [ 7.9,  3.8,  6.4,  2. ],\n",
       "       [ 6.4,  2.8,  5.6,  2.2],\n",
       "       [ 6.3,  2.8,  5.1,  1.5],\n",
       "       [ 6.1,  2.6,  5.6,  1.4],\n",
       "       [ 7.7,  3. ,  6.1,  2.3],\n",
       "       [ 6.3,  3.4,  5.6,  2.4],\n",
       "       [ 6.4,  3.1,  5.5,  1.8],\n",
       "       [ 6. ,  3. ,  4.8,  1.8],\n",
       "       [ 6.9,  3.1,  5.4,  2.1],\n",
       "       [ 6.7,  3.1,  5.6,  2.4],\n",
       "       [ 6.9,  3.1,  5.1,  2.3],\n",
       "       [ 5.8,  2.7,  5.1,  1.9],\n",
       "       [ 6.8,  3.2,  5.9,  2.3],\n",
       "       [ 6.7,  3.3,  5.7,  2.5],\n",
       "       [ 6.7,  3. ,  5.2,  2.3],\n",
       "       [ 6.3,  2.5,  5. ,  1.9],\n",
       "       [ 6.5,  3. ,  5.2,  2. ],\n",
       "       [ 6.2,  3.4,  5.4,  2.3],\n",
       "       [ 5.9,  3. ,  5.1,  1.8]])"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = iris_data[\"data\"]\n",
    "X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.2,  0.2,  0.2,  0.2,  0.2,  0.4,  0.3,  0.2,  0.2,  0.1,  0.2,\n",
       "        0.2,  0.1,  0.1,  0.2,  0.4,  0.4,  0.3,  0.3,  0.3,  0.2,  0.4,\n",
       "        0.2,  0.5,  0.2,  0.2,  0.4,  0.2,  0.2,  0.2,  0.2,  0.4,  0.1,\n",
       "        0.2,  0.1,  0.2,  0.2,  0.1,  0.2,  0.2,  0.3,  0.3,  0.2,  0.6,\n",
       "        0.4,  0.3,  0.2,  0.2,  0.2,  0.2,  1.4,  1.5,  1.5,  1.3,  1.5,\n",
       "        1.3,  1.6,  1. ,  1.3,  1.4,  1. ,  1.5,  1. ,  1.4,  1.3,  1.4,\n",
       "        1.5,  1. ,  1.5,  1.1,  1.8,  1.3,  1.5,  1.2,  1.3,  1.4,  1.4,\n",
       "        1.7,  1.5,  1. ,  1.1,  1. ,  1.2,  1.6,  1.5,  1.6,  1.5,  1.3,\n",
       "        1.3,  1.3,  1.2,  1.4,  1.2,  1. ,  1.3,  1.2,  1.3,  1.3,  1.1,\n",
       "        1.3,  2.5,  1.9,  2.1,  1.8,  2.2,  2.1,  1.7,  1.8,  1.8,  2.5,\n",
       "        2. ,  1.9,  2.1,  2. ,  2.4,  2.3,  1.8,  2.2,  2.3,  1.5,  2.3,\n",
       "        2. ,  2. ,  1.8,  2.1,  1.8,  1.8,  1.8,  2.1,  1.6,  1.9,  2. ,\n",
       "        2.2,  1.5,  1.4,  2.3,  2.4,  1.8,  1.8,  2.1,  2.4,  2.3,  1.9,\n",
       "        2.3,  2.5,  2.3,  1.9,  2. ,  2.3,  1.8])"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X[:,-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.5.2"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "widgets": {
   "state": {},
   "version": "1.1.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}