S07-Numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The Python Mega Course: Build 10 Real World Applications\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook contains the source code for the video lectures of Section 7 of [The Python Mega Course: Build 10 Real World Applciations](https://www.udemy.com/the-python-mega-course/?couponCode=GITHEADSECTION)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Section 7: Numpy\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Lecture 105:** [What is Numpy](https://www.udemy.com/the-python-mega-course/learn/v4/t/lecture/5163296?start=0)\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy is the fundamental package for scientific computing with Python. It provides a way to store and manipulate big arrays of numeric values in a more efficient way than standard Python lists. Libraries such as pandas or opencv are based on numpy. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The central object of numpy is the numpy array. Here's an example of how to create a numpy array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,\n",
       "       17, 18, 19, 20, 21, 22, 23, 24, 25, 26])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy\n",
    "n = numpy.arange(27)\n",
    "n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  1,  2],\n",
       "        [ 3,  4,  5],\n",
       "        [ 6,  7,  8]],\n",
       "\n",
       "       [[ 9, 10, 11],\n",
       "        [12, 13, 14],\n",
       "        [15, 16, 17]],\n",
       "\n",
       "       [[18, 19, 20],\n",
       "        [21, 22, 23],\n",
       "        [24, 25, 26]]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#you can change its structure\n",
    "n.reshape(3,3,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[12, 13],\n",
       "       [14, 15],\n",
       "       [16, 17]])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#another way to create a numpy array is from Python lists\n",
    "m = numpy.asarray([[12,13],[14,15],[16,17]])\n",
    "m"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Lecture 106:** [Installing the OpenCV Library](https://www.udemy.com/the-python-mega-course/learn/v4/t/lecture/5940430?start=0)\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next lecture covers opencv - an image processing library that is based on numpy. To install it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "pip install opencv-python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If that doesn't work on Mac, try brew install opencv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Lecture 107:** [Imagex to Numpy and Vice-versa](https://www.udemy.com/the-python-mega-course/learn/v4/t/lecture/5941086?start=0)\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For this section you will need an image file. [In this link](http://pythonhow.com/data/python-mega-course-data/section_numpy/smallgray.png) you can get a small image file. Once you open the link in your browser, right click and go to *Save Page* as to save it as an image and put it in the same folder with this script."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#import opencv\n",
    "import cv2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[187, 158, 104, 121, 143],\n",
       "       [198, 125, 255, 255, 147],\n",
       "       [209, 134, 255,  97, 182]], dtype=uint8)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#convert the grayscale version of the image to a numpy array\n",
    "im_g = cv2.imread(\"smallgray.png\", 0)\n",
    "im_g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[187, 158, 104, 121, 143],\n",
       "       [198, 125, 255, 255, 147],\n",
       "       [209, 134, 255,  97, 182]], dtype=uint8)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#convert BGR (color) version the image to a numpy array\n",
    "im_g = cv2.imread(\"smallgray.png\", 2)\n",
    "im_g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#convert a numpy array into an image\n",
    "cv2.imwrite(\"newsmallgray.png\", im_g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There should be a newsmallgray.png file in your current directory now."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Lecture 108:** [Indexing, Slicing, and Iterating](https://www.udemy.com/the-python-mega-course/learn/v4/t/lecture/5163302?start=0)\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets suppose we have the following numpy array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[187, 158, 104, 121, 143],\n",
       "       [198, 125, 255, 255, 147],\n",
       "       [209, 134, 255,  97, 182]], dtype=uint8)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "im_g = cv2.imread(\"smallgray.png\", 2)\n",
    "im_g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[104, 121],\n",
       "       [255, 255]], dtype=uint8)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#intersection of rows with index 0 to 1 and columns with index 2 to 3\n",
    "im_g[0:2,2:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[104, 121],\n",
       "       [255, 255],\n",
       "       [255,  97]], dtype=uint8)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#intersection of all rows with columns with index 2 to 3\n",
    "im_g[:,2:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "182"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#cell with row index 2 and column index 4\n",
    "im_g[2,4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[187 158 104 121 143]\n",
      "[198 125 255 255 147]\n",
      "[209 134 255  97 182]\n"
     ]
    }
   ],
   "source": [
    "#looping over the array rows\n",
    "for i in im_g:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[187 198 209]\n",
      "[158 125 134]\n",
      "[104 255 255]\n",
      "[121 255  97]\n",
      "[143 147 182]\n"
     ]
    }
   ],
   "source": [
    "#looping over the array columns\n",
    "for i in im_g.T:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "187\n",
      "158\n",
      "104\n",
      "121\n",
      "143\n",
      "198\n",
      "125\n",
      "255\n",
      "255\n",
      "147\n",
      "209\n",
      "134\n",
      "255\n",
      "97\n",
      "182\n"
     ]
    }
   ],
   "source": [
    "#looping over the array cells\n",
    "for i in im_g.flat:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Lecture 109:** [Stacking and Splitting](https://www.udemy.com/the-python-mega-course/learn/v4/t/lecture/5163304?start=0)\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets again suppose we have the following numpy array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[187, 158, 104, 121, 143],\n",
       "       [198, 125, 255, 255, 147],\n",
       "       [209, 134, 255,  97, 182]], dtype=uint8)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "im_g = cv2.imread(\"smallgray.png\", 2)\n",
    "im_g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[187 158 104 121 143 187 158 104 121 143 187 158 104 121 143]\n",
      " [198 125 255 255 147 198 125 255 255 147 198 125 255 255 147]\n",
      " [209 134 255  97 182 209 134 255  97 182 209 134 255  97 182]]\n"
     ]
    }
   ],
   "source": [
    "#stacking three arrays horizontally\n",
    "ims = numpy.hstack((im_g, im_g, im_g))\n",
    "print(ims)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[187 158 104 121 143]\n",
      " [198 125 255 255 147]\n",
      " [209 134 255  97 182]\n",
      " [187 158 104 121 143]\n",
      " [198 125 255 255 147]\n",
      " [209 134 255  97 182]\n",
      " [187 158 104 121 143]\n",
      " [198 125 255 255 147]\n",
      " [209 134 255  97 182]]\n"
     ]
    }
   ],
   "source": [
    "#stacking three arrays vertically\n",
    "ims = numpy.vstack((im_g, im_g, im_g))\n",
    "print(ims)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[array([[187],\n",
      "       [198],\n",
      "       [209],\n",
      "       [187],\n",
      "       [198],\n",
      "       [209],\n",
      "       [187],\n",
      "       [198],\n",
      "       [209]], dtype=uint8), array([[158],\n",
      "       [125],\n",
      "       [134],\n",
      "       [158],\n",
      "       [125],\n",
      "       [134],\n",
      "       [158],\n",
      "       [125],\n",
      "       [134]], dtype=uint8), array([[104],\n",
      "       [255],\n",
      "       [255],\n",
      "       [104],\n",
      "       [255],\n",
      "       [255],\n",
      "       [104],\n",
      "       [255],\n",
      "       [255]], dtype=uint8), array([[121],\n",
      "       [255],\n",
      "       [ 97],\n",
      "       [121],\n",
      "       [255],\n",
      "       [ 97],\n",
      "       [121],\n",
      "       [255],\n",
      "       [ 97]], dtype=uint8), array([[143],\n",
      "       [147],\n",
      "       [182],\n",
      "       [143],\n",
      "       [147],\n",
      "       [182],\n",
      "       [143],\n",
      "       [147],\n",
      "       [182]], dtype=uint8)]\n"
     ]
    }
   ],
   "source": [
    "#splitting horizontally into 5 numpy arrays\n",
    "lst = numpy.hsplit(ims, 5)\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[array([[187, 158, 104, 121, 143],\n",
      "       [198, 125, 255, 255, 147],\n",
      "       [209, 134, 255,  97, 182]], dtype=uint8), array([[187, 158, 104, 121, 143],\n",
      "       [198, 125, 255, 255, 147],\n",
      "       [209, 134, 255,  97, 182]], dtype=uint8), array([[187, 158, 104, 121, 143],\n",
      "       [198, 125, 255, 255, 147],\n",
      "       [209, 134, 255,  97, 182]], dtype=uint8)]\n"
     ]
    }
   ],
   "source": [
    "#splitting vertically into 3 numpy arrays\n",
    "lst = numpy.vsplit(ims, 3)\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[187, 158, 104, 121, 143],\n",
       "       [198, 125, 255, 255, 147],\n",
       "       [209, 134, 255,  97, 182]], dtype=uint8)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#access the first array of the big numpy array\n",
    "lst[0]"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}