week02/Lab02.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Basic Python\n",
    "##### Keywords: data type,function, loop, try/except, etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  python cheat sheet (cont.)\n",
    "1. 'Markdown' format to type formula\n",
    "1. shift + return   compile\n",
    "1. esc + dd  delete a cell\n",
    "1. esc + r + y  clear printed result\n",
    "1. [*]  in front of a cell means 'running' \n",
    "1. use Tab to complete a variable/function\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First -1\n",
      "Second 123\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    astr = 'Hello Bob'\n",
    "    istr = int(astr)\n",
    "except:\n",
    "    istr = -1\n",
    "\n",
    "print('First', istr)\n",
    "\n",
    "try:\n",
    "    astr = '123'\n",
    "    istr = int(astr)\n",
    "except:\n",
    "    iter = -1\n",
    "    \n",
    "    \n",
    "print('Second', istr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    print(x)\n",
    "except NameError:\n",
    "    x = -1\n",
    "    \n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "unexpected indent (<ipython-input-6-e446b8d3c4ed>, line 4)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-6-e446b8d3c4ed>\"\u001b[0;36m, line \u001b[0;32m4\u001b[0m\n\u001b[0;31m    print('x = ', x)\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m unexpected indent\n"
     ]
    }
   ],
   "source": [
    "# indentation error\n",
    "# try does not work\n",
    "try:\n",
    "    x = 42\n",
    "     print('x = ', x)#indentation \n",
    "except:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "unexpected indent (<ipython-input-5-19fd96504268>, line 3)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-5-19fd96504268>\"\u001b[0;36m, line \u001b[0;32m3\u001b[0m\n\u001b[0;31m    print('x = ', x)\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m unexpected indent\n"
     ]
    }
   ],
   "source": [
    "if x > 1 :\n",
    "    print('More than one')\n",
    "    if x < 100 : \n",
    "        print('Less than 100') \n",
    "        \n",
    "print('All done')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "unexpected indent (<ipython-input-6-14f026d02864>, line 3)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-6-14f026d02864>\"\u001b[0;36m, line \u001b[0;32m3\u001b[0m\n\u001b[0;31m    print('x = ', x)\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m unexpected indent\n"
     ]
    }
   ],
   "source": [
    "# cannot try structural errors.\n",
    "try:\n",
    "    x = 42\n",
    "     print('x = ', x)\n",
    "except IndentationError:\n",
    "    print('IndentationError')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "\n",
    "#string summation\n",
    "'123'+'456'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def type_print(x):\n",
    "    print('value = ', x, ',\\n type = ', type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "value =  100.111 ,\n",
      " type =  <class 'float'>\n",
      "value =  100.0 ,\n",
      " type =  <class 'float'>\n",
      "value =  100.0 ,\n",
      " type =  <class 'float'>\n",
      "value =  100 ,\n",
      " type =  <class 'int'>\n",
      "value =  100.0 ,\n",
      " type =  <class 'float'>\n",
      "value =  100 ,\n",
      " type =  <class 'int'>\n",
      "value =  100.0 ,\n",
      " type =  <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "listx = [100.111, 100., float(100), 100, 1e2, 100//1, 100/1]\n",
    "\n",
    "for x in listx:\n",
    "    type_print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# function change input value?\n",
    "# z-variable default\n",
    "# all defaults last variable(s)\n",
    "# ordering\n",
    "def sum(x,y, z=0,w = 0,ifprint = False):\n",
    "    g = x+y+z+w**2\n",
    "    if(ifprint):\n",
    "        print(g)\n",
    "    return g\n",
    "\n",
    "x = 1\n",
    "y = 2\n",
    "h = sum(x,y,w = -1,ifprint = True)\n",
    "print(h)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "while 5\n",
      "while 4\n",
      "while 3\n",
      "while 2\n",
      "while 1\n",
      "outside while: 0\n"
     ]
    }
   ],
   "source": [
    "# while\n",
    "n = 5\n",
    "while(n>0):  # need to terminate\n",
    "    print('while', n)\n",
    "    n = n-1\n",
    "\n",
    "print('outside while:', n)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inside for:  1\n",
      "i+2:  3\n",
      "inside for:  2\n",
      "i+2:  4\n",
      "inside for:  3\n",
      "i+2:  5\n",
      "inside for:  4\n",
      "i+2:  6\n",
      "i outside loop:  6\n",
      "counter outside loop:  4\n"
     ]
    }
   ],
   "source": [
    "# for loop, changes values?\n",
    "counter = 0\n",
    "for i in [1,2,3,4] :\n",
    "    print('inside for: ', i)\n",
    "    i = i+2\n",
    "    print('i+2: ',i)\n",
    "    counter += 1\n",
    "\n",
    "# what's i?\n",
    "print('i outside loop: ',i)\n",
    "print('counter outside loop: ',counter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i outside loop:  5\n",
      "counter outside loop:  2\n"
     ]
    }
   ],
   "source": [
    "# for loop, changes values?\n",
    "counter = 0\n",
    "i = 1\n",
    "while(i<=4):\n",
    "    i = i+2\n",
    "    counter += 1\n",
    "\n",
    "# what's i?\n",
    "print('i outside loop: ',i)\n",
    "print('counter outside loop: ',counter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "2\n",
      "4\n",
      "6\n",
      "8\n",
      "\n",
      "\n",
      "0\n",
      "3\n",
      "6\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "# built-in function range\n",
    "#for i in range(5): # 0-4\n",
    "#    print(i)\n",
    "\n",
    "for i in range(0,10,2): # 0-9, every 2 steps\n",
    "    print(i)\n",
    "    \n",
    "print('\\n')\n",
    "for i in range(0,10,3): # 0-9, every 3 steps\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "\n",
    "# use lambda to define function quickly\n",
    "# this is saying g maps x to x**2\n",
    "g = lambda x: x**2\n",
    "g(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 273,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#use built-in help & dir\n",
    "#dir(range)\n",
    "#help(range.count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['HHTT', 'HT']\n",
      "['wh', 2]\n",
      "1\n",
      "outside\n"
     ]
    }
   ],
   "source": [
    "x = 'HHTT'\n",
    "lx = [[x,'HT'],['wh',2],1,'outside']\n",
    "for le in lx:\n",
    "    print(le)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ith 0 H\n",
      "ith 2 T\n"
     ]
    }
   ],
   "source": [
    "for i in range(0,len(x),2):\n",
    "    print('ith',i,x[i])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "kth 0 H\n",
      "kth 2 T\n"
     ]
    }
   ],
   "source": [
    "k = 0\n",
    "while(k<len(x)):\n",
    "    print('kth',k,x[k])\n",
    "    k += 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "range(0, 10)\n"
     ]
    }
   ],
   "source": [
    "lst = list(range(10))\n",
    "print(lst)\n",
    "print(range(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 01\n",
    "\n",
    "We want to set up flipping coin random variable and related event here\n",
    "## We need ingredients:\n",
    "\n",
    "1. sample space: $\\Omega$\n",
    "1. random variable $X:\\Omega \\rightarrow \\mathbb{R}$\n",
    "1. probability function $f$\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#define sample space of flipping one coin:\n",
    "SS = ['H','T']\n",
    "\n",
    "#define random variable X on the sample space:\n",
    "# X(H) = 1, X(T) = 0\n",
    "def rand_X(s):\n",
    "    if(s == 'H'):\n",
    "        return 1\n",
    "    else:\n",
    "        return 0\n",
    "\n",
    "#define probability mass function f associated with X\n",
    "#probability getting a head = 0.7\n",
    "\n",
    "def pmf_X(s):\n",
    "    if(s == 1):\n",
    "        return 0.7\n",
    "    else:\n",
    "        return 0.3\n",
    "\n",
    "#what is the probability I flip the coin 3 times and get HTH\n",
    "tosses = 'HTH'\n",
    "prob = 1\n",
    "for i in tosses:\n",
    "    prob *= pmf_X(rand_X(i))\n",
    "    \n",
    "print('tosses = ', tosses, ', probability = ', prob)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## coin flipping function\n",
    "\n",
    "The function should be able to:\n",
    "1. compute probability\n",
    "1. deal with error input or corner cases\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def prob(tosses):\n",
    "    prob = 1\n",
    "    # assume if does not flip at all, the probability is 1\n",
    "\n",
    "    if(len(tosses) == 0):\n",
    "        return 1;\n",
    "    \n",
    "    for i in tosses:\n",
    "    #Other than head or tail, any symbol is not acceptable\n",
    "        if(i not in SS):\n",
    "            return 0;\n",
    "        prob *= pmf_X(rand_X(i))\n",
    "    print('tosses = ', tosses, ', probability = ', prob)\n",
    "    return prob\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# numpy\n",
    "must import to be used"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n",
      "(2, 3)\n",
      "[[1 2 3]\n",
      " [4 5 6]] \n",
      "\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "import numpy as np #np for short\n",
    "a = np.array([[1,2,3],[4,5,6]])\n",
    "print(a)\n",
    "print(a.shape)\n",
    "\n",
    "print(a,'\\n')\n",
    "print(a[0][0])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.  2.  3.]\n",
      " [ 4.  5.  6.]]\n",
      "[[7 8 9]\n",
      " [2 3 4]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1,2,3],[4,5,6]], float)\n",
    "print(a)\n",
    "\n",
    "b = np.array([[7,8,9],[2,3,4]], dtype = int)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Let c = a, c=\n",
      " [[ 1.  2.]\n",
      " [ 4.  5.]]\n",
      "before modify c, a = \n",
      " [[ 1.  2.]\n",
      " [ 4.  5.]]\n",
      "after change c, c =\n",
      " [[ 7.  2.]\n",
      " [ 4.  5.]]\n",
      "after change c, a =\n",
      " [[ 7.  2.]\n",
      " [ 4.  5.]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1,2],[4,5]], float)\n",
    "\n",
    "c = a\n",
    "print('Let c = a, c=\\n', c)\n",
    "print('before modify c, a = \\n', a)\n",
    "\n",
    "# if you change value of c a changes as well\n",
    "c[0][0] = 7\n",
    "print('after change c, c =\\n',c)\n",
    "print('after change c, a =\\n', a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Let c = a.copy(), c=\n",
      " [[ 1.  2.]\n",
      " [ 4.  5.]]\n",
      "before modify c, a = \n",
      " [[ 1.  2.]\n",
      " [ 4.  5.]]\n",
      "after change c, c =\n",
      " [[ 7.  2.]\n",
      " [ 4.  5.]]\n",
      "after change c, a =\n",
      " [[ 1.  2.]\n",
      " [ 4.  5.]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1,2],[4,5]], float)\n",
    "\n",
    "c = a.copy()\n",
    "print('Let c = a.copy(), c=\\n', c)\n",
    "print('before modify c, a = \\n', a)\n",
    "\n",
    "# if you change value of c, a does not change this time\n",
    "c[0][0] = 7\n",
    "print('after change c, c =\\n',c)\n",
    "print('after change c, a =\\n', a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "b = np.arange(10)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function reshape in module numpy.core.fromnumeric:\n",
      "\n",
      "reshape(a, newshape, order='C')\n",
      "    Gives a new shape to an array without changing its data.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    a : array_like\n",
      "        Array to be reshaped.\n",
      "    newshape : int or tuple of ints\n",
      "        The new shape should be compatible with the original shape. If\n",
      "        an integer, then the result will be a 1-D array of that length.\n",
      "        One shape dimension can be -1. In this case, the value is\n",
      "        inferred from the length of the array and remaining dimensions.\n",
      "    order : {'C', 'F', 'A'}, optional\n",
      "        Read the elements of `a` using this index order, and place the\n",
      "        elements into the reshaped array using this index order.  'C'\n",
      "        means to read / write the elements using C-like index order,\n",
      "        with the last axis index changing fastest, back to the first\n",
      "        axis index changing slowest. 'F' means to read / write the\n",
      "        elements using Fortran-like index order, with the first index\n",
      "        changing fastest, and the last index changing slowest. Note that\n",
      "        the 'C' and 'F' options take no account of the memory layout of\n",
      "        the underlying array, and only refer to the order of indexing.\n",
      "        'A' means to read / write the elements in Fortran-like index\n",
      "        order if `a` is Fortran *contiguous* in memory, C-like order\n",
      "        otherwise.\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    reshaped_array : ndarray\n",
      "        This will be a new view object if possible; otherwise, it will\n",
      "        be a copy.  Note there is no guarantee of the *memory layout* (C- or\n",
      "        Fortran- contiguous) of the returned array.\n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    ndarray.reshape : Equivalent method.\n",
      "    \n",
      "    Notes\n",
      "    -----\n",
      "    It is not always possible to change the shape of an array without\n",
      "    copying the data. If you want an error to be raise if the data is copied,\n",
      "    you should assign the new shape to the shape attribute of the array::\n",
      "    \n",
      "     >>> a = np.zeros((10, 2))\n",
      "     # A transpose make the array non-contiguous\n",
      "     >>> b = a.T\n",
      "     # Taking a view makes it possible to modify the shape without modifying\n",
      "     # the initial object.\n",
      "     >>> c = b.view()\n",
      "     >>> c.shape = (20)\n",
      "     AttributeError: incompatible shape for a non-contiguous array\n",
      "    \n",
      "    The `order` keyword gives the index ordering both for *fetching* the values\n",
      "    from `a`, and then *placing* the values into the output array.\n",
      "    For example, let's say you have an array:\n",
      "    \n",
      "    >>> a = np.arange(6).reshape((3, 2))\n",
      "    >>> a\n",
      "    array([[0, 1],\n",
      "           [2, 3],\n",
      "           [4, 5]])\n",
      "    \n",
      "    You can think of reshaping as first raveling the array (using the given\n",
      "    index order), then inserting the elements from the raveled array into the\n",
      "    new array using the same kind of index ordering as was used for the\n",
      "    raveling.\n",
      "    \n",
      "    >>> np.reshape(a, (2, 3)) # C-like index ordering\n",
      "    array([[0, 1, 2],\n",
      "           [3, 4, 5]])\n",
      "    >>> np.reshape(np.ravel(a), (2, 3)) # equivalent to C ravel then C reshape\n",
      "    array([[0, 1, 2],\n",
      "           [3, 4, 5]])\n",
      "    >>> np.reshape(a, (2, 3), order='F') # Fortran-like index ordering\n",
      "    array([[0, 4, 3],\n",
      "           [2, 1, 5]])\n",
      "    >>> np.reshape(np.ravel(a, order='F'), (2, 3), order='F')\n",
      "    array([[0, 4, 3],\n",
      "           [2, 1, 5]])\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    >>> a = np.array([[1,2,3], [4,5,6]])\n",
      "    >>> np.reshape(a, 6)\n",
      "    array([1, 2, 3, 4, 5, 6])\n",
      "    >>> np.reshape(a, 6, order='F')\n",
      "    array([1, 4, 2, 5, 3, 6])\n",
      "    \n",
      "    >>> np.reshape(a, (3,-1))       # the unspecified value is inferred to be 2\n",
      "    array([[1, 2],\n",
      "           [3, 4],\n",
      "           [5, 6]])\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# help(reshape) does not work! need to use modulo name np as we : import numpy as np\n",
    "help(np.reshape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b=\n",
      " [[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]]\n",
      "matrix to array:\n",
      " [ 0  1  2  3  4  5  6  7  8  9 10 11]\n",
      "Transpose of matrix:\n",
      " [[ 0  4  8]\n",
      " [ 1  5  9]\n",
      " [ 2  6 10]\n",
      " [ 3  7 11]]\n"
     ]
    }
   ],
   "source": [
    "b = np.arange(12).reshape(3,4)\n",
    "print('b=\\n',b)\n",
    "\n",
    "print('matrix to array:\\n', b.flatten()) #does not change c\n",
    "print('Transpose of matrix:\\n', b.T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s =  [1 2 3] ,  shape =  (3,)\n",
      "st =\n",
      " [[1]\n",
      " [2]\n",
      " [3]] ,\n",
      "shape = \n",
      " (3, 1)\n"
     ]
    }
   ],
   "source": [
    "s  = np.array([1,2,3])\n",
    "st = s.reshape(-1,1)\n",
    "print('s = ',s, ',  shape = ', s.shape)# 1-d\n",
    "print('st =\\n',st, ',\\nshape = \\n', st.shape) # 2-d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "value = \n",
      " [1] , type = \n",
      " <class 'numpy.ndarray'>\n",
      "value = \n",
      " [2] , type = \n",
      " <class 'numpy.ndarray'>\n",
      "value = \n",
      " [3] , type = \n",
      " <class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "for i in st:\n",
    "    type_print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0 th item 1\n",
      "1 0 th item 2\n",
      "2 0 th item 3\n"
     ]
    }
   ],
   "source": [
    "for r in range(0,st.shape[0]):\n",
    "    for col in range(0,st.shape[1]):\n",
    "        print(r,col,'th item',st[r][col])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1],\n",
       "       [2, 3],\n",
       "       [4, 5]])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# array iteration\n",
    "b = np.arange(6).reshape(3,2)"
   ]
  },
  {
   "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.6.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}