Tutorial 4 - The Sequence.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <span style=\"color: #B40486\">BASIC PYTHON FOR RESEARCHERS</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_by_ [**_Megat Harun Al Rashid bin Megat Ahmad_**](https://www.researchgate.net/profile/Megat_Harun_Megat_Ahmad)  \n",
    "last updated: April 14, 2016"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-------\n",
    "## _<span style=\"color: #29088A\">4. The Sequence</span>_\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sequence is a type of data structure. It is similar to array. Each element of a sequence can be accessed according to its index. There are several type of sequences:\n",
    "1. Strings\n",
    "2. Lists\n",
    "3. Tuples\n",
    "4. Dictionaries\n",
    "5. Sets\n",
    "6. Frozen sets\n",
    "\n",
    "The most commonly used is lists, tuples and dictionaries, which we will explored here."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "### **_4.1 The list sequence_**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A $list$ can be constructed using the bracket `[]` with the elements/components of the $list$ separated by commas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n",
      "There's 5 elements in the list [1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "List_num = [1,2,3,4,5]\n",
    "print List_num\n",
    "E = len(List_num)\n",
    "print \"There's %d elements in the list %s\" % (E,List_num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Elements in a $list$ can be made of numbers, strings, a mixture of both or other type of sequences. Element can be accessed by specifying the element position in the $list$ (similar to accessing the strings, as discussed in Tutorial 2). The number of elements in $list$ can be known using the <span style=\"color: #0000FF\">$len$&#40;&#41;</span> function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "What is the word happy in Arabic?\n",
      "The answer is Rafa and it's starts with the capital letter R.\n"
     ]
    }
   ],
   "source": [
    "List_str = [\"Blythe\",\"Rafa\",\"Felicity\",\"Kiyoko\"]\n",
    "\n",
    "print \"What is the word happy in Arabic?\"\n",
    "print \"The answer is %s and it's starts with the capital letter %s.\" % \\\n",
    "(List_str[1],List_str[1][0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above example, the elements in $List$_$str$ $list$ is accessed by specifying the positional index (in square bracket after the variable name of the list) of the $list$ and after that the element of the strings is accessed by specifying a second bracketted index as strings is also a $list$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Acessed element of a $list$ can be operated (just like variable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"The Time Machine\" was first published in 1895 with \n",
      "\"The Shape of Things to Come\" published 38 years later.\n"
     ]
    }
   ],
   "source": [
    "List_mix = [\"The Time Machine\", 1895, \"The Invisible Man\", 1897, \\\n",
    "            \"The Shape of Things to Come\", 1933]\n",
    "print '\"%s\" was first published in %d with \\n\"%s\" published %d years \\\n",
    "later.' % (List_mix[0],List_mix[1],List_mix[4],List_mix[5]-List_mix[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <span style=\"color: #F5DA81; background-color: #610B4B\">Example 4.1</span>: The followings are some of the infamous implementations of Python programming language: _CPython_, _Cython_, _PyPy_, _IronPython_, _Jython_ and _Unladen Swallow_. Put this sequence in a list and rearrange the sequence according to your preferred implementations in a list that contains only three implementations. Print the new list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Cython', 'CPython', 'PyPy']\n"
     ]
    }
   ],
   "source": [
    "Python_Impl = ['CPython','Cython','PyPy','IronPython','Jython','Unladen Swallow']\n",
    "New_Python_Impl = [Python_Impl[1],Python_Impl[0],Python_Impl[2]]\n",
    "\n",
    "print New_Python_Impl\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <span style=\"color: #F5DA81; background-color: #610B4B\">Example 4.2</span>: From this list: ['Python','Java','C','Perl','Sed','Awk','Lisp','Ruby'], create back the original list of Python implementations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['CPython', 'Cython', 'PyPy', 'IronPython', 'Jython', 'Unladen Swallow']\n"
     ]
    }
   ],
   "source": [
    "PN = ['Python','Java','C','Perl','Sed','Awk','Lisp','Ruby']\n",
    "\n",
    "Pyth_ImplN = [PN[2]+PN[0],PN[2]+PN[0][1:],PN[0][:2]*2,\\\n",
    "              PN[6][1].upper()+PN[3][2]+PN[0][4:]+PN[0],\\\n",
    "              PN[1][0]+PN[0][1:],PN[7][1].upper()+PN[0][-1]+PN[3][-1]+\\\n",
    "              PN[1][1]+PN[4][-1]+PN[4][-2]+PN[0][-1]+' '+\\\n",
    "              PN[-2][-2].upper()+PN[-3][1]+PN[1][1]+PN[3][3]*2+\\\n",
    "              PN[0][-2]+PN[-3][1]]\n",
    "\n",
    "print Pyth_ImplN"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What we have seen are one-dimensional homogeneous and non-homogeneous $lists$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = [12,45,78,14,23]\n",
    "y = [\"Dickens\",\"Hardy\",\"Austen\",\"Steinbeck\"]\n",
    "Z = [3E8,'light',\"metre\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$List$ can also be multi-dimensional."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[12, 32], [43, 9]]\n",
      "[43, 9]\n",
      "32\n"
     ]
    }
   ],
   "source": [
    "# Homogeneous multi dimensional list (2D):\n",
    "\n",
    "# List_name[row][column]\n",
    "\n",
    "x2 = [[12,32],[43,9]]\n",
    "print x2\n",
    "print x2[1]              # Second row\n",
    "print x2[0][1]           # First row, second column"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In a matrix representation, this is:\n",
    "$$\\left( \\begin{array}{cc}\n",
    "12 & 32 \\\\\n",
    "43 & 9\\end{array} \\right)$$\n",
    "\n",
    "and to get the matrix determinant:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Determinant of x2 is -1268\n"
     ]
    }
   ],
   "source": [
    "# Matrix determinant\n",
    "\n",
    "det_x2 = x2[0][0]*x2[1][1]-x2[0][1]*x2[1][0]\n",
    "print \"Determinant of x2 is %d\" % det_x2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A multi-dimensional $list$ is actually $lists$ within $list$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.1, 0.2, 0.3, 0.4, 0.5], [0, 12, 34, 15, 1]]\n"
     ]
    }
   ],
   "source": [
    "x1 = [0.1,0.2,0.3,0.4,0.5]\n",
    "x2 = [0,12,34,15,1]\n",
    "x = [x1,x2]\n",
    "print x              # A 2x5 Array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$List$ can also be non-homogeneous multi-dimensional:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "Mr. Perelman published the solution to Poincáre conjecture in \"ArXiv\".\n"
     ]
    }
   ],
   "source": [
    "Data_3D = [[[2,3,5],[1,7,0]],[5,\"ArXiv\"]]\n",
    "\n",
    "#print number 7\n",
    "print Data_3D[0][1][1]\n",
    "\n",
    "print 'Mr. Perelman published the solution \\\n",
    "to Poinc%sre conjecture in \"%s\".' % (u\"\\u00E1\", Data_3D[1][1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Data_3D` is actually $lists$ inside $lists$ inside $list$ but non-homogeneously."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"Tutorial3/array.png\" width=\"500\" >\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The elements in the $list$ can be subtituted."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2, 3, 5], [1, 7, 0]]\n",
      "[[5, 'ArXiv'], [2, 3, 5]]\n",
      "ArXiv\n",
      "[[[2, 3, 5], [1, 7, 0]], [5, 'PlosOne']]\n"
     ]
    }
   ],
   "source": [
    "# Extracting and substitution\n",
    "\n",
    "L1 = Data_3D[0]; print L1\n",
    "L2 = [Data_3D[1]]+[Data_3D[0][0]]\n",
    "print L2\n",
    "print L2[0][1]\n",
    "Data_3D[1][1] = \"PlosOne\"\n",
    "print Data_3D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Iterating on elements in list requires the sequential accessing of the list. This can be done using <span style=\"color: #0000FF\">$for$</span> and <span style=\"color: #0000FF\">$while$</span> control structures as well as the <span style=\"color: #0000FF\">$enumerate$&#40;&#41;</span> function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Eris', 'Pluto', 'Makemake', 'Haumea', 'Sedna']\n"
     ]
    }
   ],
   "source": [
    "# Looping: for\n",
    "\n",
    "dwarf = [\"Eris\",\"Pluto\",\"Makemake\",\"Haumea\",\"Sedna\"]\n",
    "print dwarf\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Eris\n",
      "Pluto\n",
      "Makemake\n",
      "Haumea\n",
      "Sedna\n"
     ]
    }
   ],
   "source": [
    "for name in dwarf:\n",
    "    print name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\tEris\n",
      "1\tPluto\n",
      "2\tMakemake\n",
      "3\tHaumea\n",
      "4\tSedna\n"
     ]
    }
   ],
   "source": [
    "for z in range(len(dwarf)):\n",
    "    print \"%d\\t%s\" % (z,dwarf[z])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\tEris\n",
      "2\tPluto\n",
      "3\tMakemake\n",
      "4\tHaumea\n",
      "5\tSedna\n"
     ]
    }
   ],
   "source": [
    "for x,z in enumerate(dwarf,1):\n",
    "    print \"%d\\t%s\" % (x,z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\tEris\n",
      "2\tPluto\n",
      "3\tMakemake\n",
      "4\tHaumea\n",
      "5\tSedna\n"
     ]
    }
   ],
   "source": [
    "z = 0\n",
    "while z < len(dwarf):\n",
    "    print \"%d\\t%s\" % (z+1,dwarf[z])\n",
    "    z = z + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <span style=\"color: #F5DA81; background-color: #610B4B\">Example 4.3</span>: Calculate and print each value of x`*`y with:\n",
    "#### x = [12.1,7.3,6.2,9.9,0.5]\n",
    "#### y = [4.5,6.1,3.9,1.7,8.0]\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12.1 x 4.5 = 54.45\n",
      "7.3 x 6.1 = 44.53\n",
      "6.2 x 3.9 = 24.18\n",
      "9.9 x 1.7 = 16.83\n",
      "0.5 x 8.0 = 4.00\n",
      "\n",
      "\n",
      "[54.449999999999996, 44.529999999999994, 24.18, 16.830000000000002, 4.0]\n"
     ]
    }
   ],
   "source": [
    "x = [12.1,7.3,6.2,9.9,0.5]\n",
    "y = [4.5,6.1,3.9,1.7,8.0]\n",
    "\n",
    "i = 0\n",
    "xy = []      # Creating empty list\n",
    "while i < (len(x)):\n",
    "    xy = xy + [x[i]*y[i]]     # Appending result into list\n",
    "    print '%.1f x %.1f = %.2f' % (x[i],y[i],xy[i])\n",
    "    i = i + 1\n",
    "print '\\n'        \n",
    "print xy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <span style=\"color: #F5DA81; background-color: #610B4B\">Example 4.4</span>: Calculate and print each value of x2`*`y2 with:\n",
    "#### x2 = [[12.1,7.3],[6.2,9.9]]\n",
    "#### y2 = [[4.5,6.1],[3.9,1.7]]\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12.1 x 4.5 = 54.45\n",
      "7.3 x 6.1 = 44.53\n",
      "6.2 x 3.9 = 24.18\n",
      "9.9 x 1.7 = 16.83\n",
      "\n",
      "\n",
      "[[54.449999999999996, 44.529999999999994], [24.18, 16.830000000000002]]\n"
     ]
    }
   ],
   "source": [
    "x2 = [[12.1,7.3],[6.2,9.9]]\n",
    "y2 = [[4.5,6.1],[3.9,1.7]]\n",
    "\n",
    "j = 0\n",
    "xy2 = []\n",
    "xy3 = []\n",
    "while j < (len(x2)):\n",
    "    k = 0\n",
    "    for k in range(len(x2)):\n",
    "        xy3 = xy3 + [x2[j][k]*y2[j][k]]\n",
    "        print '%.1f x %.1f = %.2f' % (x2[j][k],y2[j][k],xy3[k])\n",
    "        k = k + 1\n",
    "    xy2 = xy2 + [xy3]\n",
    "    xy3 = []\n",
    "    j = j + 1\n",
    "print '\\n'     \n",
    "print xy2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <span style=\"color: #F5DA81; background-color: #610B4B\">Example 4.5</span>: Just create a list that contains the $f(x)$ value of a _Gaussian_ distribution with $\\sigma$ = 0.4 and $\\mu$ = 5."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**The Gaussian function:$$f(x) = e^{\\frac{-(x-\\mu)^2}{2\\sigma^2}}$$**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.000004\t\n",
      "0.000013\t\n",
      "0.000040\t\n",
      "0.000120\t\n",
      "0.000335\t\n",
      "0.000884\t\n",
      "0.002187\t\n",
      "0.005086\t\n",
      "0.011109\t\n",
      "0.022794\t*\n",
      "0.043937\t**\n",
      "0.079560\t***\n",
      "0.135335\t******\n",
      "0.216265\t**********\n",
      "0.324652\t****************\n",
      "0.457833\t**********************\n",
      "0.606531\t******************************\n",
      "0.754840\t*************************************\n",
      "0.882497\t********************************************\n",
      "0.969233\t************************************************\n",
      "1.000000\t**************************************************\n",
      "0.969233\t************************************************\n",
      "0.882497\t********************************************\n",
      "0.754840\t*************************************\n",
      "0.606531\t******************************\n",
      "0.457833\t**********************\n",
      "0.324652\t****************\n",
      "0.216265\t**********\n",
      "0.135335\t******\n",
      "0.079560\t***\n",
      "0.043937\t**\n",
      "0.022794\t*\n",
      "0.011109\t\n",
      "0.005086\t\n",
      "0.002187\t\n",
      "0.000884\t\n",
      "0.000335\t\n",
      "0.000120\t\n",
      "0.000040\t\n",
      "0.000013\t\n",
      "0.000004\t\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[3.7266531720786777e-06,\n",
       " 1.2607105177048545e-05,\n",
       " 4.006529739295121e-05,\n",
       " 0.00011961288358102479,\n",
       " 0.00033546262790251364,\n",
       " 0.0008838263069350546,\n",
       " 0.0021874911181828985,\n",
       " 0.005086069231012732,\n",
       " 0.011108996538242375,\n",
       " 0.022794180883612486,\n",
       " 0.04393693362340769,\n",
       " 0.07955950871822796,\n",
       " 0.13533528323661287,\n",
       " 0.2162651668298872,\n",
       " 0.32465246735834913,\n",
       " 0.45783336177161305,\n",
       " 0.6065306597126316,\n",
       " 0.7548396019890051,\n",
       " 0.8824969025845932,\n",
       " 0.9692332344763427,\n",
       " 1.0,\n",
       " 0.9692332344763459,\n",
       " 0.8824969025845991,\n",
       " 0.7548396019890127,\n",
       " 0.6065306597126396,\n",
       " 0.45783336177162065,\n",
       " 0.3246524673583556,\n",
       " 0.21626516682989225,\n",
       " 0.13533528323661645,\n",
       " 0.07955950871823037,\n",
       " 0.043936933623409155,\n",
       " 0.022794180883613388,\n",
       " 0.0111089965382429,\n",
       " 0.005086069231013008,\n",
       " 0.002187491118183033,\n",
       " 0.0008838263069351174,\n",
       " 0.00033546262790254015,\n",
       " 0.00011961288358103563,\n",
       " 4.006529739295526e-05,\n",
       " 1.2607105177049956e-05,\n",
       " 3.7266531720791343e-06]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import *\n",
    "\n",
    "sigma = 0.4\n",
    "mu = 5.0\n",
    "\n",
    "x_val = []\n",
    "ctr = 3\n",
    "while ctr < 7:\n",
    "    x_val = x_val + [ctr]\n",
    "    ctr = ctr + 0.1\n",
    "\n",
    "fx = []\n",
    "for n in range(0,len(x_val),1):\n",
    "    intensity = exp(-(x_val[n]-mu)**2/(2*sigma**2))\n",
    "    fx = fx + [intensity]\n",
    "    print '%f\\t%s' % (intensity,int(intensity*50)*'*')\n",
    "\n",
    "fx"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "#### **_4.1.1 Converting data from a file into a list_**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each line in a file can be directly converted to a list using the <span style=\"color: #0000FF\">$readlines$&#40;&#41;</span> function. For instance, in section 2.4 of tutorial 2, instead of using <span style=\"color: #0000FF\">$read$&#40;&#41;</span> function, we can use the <span style=\"color: #0000FF\">$readlines$&#40;&#41;</span> function to convert each line in the file $les miserables.txt$ as elements of a list $linecontent$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Opening a file \n",
    "file_read = open(\"Tutorial2/les miserables.txt\")\n",
    "linecontent = file_read.readlines()\n",
    "file_read.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The elements of $linecontent$ is now the lines in $les miserables.txt$ (including the escape character):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Preface from Les Miserables\\n',\n",
       " '\\n',\n",
       " 'So long as there shall exist, by reason of law and custom,\\n',\n",
       " 'a social condemnation, which, in the face of civilisation,\\n',\n",
       " 'artificially creates hells on earth, and complicates a\\n',\n",
       " 'destiny that is divine, with human fatality; so long as the\\n',\n",
       " 'three problems of the age - the degradation of man by poverty,\\n',\n",
       " 'the ruin of woman by starvation, and the dwarfing of childhood\\n',\n",
       " 'by physical and spiritual night - are not solved; so long as,\\n',\n",
       " 'in certain regions, social asphyxia shall be possible; in other\\n',\n",
       " 'words, and from a yet more extended point of view, so long as\\n',\n",
       " 'ignorance and misery remain on earth, books like this cannot\\n',\n",
       " 'be useless.\\n',\n",
       " '\\n',\n",
       " 'HAUTEVILLE HOUSE, 1862.\\n',\n",
       " 'FANTINE']"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "linecontent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "### **_4.2 The Tuples_**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A $tuple$ can be declared using the round bracket. A $tuple$ is actually a $list$ that contains element that cannot be modified or subtituted. Apart from that, its has similar properties with $list$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3, 4)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t1 = (1,2,3,4)\n",
    "t1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Attempting to substitute a $tuple$ element will give an error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-23-d1336156237f>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mt1\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m5\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "t1[1] = 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "### **_4.3 The Dictionaries_**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$Dictionaries$ are similar to \"associative arrays\" in many other programming language. $Dictionaries$ are indexed by keys that can be strings or numbers. Acessing data in $dictionaries$ is by specifying the keys instead of index number. Data can be anything including other $dictionaries$. $Dictionaries$ can be declared by using the curly brackets with the pair of key and data separated by '$:$' and each pair of this element separated by '$,$'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Barnard's Star\""
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Nearby stars to the earth\n",
    "\n",
    "Stars = {1:'Sun', 2:'Alpha Centauri', 3:\"Barnard's Star\",\\\n",
    "         4:'Luhman 16', 5:'WISE 0855-0714'}\n",
    "\n",
    "Stars[3]      # Specify the key instead of index number"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above example the keys are made of integers whereas the data are all made of strings. It can also be the opposite:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Alpha Centauri is 4.24 light years from earth.\n"
     ]
    }
   ],
   "source": [
    "# Distance of nearby stars to the earth\n",
    "\n",
    "Stars_Dist = {'Sun':0, 'Alpha Centauri':4.24, \"Barnard's Star\":6.00,\\\n",
    "         'Luhman 16':6.60, 'WISE 0855-0714':7.0}\n",
    "\n",
    "print 'Alpha Centauri is %.2f light years from earth.' % \\\n",
    "(Stars_Dist['Alpha Centauri'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These informations can be made more structured by using $list$ as data in $dictionary$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Luhman 16 is the fourth closest star at about 6.60 light \n",
      "years from earth.\n"
     ]
    }
   ],
   "source": [
    "# A more structured dictionaries data\n",
    "\n",
    "Stars_List = {1:['Sun',0], 2:['Alpha Centauri',4.24],\\\n",
    "              3:[\"Barnard's Star\",6.00], 4:['Luhman 16',6.60],\\\n",
    "              5:['WISE 0855-0714',7.0]}\n",
    "\n",
    "print '%s is the fourth closest star at about %.2f light \\\n",
    "\\nyears from earth.' % (Stars_List[4][0],Stars_List[4][1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below is the example of $dictionary$ that contains $dictionary$ type data and the ways to access them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Declaring dictionaries data for the dictionary 'Author'\n",
    "\n",
    "Coetzee = {1974:'Dusklands',\n",
    "           1977:'In The Heart Of The Country',\n",
    "           1980:'Waiting For The Barbarians',\n",
    "           1983:'Life & Times Of Michael K'}\n",
    "\n",
    "McCarthy = {1992:'All the Pretty Horses',\n",
    "            1994:'The Crossing',\n",
    "            1998:'Cities of the Plain',\n",
    "            2005:'No Country for Old Men',\n",
    "            2006:'The Road'}\n",
    "\n",
    "Steinbeck = {1937:'Of Mice And Men',\n",
    "             1939:'The Grapes Of Wrath',\n",
    "             1945:'Cannery Row',\n",
    "             1952:'East Of Eden',\n",
    "             1961:'The Winter Of Our Discontent'}\n",
    "\n",
    "Lewis = {'Narnia Series':{1950:'The Lion, the Witch and the Wardrobe',\n",
    "         1951:'Prince Caspian: The Return to Narnia',\n",
    "         1952:'The Voyage of the Dawn Treader',\n",
    "         1953:'The Silver Chair',\n",
    "         1954:'The Horse and His Boy',\n",
    "         1955:\"The Magician's Nephew\",\n",
    "         1956:'The Last Battle'\n",
    "         }}\n",
    "\n",
    "# Assigning keys and data for the dictionary 'Author'\n",
    "# one of it is a dictionary list\n",
    "\n",
    "Author = {'South Africa':Coetzee,'USA':[McCarthy,Steinbeck],\n",
    "          'British':Lewis}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Life & Times Of Michael K'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Author['South Africa'][1983]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'The Grapes Of Wrath'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Author['USA'][1][1939]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'The Silver Chair'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Author['British']['Narnia Series'][1953]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "More on lists and dictionaries can be found on https://docs.python.org/2/tutorial/datastructures.html"
   ]
  }
 ],
 "metadata": {
  "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.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}