sums_tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Welcom To Jupyter Notebook Guys!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jupyter notebook is very convenient for a python developer to test their code.\n",
    "Come and be one of us!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Jupyter  shortcuts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "up/down arrow keys to move, enter to edit\n",
    "\n",
    "Esc to exit edit mode\n",
    "\n",
    "Shift + enter to run code\n",
    "\n",
    "a/b to add cell above/below\n",
    "\n",
    "dd to delete cell\n",
    "\n",
    "1/2/3... to add comment\n",
    "\n",
    "press h for more shortcuts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import cv2\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "img = cv2.imread('images/duckietown.jpg')\n",
    "dst1 = cv2.cvtColor(img,cv2.COLOR_BGR2RGB)\n",
    "plt.subplot(121), plt.imshow(dst1, cmap = 'brg')\n",
    "plt.title('Original Image')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Basic Syntax "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I like to eat an apple\n"
     ]
    }
   ],
   "source": [
    "print(\"I like to eat an apple\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Duckietown!\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello Duckietown!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "x=1\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for i in range(1, 10):\n",
    "    print i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "B\n"
     ]
    }
   ],
   "source": [
    "x=['B', 'L', 'F', 'F']\n",
    "print(x[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LFF\n"
     ]
    }
   ],
   "source": [
    "route = \"\"\n",
    "for i in x:\n",
    "    if i != 'B':\n",
    "        route += i\n",
    "print route"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x doesn't equal 1\n"
     ]
    }
   ],
   "source": [
    "x=0\n",
    "if x==1 :\n",
    "    print(\"x equals 1\")\n",
    "else : \n",
    "    print(\"x doesn't equal 1\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Playing around with Numpy & Scipy  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numpy & Scipy are commonly used library for math and science purpose\n",
    "### They are powerful and will save us a lot of trouble"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## import lib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy as sp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## array declaration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "(3,) <type 'numpy.ndarray'> <type 'numpy.int64'>\n"
     ]
    }
   ],
   "source": [
    "x = np.array([1, 2, 3])\n",
    "for i in range(x.shape[0]) :\n",
    "    print x[i]\n",
    "print x.shape, type(x), type(x[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "(2, 3) <type 'numpy.ndarray'> <type 'numpy.ndarray'> <type 'numpy.int64'>\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "for i in range(x.shape[0]) :\n",
    "    for j in range(x.shape[1]) :\n",
    "        print x[i][j]\n",
    "print x.shape, type(x), type(x[0]), type(x[0][0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.  0.  0.  0.]\n",
      " [ 0.  0.  0.  0.]\n",
      " [ 0.  0.  0.  0.]]\n"
     ]
    }
   ],
   "source": [
    "x = np.zeros((3, 4))\n",
    "print x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.  1.  1.  1.]\n",
      " [ 1.  1.  1.  1.]\n",
      " [ 1.  1.  1.  1.]]\n"
     ]
    }
   ],
   "source": [
    "x = np.ones((3, 4))\n",
    "print x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10 15 20 25]\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(10, 30 ,5)\n",
    "print x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## array manipulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]\n",
      "[[ 0  1  2  3  4]\n",
      " [ 5  6  7  8  9]\n",
      " [10 11 12 13 14]]\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(15)\n",
    "print x\n",
    "x = x.reshape(3,5)\n",
    "print x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## visualization (matplotlib) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from matplotlib import pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "plt.plot([1,2,3], [1,2,3], 'ro')\n",
    "#toggle axis\n",
    "#plt.axis([0, 5, 0, 5])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3  4  5  6  7  8  9]\n",
      " [10 11 12 13 14 15 16 17 18 19]\n",
      " [20 21 22 23 24 25 26 27 28 29]\n",
      " [30 31 32 33 34 35 36 37 38 39]\n",
      " [40 41 42 43 44 45 46 47 48 49]\n",
      " [50 51 52 53 54 55 56 57 58 59]\n",
      " [60 61 62 63 64 65 66 67 68 69]\n",
      " [70 71 72 73 74 75 76 77 78 79]\n",
      " [80 81 82 83 84 85 86 87 88 89]\n",
      " [90 91 92 93 94 95 96 97 98 99]]\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(100).reshape(10,10)\n",
    "print x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "plt.matshow(x)\n",
    "#toggle for gray colormap\n",
    "plt.matshow(x, cmap=plt.cm.gray)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Let's use it to do our math homework! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculus "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from scipy import integrate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.333333333333\n",
      "3.70074341542e-15\n"
     ]
    }
   ],
   "source": [
    "def f(x) :\n",
    "    return x**2\n",
    "result, err = integrate.quad(f, 0, 1)\n",
    "print result\n",
    "print err"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# numpy meshgrid "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "nx, ny = (3,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = np.linspace(0, 1, nx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0. ,  0.5,  1. ])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "y = np.linspace(0, 1, ny)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.,  1.])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "xv, yv = np.meshgrid(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0. ,  0.5,  1. ],\n",
       "       [ 0. ,  0.5,  1. ]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "xv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.,  0.,  0.],\n",
       "       [ 1.,  1.,  1.]])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "yv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## example for function evaluation "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "x = np.arange(-5, 5, 0.1)\n",
    "y = np.arange(-5, 5, 0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ -5.00000000e+00  -4.90000000e+00  -4.80000000e+00  -4.70000000e+00\n",
      "   -4.60000000e+00  -4.50000000e+00  -4.40000000e+00  -4.30000000e+00\n",
      "   -4.20000000e+00  -4.10000000e+00  -4.00000000e+00  -3.90000000e+00\n",
      "   -3.80000000e+00  -3.70000000e+00  -3.60000000e+00  -3.50000000e+00\n",
      "   -3.40000000e+00  -3.30000000e+00  -3.20000000e+00  -3.10000000e+00\n",
      "   -3.00000000e+00  -2.90000000e+00  -2.80000000e+00  -2.70000000e+00\n",
      "   -2.60000000e+00  -2.50000000e+00  -2.40000000e+00  -2.30000000e+00\n",
      "   -2.20000000e+00  -2.10000000e+00  -2.00000000e+00  -1.90000000e+00\n",
      "   -1.80000000e+00  -1.70000000e+00  -1.60000000e+00  -1.50000000e+00\n",
      "   -1.40000000e+00  -1.30000000e+00  -1.20000000e+00  -1.10000000e+00\n",
      "   -1.00000000e+00  -9.00000000e-01  -8.00000000e-01  -7.00000000e-01\n",
      "   -6.00000000e-01  -5.00000000e-01  -4.00000000e-01  -3.00000000e-01\n",
      "   -2.00000000e-01  -1.00000000e-01  -1.77635684e-14   1.00000000e-01\n",
      "    2.00000000e-01   3.00000000e-01   4.00000000e-01   5.00000000e-01\n",
      "    6.00000000e-01   7.00000000e-01   8.00000000e-01   9.00000000e-01\n",
      "    1.00000000e+00   1.10000000e+00   1.20000000e+00   1.30000000e+00\n",
      "    1.40000000e+00   1.50000000e+00   1.60000000e+00   1.70000000e+00\n",
      "    1.80000000e+00   1.90000000e+00   2.00000000e+00   2.10000000e+00\n",
      "    2.20000000e+00   2.30000000e+00   2.40000000e+00   2.50000000e+00\n",
      "    2.60000000e+00   2.70000000e+00   2.80000000e+00   2.90000000e+00\n",
      "    3.00000000e+00   3.10000000e+00   3.20000000e+00   3.30000000e+00\n",
      "    3.40000000e+00   3.50000000e+00   3.60000000e+00   3.70000000e+00\n",
      "    3.80000000e+00   3.90000000e+00   4.00000000e+00   4.10000000e+00\n",
      "    4.20000000e+00   4.30000000e+00   4.40000000e+00   4.50000000e+00\n",
      "    4.60000000e+00   4.70000000e+00   4.80000000e+00   4.90000000e+00]]\n",
      "[[ -5.00000000e+00]\n",
      " [ -4.90000000e+00]\n",
      " [ -4.80000000e+00]\n",
      " [ -4.70000000e+00]\n",
      " [ -4.60000000e+00]\n",
      " [ -4.50000000e+00]\n",
      " [ -4.40000000e+00]\n",
      " [ -4.30000000e+00]\n",
      " [ -4.20000000e+00]\n",
      " [ -4.10000000e+00]\n",
      " [ -4.00000000e+00]\n",
      " [ -3.90000000e+00]\n",
      " [ -3.80000000e+00]\n",
      " [ -3.70000000e+00]\n",
      " [ -3.60000000e+00]\n",
      " [ -3.50000000e+00]\n",
      " [ -3.40000000e+00]\n",
      " [ -3.30000000e+00]\n",
      " [ -3.20000000e+00]\n",
      " [ -3.10000000e+00]\n",
      " [ -3.00000000e+00]\n",
      " [ -2.90000000e+00]\n",
      " [ -2.80000000e+00]\n",
      " [ -2.70000000e+00]\n",
      " [ -2.60000000e+00]\n",
      " [ -2.50000000e+00]\n",
      " [ -2.40000000e+00]\n",
      " [ -2.30000000e+00]\n",
      " [ -2.20000000e+00]\n",
      " [ -2.10000000e+00]\n",
      " [ -2.00000000e+00]\n",
      " [ -1.90000000e+00]\n",
      " [ -1.80000000e+00]\n",
      " [ -1.70000000e+00]\n",
      " [ -1.60000000e+00]\n",
      " [ -1.50000000e+00]\n",
      " [ -1.40000000e+00]\n",
      " [ -1.30000000e+00]\n",
      " [ -1.20000000e+00]\n",
      " [ -1.10000000e+00]\n",
      " [ -1.00000000e+00]\n",
      " [ -9.00000000e-01]\n",
      " [ -8.00000000e-01]\n",
      " [ -7.00000000e-01]\n",
      " [ -6.00000000e-01]\n",
      " [ -5.00000000e-01]\n",
      " [ -4.00000000e-01]\n",
      " [ -3.00000000e-01]\n",
      " [ -2.00000000e-01]\n",
      " [ -1.00000000e-01]\n",
      " [ -1.77635684e-14]\n",
      " [  1.00000000e-01]\n",
      " [  2.00000000e-01]\n",
      " [  3.00000000e-01]\n",
      " [  4.00000000e-01]\n",
      " [  5.00000000e-01]\n",
      " [  6.00000000e-01]\n",
      " [  7.00000000e-01]\n",
      " [  8.00000000e-01]\n",
      " [  9.00000000e-01]\n",
      " [  1.00000000e+00]\n",
      " [  1.10000000e+00]\n",
      " [  1.20000000e+00]\n",
      " [  1.30000000e+00]\n",
      " [  1.40000000e+00]\n",
      " [  1.50000000e+00]\n",
      " [  1.60000000e+00]\n",
      " [  1.70000000e+00]\n",
      " [  1.80000000e+00]\n",
      " [  1.90000000e+00]\n",
      " [  2.00000000e+00]\n",
      " [  2.10000000e+00]\n",
      " [  2.20000000e+00]\n",
      " [  2.30000000e+00]\n",
      " [  2.40000000e+00]\n",
      " [  2.50000000e+00]\n",
      " [  2.60000000e+00]\n",
      " [  2.70000000e+00]\n",
      " [  2.80000000e+00]\n",
      " [  2.90000000e+00]\n",
      " [  3.00000000e+00]\n",
      " [  3.10000000e+00]\n",
      " [  3.20000000e+00]\n",
      " [  3.30000000e+00]\n",
      " [  3.40000000e+00]\n",
      " [  3.50000000e+00]\n",
      " [  3.60000000e+00]\n",
      " [  3.70000000e+00]\n",
      " [  3.80000000e+00]\n",
      " [  3.90000000e+00]\n",
      " [  4.00000000e+00]\n",
      " [  4.10000000e+00]\n",
      " [  4.20000000e+00]\n",
      " [  4.30000000e+00]\n",
      " [  4.40000000e+00]\n",
      " [  4.50000000e+00]\n",
      " [  4.60000000e+00]\n",
      " [  4.70000000e+00]\n",
      " [  4.80000000e+00]\n",
      " [  4.90000000e+00]]\n"
     ]
    }
   ],
   "source": [
    "xx, yy = np.meshgrid(x, y, sparse = True)\n",
    "print xx\n",
    "print yy\n",
    "z = np.sin(xx*2+yy*2)/(xx*2+yy*2)\n",
    "h = plt.contourf(x, y, z)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.        ,  0.55555556,  1.11111111,  1.66666667,  2.22222222,\n",
       "        2.77777778,  3.33333333,  3.88888889,  4.44444444,  5.        ])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(0,5,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0. ,  0.5,  1. ,  1.5,  2. ,  2.5,  3. ,  3.5,  4. ,  4.5])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(0,5,0.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## unravel_index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### return value is row and col"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0, 0, 0, 1]), array([1, 2, 3, 0]))"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.unravel_index([1,2,3,4],(4,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0, 1, 1, 2]), array([1, 0, 1, 0]))"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.unravel_index([1,2,3,4],(4,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Check Point!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let's have some exciting challenge!!!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## 1. Use for loop to Print a multiplication table (from 1~9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# It should look like this \n",
    "# 1*1=1 1*2=2 . . .\n",
    "# 2*1=2 2*2=4 . . ."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hint : You should use two layer of for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, '*', 1, '=', 1)\n",
      "(2, '*', 2, '=', 4)\n",
      "(3, '*', 3, '=', 9)\n",
      "(4, '*', 4, '=', 16)\n",
      "(5, '*', 5, '=', 25)\n",
      "(6, '*', 6, '=', 36)\n",
      "(7, '*', 7, '=', 49)\n",
      "(8, '*', 8, '=', 64)\n"
     ]
    }
   ],
   "source": [
    "for i in range(1, 9):\n",
    "    print(i, '*', i, '=', i*i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Draw z = cos( x^2 + y^2 )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hint : We have done draw z = sin(x^2 + y^2)/(x^2 + y^2), just modify the code!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Step:\n",
    "    #1. import numpy & matplotlib.pyplot\n",
    "    #2. meshgrid the x, y\n",
    "    #3. use the result of meshgrid to draw"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}