MyPythonNotebook.ipynb

{
 "metadata": {
  "name": "",
  "signature": "sha256:a394c5bf52c2ec9e8ab6593edf9ff69545c51eac1a55d2e298ab0b3aa7b01cf1"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Sri's Python Tutorial Blog"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Here is some text markup $Latex - (a+b)^2 = a^2 + b^2 + 2*a*b$\n",
      "Python has a set of magic commands that help the interactive programming process. Magic commands are prefixed with a single or double percent symbol. The pylab magic command automatically configures Python for plotting. Use the pylab magic command by entering the following into a code cell:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%pylab inline"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Populating the interactive namespace from numpy and matplotlib\n"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stderr",
       "text": [
        "WARNING: pylab import has clobbered these variables: ['random']\n",
        "`%matplotlib` prevents importing * from pylab and numpy\n"
       ]
      }
     ],
     "prompt_number": 58
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Execute the cell and the pylab magic will run. In another code cell, add and execute the following Python code to plot a segment of the sine function:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = linspace(0, 10)\n",
      "y =sin(x)\n",
      "plot(x, y)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 59,
       "text": [
        "[<matplotlib.lines.Line2D at 0x10579d5f8>]"
       ]
      },
      {
       "metadata": {},
       "output_type": "display_data",
       "png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAAEACAYAAABfxaZOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
       "text": [
        "<matplotlib.figure.Figure at 0x10557dcc0>"
       ]
      }
     ],
     "prompt_number": 59
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Interfacing IPython Notebook with R "
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "This can be done using rpy2......"
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "The Shebang"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "On Unix, when a program is invoked in the console, the file\u2019s first two bytes are\n",
      "read.\u2605 If these bytes are the ASCII characters #!, the shell assumes that the file\n",
      "is to be executed by an interpreter and that the file\u2019s first line specifies which\n",
      "interpreter to use. This line is called the shebang (shell execute) line, and if\n",
      "present must be the first line in the file."
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Importing Modules"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The standard convention for importing modules is: standard library\n",
      "modules first, then third-party library modules, and finally your own\n",
      "modules."
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Dynamic Typing"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Python uses dynamic typing, which means that an object reference can be rebound\n",
      "to refer to a different object (which may be of a different data type) at\n",
      "any time. Languages that use strong typing (such as C++ and Java) allow only\n",
      "those operations that are defined for the data types involved to be performed.\n",
      "Python also applies this constraint, but it isn\u2019t called strong typing in Python\u2019s\n",
      "case because the valid operations can change."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "    #Example:\n",
      "    myvar = 10\n",
      "    myvar /= 2\n",
      "    print(myvar)\n",
      "    myvar = \"apple\" #This is possible because python uses dynamic typing. The int object myvar \n",
      "                    #is scheduled for garbage collection since now no object reference refers to it.\n",
      "    myvar/2 #Not possible because python is a strongly typed language"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "\" is \" The Identity Operator"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#The is operator is a binary operator that returns True if its left-hand object\n",
      "#reference is referring to the same object as its right-hand object reference.\n",
      "a = 10\n",
      "b = 10\n",
      "if a is b:\n",
      "    print(True)\n",
      "else:\n",
      "    print(False)\n",
      "\n",
      "#Wait!!! Wait!!! lets look at objects now\n",
      "# lists \"a\" and \"b\" refer to two different memory locations.\n",
      "a = [1,2,3,4]\n",
      "b = [1,2,3,4]\n",
      "if a is b:\n",
      "    print(True)\n",
      "else:\n",
      "    print(False)\n",
      "\n",
      "#Now let us see by assigning a to c\n",
      "c = a\n",
      "if a is c:\n",
      "    print(True)\n",
      "else:\n",
      "    print(False)\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "True\n",
        "False\n",
        "True\n"
       ]
      }
     ],
     "prompt_number": 32
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "One benefit of identity comparisons is that they are very fast. This is because\n",
      "the objects referred to do not have to be examined themselves. The is operator\n",
      "needs to compare only the memory addresses of the objects\u2014the same address\n",
      "means the same object. The most common use case for is is to compare a data item with the built-in\n",
      "null object, None, which is often used as a place-marking value to signify\n",
      "\u201cunknown\u201d or \u201cnonexistent\u201d."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = \"Something here\"\n",
      "b = None\n",
      "a is not None, b is None"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 35,
       "text": [
        "(True, True)"
       ]
      }
     ],
     "prompt_number": 35
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "In some cases, comparing the identity of two strings or numbers\u2014for example,\n",
      "using a is b\u2014will return True, even if each has been assigned separately as we\n",
      "did here. This is because some implementations of Python will reuse the same\n",
      "object (since the value is the same and is immutable) for the sake of efficiency.\n",
      "The moral of this is to use == and != when comparing values, and to use is and\n",
      "is not only when comparing with None or when we really do want to see if two\n",
      "object references, rather than their values, are the same.\n",
      "\n",
      "One particularly nice feature of Python\u2019s comparison operators is that they can\n",
      "be chained. This is a nicer way of testing that a given data item is in range than having\n",
      "to do two separate comparisons joined by logical and, as most other languages\n",
      "require. It also has the additional virtue of evaluating the data item only once\n",
      "(since it appears once only in the expression), something that could make a difference if computing the data item\u2019s value is expensive, or if accessing the\n",
      "data item causes side effects."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = 5\n",
      "0 <= a <= 10"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 36,
       "text": [
        "True"
       ]
      }
     ],
     "prompt_number": 36
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#The right-hand operand for the list += operator must be an iterable; if it is not an exception is \n",
      "#raised.\n",
      "mylist = [1,2,3,4]\n",
      "mylist += [5] #valid\n",
      "mylist += 5 #not valid"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 38
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Lists"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#list expansion\n",
      "a = [\"first\",2,3]\n",
      "a *= 2\n",
      "print(a)\n",
      "a += [4,5]\n",
      "print(a)\n",
      "a += \"list\" #the result will surprise you\n",
      "print(a)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "['first', 2, 3, 'first', 2, 3]\n",
        "['first', 2, 3, 'first', 2, 3, 4, 5]\n",
        "['first', 2, 3, 'first', 2, 3, 4, 5, 'l', 'i', 's', 't']\n"
       ]
      }
     ],
     "prompt_number": 11
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#There are two ways to append items to a list.\n",
      "\n",
      "#Method1: list is an 'class' with append method(self,var). The append method can be invoked using \n",
      "# the dot operator on the list class.\n",
      "a = [1,2,3]\n",
      "list.append(a,4)\n",
      "print(a)\n",
      "\n",
      "#Method2: You can also pass the 'var' that needs to appended to the list object \"b\" in this case. \n",
      "b = [1,2,3]\n",
      "b.append(4)\n",
      "print(b)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[1, 2, 3, 4]\n",
        "[1, 2, 3, 4]\n"
       ]
      }
     ],
     "prompt_number": 24
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#element-wise operation.\n",
      "a = [1,2,3]\n",
      "b = [4,5,6]\n",
      "print(list(map(multiply,a,b)))\n",
      "print(list(map(add,a,b)))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[4, 10, 18]\n",
        "[5, 7, 9]\n"
       ]
      }
     ],
     "prompt_number": 148
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#sorting a list\n",
      "randomlist = [1,8,2,5]\n",
      "sorted(randomlist) #original list is unchanged\n",
      "print(randomlist)\n",
      "\n",
      "randomlist.sort() #sorts the list in place\n",
      "print(randomlist)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[1, 8, 2, 5]\n",
        "[1, 2, 5, 8]\n"
       ]
      }
     ],
     "prompt_number": 241
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Enumerate"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "L = [\"Apple\",\"Banana\",\"Clementine\",\"Date\"]\n",
      "for i, fruit in enumerate(L):\n",
      "    print(str(i) + \" \" + fruit)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "0 Apple\n",
        "1 Banana\n",
        "2 Clementine\n",
        "3 Date\n"
       ]
      }
     ],
     "prompt_number": 473
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Stacks (LIFO)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "L = [1,2,3]\n",
      "L.append(4)\n",
      "L\n",
      "L.pop()\n",
      "L"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 155,
       "text": [
        "[1, 2, 3]"
       ]
      }
     ],
     "prompt_number": 155
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#generation of list of pairs\n",
      "list1 = [1,2,3,4]\n",
      "list2 = [5,6,7]\n",
      "\n",
      "print(list(zip(list1,list2)))\n",
      "\n",
      "for l1, l2 in zip(list1, list2):\n",
      "    print(l1, l2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[(1, 5), (2, 6), (3, 7)]\n",
        "1 5\n",
        "2 6\n",
        "3 7\n"
       ]
      }
     ],
     "prompt_number": 269
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#To concatenate items in a list\n",
      "wordlist = [\"Hello\",\"World\",\"India\"]\n",
      "#''.join(wordlist)\n",
      "import operator\n",
      "outstring = ''\n",
      "for item in wordlist:\n",
      "    outstring = outstring+item #operator.concat(outstring, item)\n",
      "print(outstring)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "HelloWorldIndia\n"
       ]
      }
     ],
     "prompt_number": 180
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#multiplication of items in a list\n",
      "\n",
      "reduce = lambda x, y: x * y\n",
      "reduce(3,4)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 202,
       "text": [
        "12"
       ]
      }
     ],
     "prompt_number": 202
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Queues (FIFO)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from collections import deque\n",
      "myque = deque([\"apple\",\"orange\",\"grape\"])\n",
      "myque.append(\"kiwi\")\n",
      "myque.append(\"strawberry\")\n",
      "myque.popleft()\n",
      "myque"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 193,
       "text": [
        "deque(['orange', 'grape', 'kiwi', 'strawberry'])"
       ]
      }
     ],
     "prompt_number": 193
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Slicing"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "    -    -    -    -    -\n",
      "  0    1    2    3    4    5\n",
      " -5   -4   -3   -2   -1"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "examplelist = [\"a\",\"b\",\"c\",\"d\",\"e\"]\n",
      "'''      VAR[lower:upper: step]        '''\n",
      "print(\"#-----------------#\")\n",
      "print(examplelist[0:5])\n",
      "print(examplelist[:])\n",
      "print(examplelist[0:])\n",
      "print(examplelist[-5:])\n",
      "print(examplelist[:1000])#he he he this is funny\n",
      "print(\"#-----------------#\")\n",
      "print(examplelist[0:-1])\n",
      "print(\"#-----------------#\")\n",
      "print(examplelist[::2]) #get every second element.\n",
      "print(examplelist[::-1]) #List reversal"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "#-----------------#\n",
        "['a', 'b', 'c', 'd', 'e']\n",
        "['a', 'b', 'c', 'd', 'e']\n",
        "['a', 'b', 'c', 'd', 'e']\n",
        "['a', 'b', 'c', 'd', 'e']\n",
        "['a', 'b', 'c', 'd', 'e']\n",
        "#-----------------#\n",
        "['a', 'b', 'c', 'd']\n",
        "#-----------------#\n",
        "['a', 'c', 'e']\n",
        "['e', 'd', 'c', 'b', 'a']\n"
       ]
      }
     ],
     "prompt_number": 53
    },
    {
     "cell_type": "heading",
     "level": 4,
     "metadata": {},
     "source": [
      "Shallow Copy of Lists"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "fruits = [\"apple\",\"orange\",\"mango\"]\n",
      "vegetables = fruits\n",
      "print(vegetables)\n",
      "vegetables[2] = \"cabbage\"\n",
      "print(fruits)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "['apple', 'orange', 'mango']\n",
        "['apple', 'orange', 'cabbage']\n"
       ]
      }
     ],
     "prompt_number": 228
    },
    {
     "cell_type": "heading",
     "level": 4,
     "metadata": {},
     "source": [
      "Work around using Slice Operator"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "fruits = [\"apple\",\"orange\",\"mango\"]\n",
      "vegetables = fruits[:]\n",
      "print(vegetables)\n",
      "vegetables[2] = \"cabbage\"\n",
      "print(fruits)\n",
      "print(vegetables)\n",
      "print(\"#----------------------#\")\n",
      "fruits=[\"apple\",\"orange\",\"mango\",[\"strawberry\",\"blueberry\"]]\n",
      "vegetables = fruits[:]\n",
      "vegetables[1] = \"grape\"\n",
      "print(fruits)\n",
      "vegetables[3][0] = \"raspberry\"\n",
      "print(fruits) # you are in trouble again when your list contains sublists"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "['apple', 'orange', 'mango']\n",
        "['apple', 'orange', 'mango']\n",
        "['apple', 'orange', 'cabbage']\n",
        "#----------------------#\n",
        "['apple', 'orange', 'mango', ['strawberry', 'blueberry']]\n",
        "['apple', 'orange', 'mango', ['raspberry', 'blueberry']]\n"
       ]
      }
     ],
     "prompt_number": 236
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "\"Copy from one, it's plagiarism; copy from two, it's research.\"\n",
      "Wilson Mizner, (1876 - 1933) "
     ]
    },
    {
     "cell_type": "heading",
     "level": 4,
     "metadata": {},
     "source": [
      "Deep Copy of Lists"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from copy import deepcopy\n",
      "fruits=[\"apple\",\"orange\",\"mango\",[\"strawberry\",\"blueberry\"]]\n",
      "vegetables = deepcopy(fruits)\n",
      "vegetables[1] = \"grape\"\n",
      "print(fruits)\n",
      "vegetables[3][0] = \"raspberry\"\n",
      "print(fruits)\n",
      "print(vegetables)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "['apple', 'orange', 'mango', ['strawberry', 'blueberry']]\n",
        "['apple', 'orange', 'mango', ['strawberry', 'blueberry']]\n",
        "['apple', 'grape', 'mango', ['raspberry', 'blueberry']]\n"
       ]
      }
     ],
     "prompt_number": 237
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Tuples"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "As opposed to lists tuples are immutable i.e., you cannot modify, change or add elements.\n",
      "Thus tuples can be used as keys in a dictionary whereas lists cannot be.\n",
      "Example of a tuple: mytuple = (\"orange\",\"mango\",\"grape\")"
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Dictionaries"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "myDict = {\"one\":\"apple\",2:\"pear\",\"three\":\"orange\"}\n",
      "print(myDict[\"one\"])\n",
      "print(myDict[2])\n",
      "\n",
      "del myDict['three']\n",
      "\n",
      "myDict.keys()\n",
      "\n",
      "myDict.items()\n",
      "for k in myDict: #Alternatively, for k in myDict.keys(): print(k)\n",
      "    print(k)\n",
      "for k, v in myDict.items():\n",
      "    print(k,v)\n",
      "\n",
      "if \"one\" in myDict:\n",
      "    print(\"True\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "apple\n",
        "pear\n",
        "2\n",
        "one\n",
        "2 pear\n",
        "one apple\n",
        "True\n"
       ]
      }
     ],
     "prompt_number": 247
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "newDict = {x: x**2 for x in (2, 4, 6)}\n",
      "#newDict.get(2,\"Not Fnd\") #Since key 2 is in newDict returns its value 4 otherwise returns \"Not Fnd\"\n",
      "newDict.get(3,\"Not Found\") #Since key 3 is not newDict it returns \"Not Found\"\n",
      "\n",
      "newDict.setdefault(5,10) #Since the key 5 is not in newDict it adds a new pair (5:10) to newDict\n",
      "newDict.setdefault(6,4) #Since the key 6 is already in newDict it returns its value 36\n",
      "\n",
      "class parentDict(dict):\n",
      "    def __init__(self,key_val_pairs):\n",
      "        self.update(key_val_pairs)\n",
      "    def __missing__(self,key):\n",
      "        if key not in self.keys():\n",
      "            print(\"Not in the dictionary\")\n",
      "\n",
      "myParDict = parentDict({1:\"one\",2:\"two\",3:\"three\"})\n",
      "myParDict[10]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Not in the dictionary\n"
       ]
      }
     ],
     "prompt_number": 248
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Dictionary of dictionaries"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "fruits = {\"o\": \"orange\", \"b\": \"bananna\", \"a\": \"apple\"}\n",
      "vegetables = {\"o\":\"okra\", \"b\": \"brocolli\", \"a\": \"artochoke\"}\n",
      "pantry = {\"f\":fruits, \"v\":vegetables}\n",
      "print(pantry[\"v\"][\"o\"])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "okra\n"
       ]
      }
     ],
     "prompt_number": 246
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Shallow and deepcopy of dictionaries"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from copy import deepcopy\n",
      "pantry = {\"fruits\": {\"o\": \"orange\", \"b\": \"bananna\", \"a\": \"apple\"},\n",
      "          \"vegetables\": {\"o\":\"okra\", \"b\": \"brocolli\", \"a\": \"artochoke\"} \n",
      "         }\n",
      "pantry_shallowcopy = pantry.copy()\n",
      "pantry_shallowcopy[\"fruits\"][\"b\"] = \"berry\"\n",
      "print(pantry_shallowcopy)\n",
      "print(pantry)\n",
      "pantry_deepcopy = deepcopy(pantry)\n",
      "pantry_deepcopy[\"vegetables\"][\"o\"] = \"onion\"\n",
      "print(pantry_deepcopy)\n",
      "print(pantry)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "{'fruits': {'b': 'berry', 'o': 'orange', 'a': 'apple'}, 'vegetables': {'b': 'brocolli', 'o': 'okra', 'a': 'artochoke'}}\n",
        "{'fruits': {'b': 'berry', 'o': 'orange', 'a': 'apple'}, 'vegetables': {'b': 'brocolli', 'o': 'okra', 'a': 'artochoke'}}\n",
        "{'fruits': {'b': 'berry', 'o': 'orange', 'a': 'apple'}, 'vegetables': {'b': 'brocolli', 'o': 'onion', 'a': 'artochoke'}}\n",
        "{'fruits': {'b': 'berry', 'o': 'orange', 'a': 'apple'}, 'vegetables': {'b': 'brocolli', 'o': 'okra', 'a': 'artochoke'}}\n"
       ]
      }
     ],
     "prompt_number": 258
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Converting Lists to Dictionary"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "codes = ['a','b','o']\n",
      "fruits = [\"apple\",\"banana\",\"orange\"]\n",
      "lists_to_dict = dict(zip(codes,fruits))\n",
      "print(lists_to_dict)\n",
      "print(lists_to_dict.items())\n",
      "print(lists_to_dict.keys())\n",
      "print(lists_to_dict.values())"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "{'b': 'banana', 'o': 'orange', 'a': 'apple'}\n",
        "dict_items([('b', 'banana'), ('o', 'orange'), ('a', 'apple')])\n",
        "dict_keys(['b', 'o', 'a'])\n",
        "dict_values(['banana', 'orange', 'apple'])\n"
       ]
      }
     ],
     "prompt_number": 277
    },
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "Sets"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Unlike lists and tuples, sets like their mathematical counterparts can contain only unique elements. Sets are mutable but they cannot contain mutable objects like lists as their members."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = set(\"apple banana\") # If we pass a string to set function it will be split into individual chars\n",
      "print(x)\n",
      "print(type(x))\n",
      "y = set([\"apple\", \"banana\"])\n",
      "print(y)\n",
      "print(type(y))\n",
      "z = {\"one\", \"two\", \"three\", \"two\"} #Sets can also be created using the mathematical representation\n",
      "print(z) # repeats will be removed by set function\n",
      "print(type(z))\n",
      "t = set((\"car\",\"truck\",\"van\"))\n",
      "print(t)\n",
      "print(type(t))\n",
      "ts = set(((\"one\", \"two\", \"three\"),(\"uno\", \"dos\", \"tres\"))) #tuples can be used as elements of sets\n",
      "print(ts)\n",
      "print(type(ts))\n",
      "ts.add((\"ek\",\"do\",\"teen\")) #Sets are mutable\n",
      "print(ts)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "{'l', 'a', 'e', 'p', 'b', 'n', ' '}\n",
        "<class 'set'>\n",
        "{'banana', 'apple'}\n",
        "<class 'set'>\n",
        "{'two', 'three', 'one'}\n",
        "<class 'set'>\n",
        "{'car', 'truck', 'van'}\n",
        "<class 'set'>\n",
        "{('one', 'two', 'three'), ('uno', 'dos', 'tres')}\n",
        "<class 'set'>\n",
        "{('ek', 'do', 'teen'), ('one', 'two', 'three'), ('uno', 'dos', 'tres')}\n"
       ]
      }
     ],
     "prompt_number": 304
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Difference between two sets\n",
      "basket1 = {\"apples\",\"oranges\",\"grapes\"}\n",
      "basket2 = {\"oranges\",\"mangoes\"}\n",
      "print(basket1.difference(basket2))\n",
      "print(basket1-basket2)\n",
      "#difference_update removes intersection of sets from current set. \n",
      "basket1.difference_update(basket2)\n",
      "print(basket1)\n",
      "#discard removes element from a set\n",
      "basket2.discard(\"mangoes\")\n",
      "print(basket2)\n",
      "#Intersection and union of sets\n",
      "set1 = {1,2,3,4,5,6,7}\n",
      "set2 = {2,3,8,9}\n",
      "set3 = {2,3,4}\n",
      "print(set1.intersection(set2))\n",
      "print(set1 & set2) # same as intersection\n",
      "set1.union(set2)\n",
      "print(set1.isdisjoint(set2)) # disjoint returns true if set1 intersection set2 is a null set\n",
      "print(basket1.isdisjoint(basket2))\n",
      "print(set3 < set1) # set3 is a subset of set1. You can also use issubset()\n",
      "print(set1 > set3) # set1 is a superset of set3. You can also use issuperset()\n",
      "print(set1 >= set1)\n",
      "set1.pop() # removes arbitrary element from the set. Works similar to dictionary"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "{'apples', 'grapes'}\n",
        "{'apples', 'grapes'}\n",
        "{'apples', 'grapes'}\n",
        "{'oranges'}\n",
        "{2, 3}\n",
        "{2, 3}\n",
        "False\n",
        "True\n",
        "True\n",
        "True\n",
        "True\n"
       ]
      },
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 331,
       "text": [
        "1"
       ]
      }
     ],
     "prompt_number": 331
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Frozen Sets"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Unlike sets frozen sets are immutable i.e., once created you are not allowed to change or add items. The immutable nature of frozen sets means they can be used as keys in a dictionary."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "immutable_set = frozenset((\"one\",\"two\",\"three\"))\n",
      "print(immutable_set)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "frozenset({'two', 'three', 'one'})\n"
       ]
      }
     ],
     "prompt_number": 308
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Input"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "input function is a convenience function to read the input from the console. But any input entered by the user would be treated as string."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "total_debt = input(\"What is your debt?\")\n",
      "print(type(total_debt))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "name": "stdout",
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "What is your debt?200000\n"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "<class 'str'>\n"
       ]
      }
     ],
     "prompt_number": 332
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Eval"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Eval function can be used for casting the input to the desired type."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "total_debt = eval(input(\"What is your debt?\")) #you can also cast using int()\n",
      "print(type(total_debt))\n",
      "fruits = eval(input(\"What fruits do you like?\"))\n",
      "print(type(fruits))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "name": "stdout",
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "What is your debt?1000\n"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "<class 'int'>\n"
       ]
      },
      {
       "name": "stdout",
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "What fruits do you like?{\"apple\",\"mango\"}\n"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "<class 'set'>\n"
       ]
      }
     ],
     "prompt_number": 336
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Ternary Operator"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "(a, b) = (5, 10)\n",
      "max = a if a>b else b\n",
      "print(max)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "10\n"
       ]
      }
     ],
     "prompt_number": 339
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Output Formatting"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(\"First argument: {0}, Second argument: {1}\".format(\"orange\",\"mango\"))\n",
      "print(\"First argument: {1}, Second argument: {0}\".format(\"orange\",\"mango\"))\n",
      "print(\"1st arg: {0:5d}, 2nd arg: {1:9d}\".format(12345,123456789))\n",
      "print(\"1st arg: {0:5d}, 2nd arg: {1:9.2f}\".format(4,1234.783))#Total 9 places - 2 for post-decimal\n",
      "\n",
      "#Formatting using keyword parameters\n",
      "print(\"Drug_Index: {DI:5d}, Drug_Price: {DP:9.2f}\".format(DI=1234, DP=12334.789))\n",
      "\n",
      "#Justify left and right using '<' and '>' respectively\n",
      "print(\"{0:<20s} {1:5.2f}\".format('Metazolone Price:', 2.5999))\n",
      "print(\"{0:>20s} {1:5.2f}\".format('Metazolone Price:', 2.5999))\n",
      "\n",
      "#using ** notation\n",
      "k = {\"Canada\":\"Ottawa\", \"USA\":\"Washington D.C\"}\n",
      "print(\"The capital of Canada is {Canada:s} & USA is {USA:s}\".format(**k))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "First argument: orange, Second argument: mango\n",
        "First argument: mango, Second argument: orange\n",
        "1st arg: 12345, 2nd arg: 123456789\n",
        "1st arg:     4, 2nd arg:   1234.78\n",
        "Drug_Index:  1234, Drug_Price:  12334.79\n",
        "Metazolone Price:     2.60\n",
        "   Metazolone Price:  2.60\n",
        "The capital of Canada is Ottawa & USA is Washington D.C\n"
       ]
      }
     ],
     "prompt_number": 362
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Functions"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Doc String\n",
      "def hello_name(name):\n",
      "    '''hello_name help. This function greets the user using his name'''\n",
      "    print(\"Hello {0}! Welcome to Python.\".format(name))\n",
      "hello_name(input(\"What is your name?\"))\n",
      "print(hello_name.__doc__)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "name": "stdout",
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "What is your name?Sri\n"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Hello Sri! Welcome to Python.\n",
        "hello_name help. This function greets the user using his name\n"
       ]
      }
     ],
     "prompt_number": 366
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Keyword Parameters\n",
      "def positional_param_func(a,b=0,c=0,d=0):\n",
      "    return a*d - b*c\n",
      "print(\"positional_parameters function: \" + str(positional_param_func(1,d=5)))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "positional_parameters function: 5\n"
       ]
      }
     ],
     "prompt_number": 374
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Global Variables\n",
      "def test_global_vars():\n",
      "    global glob_var\n",
      "    glob_var = glob_var*2\n",
      "    print(\"var updated\")\n",
      "\n",
      "glob_var = 2\n",
      "print(\"before calling function the value of glob_var = \" + str(glob_var))\n",
      "test_global_vars()\n",
      "print(\"after calling function the value of glob_var = \" + str(glob_var))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "before calling function the value of glob_var = 2\n",
        "var updated\n",
        "after calling function the value of glob_var = 4\n"
       ]
      }
     ],
     "prompt_number": 376
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Arbitrary Number of parameters\n",
      "def arbitrary_func_params(*args):   \n",
      "    total = 0\n",
      "    for item in args:\n",
      "        total = total+item\n",
      "    return total\n",
      "\n",
      "print(\"Total sum is: \" + str(arbitrary_func_params(5,10,15)))\n",
      "print(\"Total sum is: \" + str(arbitrary_func_params(5,10,15,20)))\n",
      "print(\"Total sum is: \" + str(arbitrary_func_params(5,10,15,20,25)))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Total sum is: 30\n",
        "Total sum is: 50\n",
        "Total sum is: 75\n"
       ]
      }
     ],
     "prompt_number": 384
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#factorial of a number using recursion\n",
      "def factorial(n):\n",
      "    if n == 1:\n",
      "        return 1\n",
      "    else:\n",
      "        return n*factorial(n-1)\n",
      "    \n",
      "numb = eval(input(\"Enter a number? \"))\n",
      "print(\"{0}! is: {1}\".format(numb,factorial(numb)))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "name": "stdout",
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Enter a number? 4\n"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "4! is: 24\n"
       ]
      }
     ],
     "prompt_number": 389
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Unit Testing"
     ]
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Using __name__"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Suppose you save the program in the following cell in a file named \"fiborecur.py\".\n",
      "If you import the function \"fibo\" using the statement \"from fiborecur import fibo\" and then call the fibo function using \"fibo(5)\" it will print 5.\n",
      "But if you run the program directly using the statement \"run fiborecur.py\" it will print \"Success!! The fibo module is working correctly!\".\n",
      "It is a nice way to include unit testing code in your program without affecting import functionality of module."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#This function returns the nth value in a fibonacci sequence\n",
      "def fibo(n):\n",
      "    mem = {0:0,1:1}\n",
      "\n",
      "    if n not in mem:\n",
      "        mem[n] = fibo(n-1) + fibo(n-2)\n",
      "    \n",
      "    return mem[n]\n",
      "\n",
      "if __name__ == \"__main__\":\n",
      "    if fibo(5) == 5 and fibo(10) == 55 and fibo(25) == 75025:\n",
      "        print(\"Success!! The fibo module is working correctly!\")\n",
      "    else:\n",
      "        print(\"Failure!! Your fibo module failed one or more test cases\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Using doctest Module"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Suppose you save the program in the following cell in a file named \"fiborecur.py\".\n",
      "If you import the function \"fibo\" using the statement \"from fiborecur import fibo\" and then call the fibo function using \"fibo(5)\" it will print 5.\n",
      "But if you run the program directly in the ****\"C or BOURNE SHELL\"**** using the statement \"python fiborecur.py\" it will return nothing if all the test conditions succeed. If any of the test conditions fail it will print the report on the screen."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import doctest\n",
      "#With recursion (Recursion is very inefficient for large n)\n",
      "def fibo(n):\n",
      "    '''\n",
      "    >>> fibo(5)\n",
      "    5\n",
      "\n",
      "    >>> fibo(10)\n",
      "    55\n",
      "\n",
      "    >>> fibo(25)\n",
      "    75025\n",
      "    '''\n",
      "    mem = {0:0,1:1}\n",
      "\n",
      "    if n not in mem:\n",
      "        mem[n] = fibo(n-1) + fibo(n-2)\n",
      "    \n",
      "    return mem[n]\n",
      "\n",
      "if __name__ == \"__main__\":\n",
      "    doctest.testmod()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Using unittest Module"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "First we create a test class lets call it \"TestFibo\". \"TestFibo\" should inherit from unittest.TestCase. The desired test cases are then defined in the test class in user defined methods whose names should start with \"test\". In our method \"test_fibo_results\" we use the method assertEqual from the class TestCase. assertEqual(first, second, msg = None) checks, if expression \"first\" is equal to the expression \"second\"."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import unittest\n",
      "from fiborecur import fibo\n",
      "\n",
      "class TestFibo(unittest.TestCase):\n",
      "\n",
      "    def test_fibo_results(self):\n",
      "        self.assertEqual(fibo(5), 5)\n",
      "        self.assertEqual(fibo(10), 55)\n",
      "        self.assertEqual(fibo(25), 75025)\n",
      "\n",
      "if __name__ == \"__main__\": \n",
      "    unittest.main()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Function Decorators"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def italics(the_function_that_will_be_wrapped):\n",
      "    def the_function_that_will_wrap():\n",
      "        return '<i>' + the_function_that_will_be_wrapped() + '</i>'\n",
      "    return the_function_that_will_wrap\n",
      "\n",
      "@italics\n",
      "def hello_world():\n",
      "    return \"Hello World!\"\n",
      "\n",
      "print(hello_world())"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "<i>Hello World!</i>\n"
       ]
      }
     ],
     "prompt_number": 491
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Functions are objects which means you can:"
     ]
    },
    {
     "cell_type": "heading",
     "level": 4,
     "metadata": {},
     "source": [
      "1. Assign functions to variables"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def greet(person):\n",
      "    return \"hello \" + person\n",
      "\n",
      "greet_fn_var = greet\n",
      "print(greet_fn_var(\"sri\"))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "hello sri\n"
       ]
      }
     ],
     "prompt_number": 492
    },
    {
     "cell_type": "heading",
     "level": 4,
     "metadata": {},
     "source": [
      "2. Define functions inside other functions"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def greet(person):\n",
      "    def get_message():\n",
      "        return \"Hello \"\n",
      "\n",
      "    greeting = get_message() + person\n",
      "    return greeting\n",
      "\n",
      "print(greet(\"Sri\"))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Hello Sri\n"
       ]
      }
     ],
     "prompt_number": 496
    },
    {
     "cell_type": "heading",
     "level": 4,
     "metadata": {},
     "source": [
      "3. Functions can be passed as parameters to other functions"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def get_greeting():\n",
      "    return \"Hello \"\n",
      "\n",
      "def build_message(get_fn):\n",
      "    return get_fn() + \"Sri\"\n",
      "\n",
      "print(build_message(get_greeting))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Hello Sri\n"
       ]
      }
     ],
     "prompt_number": 500
    },
    {
     "cell_type": "heading",
     "level": 4,
     "metadata": {},
     "source": [
      "4. Functions can return functions and Inner functions have access to the enclosing scope"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def return_build_message_fn(person):\n",
      "    def build_message():\n",
      "        return \"Hello \" + person\n",
      "    return build_message\n",
      "\n",
      "fn_ref = return_build_message_fn(\"Sri\") \n",
      "print(fn_ref())"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Hello Sri\n"
       ]
      }
     ],
     "prompt_number": 507
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Composition"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Function decorators are simply wrappers to existing functions. Putting the ideas mentioned above together, we can build a decorator. In this example let's consider a function that wraps the string output of another function by p tags."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def get_text(name):\n",
      "   return \"lorem ipsum, {0} dolor sit amet\".format(name)\n",
      "\n",
      "def p_decorate(func):\n",
      "   def func_wrapper(name):\n",
      "       return \"<p>{0}</p>\".format(func(name))\n",
      "   return func_wrapper\n",
      "\n",
      "decorate_get_text = p_decorate(get_text)\n",
      "\n",
      "print(decorate_get_text(\"John\"))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "<p>lorem ipsum, John dolor sit amet</p>\n"
       ]
      }
     ],
     "prompt_number": 515
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Python makes creating and using decorators a bit cleaner and nicer for the programmer through some syntactic sugar To decorate get_text we don't have to use decorate_get_text = p_decorator(get_text). There is a neat shortcut for that, which is to mention the name of the decorating function before the function to be decorated. The name of the decorator should be perpended with an @ symbol."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def p_decorate(func):\n",
      "   def func_wrapper(name):\n",
      "       return \"<p>{0}</p>\".format(func(name))\n",
      "   return func_wrapper\n",
      "\n",
      "@p_decorate\n",
      "def get_text(name):\n",
      "   return \"lorem ipsum, {0} dolor sit amet\".format(name)\n",
      "\n",
      "print(get_text(\"John\"))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "<p>lorem ipsum, John dolor sit amet</p>\n"
       ]
      }
     ],
     "prompt_number": 518
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Now let's consider we wanted to decorate our get_text function by 2 other functions to wrap a div and strong tag around the string output."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def p_decorate(func):\n",
      "   def func_wrapper(name):\n",
      "       return \"<p>{0}</p>\".format(func(name))\n",
      "   return func_wrapper\n",
      "\n",
      "def strong_decorate(func):\n",
      "    def func_wrapper(name):\n",
      "        return \"<strong>{0}</strong>\".format(func(name))\n",
      "    return func_wrapper\n",
      "\n",
      "def div_decorate(func):\n",
      "    def func_wrapper(name):\n",
      "        return \"<div>{0}</div>\".format(func(name))\n",
      "    return func_wrapper"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "With the basic approach, decorating get_text would be along the lines of"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "get_text = div_decorate(p_decorate(strong_decorate(get_text)))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "With Python's decorator syntax, same thing can be achieved with much more expressive power. One important thing to notice here is that the order of setting our decorators matters. If the order was different then the output would have be different."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "@div_decorate\n",
      "@p_decorate\n",
      "@strong_decorate\n",
      "def get_text(name):\n",
      "   return \"lorem ipsum, {0} dolor sit amet\".format(name)\n",
      "\n",
      "print(get_text(\"John\"))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Decorator Generator"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "You can notice how redundant the decorators in the example are. 3 decorators(div_decorate, p_decorate, strong_decorate) each with the same functionality but wrapping the string with different tags. We can definitely do much better than that. Why not have a more general implementation for one that takes the tag to wrap with as a string? It takes a bit more work in this case. Decorators expect to receive a function as an argument, that is why we will have to build a function that takes those extra arguments and generate our decorator on the fly. In this example tags, is our decorator generator."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\n",
      "def tags(tag_name):\n",
      "    def tags_decorator(func):\n",
      "        def func_wrapper(name):\n",
      "            return \"<{0}>{1}</{0}>\".format(tag_name, func(name))\n",
      "        return func_wrapper\n",
      "    return tags_decorator\n",
      "\n",
      "@tags(\"p\")\n",
      "def get_text(name):\n",
      "    return \"Hello \"+name\n",
      "\n",
      "print(get_text(\"John\"))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "<p>Hello John</p>\n"
       ]
      }
     ],
     "prompt_number": 528
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Method Decorators"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "In Python methods are member functions of classes. In Python, methods are functions that expect their first parameter to be a reference to the current object. We can build decorators for methods the same way, while taking self into consideration in the wrapper function."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def p_decorate(func):\n",
      "    print(\"in p_decorate\")\n",
      "    def func_wrapper(self,message):\n",
      "        print(\"in func_wrapper\")\n",
      "        return \"<p>{0}</p>\".format(func(self,message))\n",
      "    print(\"out func_wrapper\")\n",
      "    return func_wrapper\n",
      "\n",
      "class Person(object):\n",
      "    def __init__(self):\n",
      "        self.name = \"John\"\n",
      "        self.family = \"Doe\"\n",
      "\n",
      "    @p_decorate\n",
      "    def greet_fullname(self,message):\n",
      "        print(\"in get_fullname\")\n",
      "        return message + self.name + \" \" + self.family\n",
      "\n",
      "my_person = Person()\n",
      "print(my_person.greet_fullname(\"Hello \"))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "in p_decorate\n",
        "out func_wrapper\n",
        "in func_wrapper\n",
        "in get_fullname\n",
        "<p>Hello John Doe</p>\n"
       ]
      }
     ],
     "prompt_number": 522
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "A much better approach would be to make our decorator useful for functions and methods alike. This can be done by putting \\*args and \\**kwargs as parameters for the wrapper, then it can accept any arbitrary number of arguments and keyword arguments."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def p_decorate(func):\n",
      "   def func_wrapper(*args, **kwargs):\n",
      "       return \"<p>{0}</p>\".format(func(*args, **kwargs))\n",
      "   return func_wrapper\n",
      "\n",
      "class Person(object):\n",
      "    def __init__(self):\n",
      "        self.name = \"John\"\n",
      "        self.family = \"Doe\"\n",
      "\n",
      "    @p_decorate\n",
      "    def greet_fullname(self,message):\n",
      "        return message + self.name+\" \"+self.family\n",
      "\n",
      "my_person = Person()\n",
      "\n",
      "print(my_person.greet_fullname(\"Hello \"))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "<p>Hello John Doe</p>\n"
       ]
      }
     ],
     "prompt_number": 527
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def argument_test_natural_number(f):\n",
      "    def helper(x):\n",
      "        if type(x) == int and x > 0:\n",
      "            return f(x)\n",
      "        else:\n",
      "            raise Exception(\"Argument is not an integer\")\n",
      "    return helper\n",
      "\n",
      "@argument_test_natural_number\n",
      "def factorial(n):\n",
      "    if n == 1:\n",
      "        return 1\n",
      "    else:\n",
      "        return n * factorial(n-1)\n",
      "\n",
      "print(factorial(-1))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1\n"
       ]
      }
     ],
     "prompt_number": 2
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Memoization using class"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class Factorial:\n",
      "    def __init__(self):\n",
      "        self.cache = {}\n",
      "    def __call__(self, n):\n",
      "        if n not in self.cache:\n",
      "            if n == 0:\n",
      "                self.cache[n] = 1\n",
      "            else:\n",
      "                self.cache[n] = n * self.__call__(n-1)\n",
      "        return self.cache[n]\n",
      "\n",
      "fact = Factorial()\n",
      "#Now you have a fact object which is callable, just like every other function. For example\n",
      "for i in range(2):                                                             \n",
      "    print(\"{}! = {}\".format(i, fact(i)))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "0! = 1\n",
        "1! = 1\n"
       ]
      }
     ],
     "prompt_number": 18
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Functions: Call by value or Call by reference?"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Python initially behaves like call-by-reference, but as soon as we are changing the value of such a variable, i.e. as soon as we assign a new object to it, Python \"switches\" to call-by-value. This means, that a local variable x will be created and the value of the global variable x will be copied into it. "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def no_changes(fruits):\n",
      "    print(fruits)\n",
      "    fruits = fruits + [\"Banana\", \"Grapes\"]\n",
      "    print(fruits)\n",
      "\n",
      "fruits = [\"Leeches\", \"Mangoes\"]\n",
      "no_changes(fruits)\n",
      "print(fruits) # The value of the list fruits is unchanged."
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "['Leeches', 'Mangoes']\n",
        "['Leeches', 'Mangoes', 'Banana', 'Grapes']\n",
        "['Leeches', 'Mangoes']\n"
       ]
      }
     ],
     "prompt_number": 19
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def no_changes(fruits):\n",
      "    print(fruits)\n",
      "    fruits += [\"Banana\", \"Grapes\"] #Becareful! Augmented assignment operator changes the list in place\n",
      "    print(fruits)\n",
      "\n",
      "fruits = [\"Leeches\", \"Mangoes\"]\n",
      "no_changes(fruits)\n",
      "print(fruits)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "['Leeches', 'Mangoes']\n",
        "['Leeches', 'Mangoes', 'Banana', 'Grapes']\n",
        "['Leeches', 'Mangoes', 'Banana', 'Grapes']\n"
       ]
      }
     ],
     "prompt_number": 20
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def no_changes(fruits):\n",
      "    print(fruits)\n",
      "    fruits += [\"Banana\", \"Grapes\"] \n",
      "    print(fruits)\n",
      "\n",
      "fruits = [\"Leeches\", \"Mangoes\"]\n",
      "no_changes(fruits[:]) #Calling the function using a copy will keep the local list unchanged\n",
      "                      #Since the list in this case is not nested a shallow is enough\n",
      "print(fruits)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "['Leeches', 'Mangoes']\n",
        "['Leeches', 'Mangoes', 'Banana', 'Grapes']\n",
        "['Leeches', 'Mangoes']\n"
       ]
      }
     ],
     "prompt_number": 21
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Command Line Arguments"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "If you call a Python script from a shell, the arguments are placed after the script name. The arguments are separated by spaces. Inside of the script these argumetns are accessible through the list variable sys.argv. The name of the script is included in this list sys.argv[0]. sys.argv[1] contains the first parameter, sys.argv[2] the second and so on.\n",
      "The following script (arguments.py) prints all arguments: "
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "<b> Module sys has to be imported:</b>\n",
      "\n",
      "import sys                \n",
      "\n",
      "<b> Iteration over all arguments: </b>\n",
      "\n",
      "for eachArg in sys.argv:\n",
      "    \n",
      "    print(eachArg)"
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Functions with variable # of Arguments"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The asterisk \"*\" is used in Python to define a variable number of arguments. The asterisk character has to precede a variable identifier in the parameter list."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def var_arg_fn(*var_args):\n",
      "    print(var_args)\n",
      "var_arg_fn()\n",
      "var_arg_fn(\"Hello\",\"Sri\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "()\n",
        "('Hello', 'Sri')\n"
       ]
      }
     ],
     "prompt_number": 23
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "We learn from the previous example, that the arguments passed to the function call of varpafu() are collected in a tuple, which can be accessed as a \"normal\" variable x within the body of the function. If the function is called without any arguments, the value of x is an empty tuple.\n",
      "\n",
      "Sometimes, it's necessary to use positional parameters followed by an arbitrary number of parameters in a function definition. This is possible, but the positional parameters always have to precede the arbitrary parameters. In the following example, we have a positional parameter \"capital_city\", - which always has to be given, followed by an arbitrary number of other locations: "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def locations(capital_city, *other_cities): \n",
      "    print(\"Capital City is {0} and other cities are {1}\".format(capital_city, other_cities))\n",
      "locations(\"Delhi\",\"Hyderabad\", \"Bangalore\",\"Mumbai\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Capital City is Delhi and other cities are ('Hyderabad', 'Bangalore', 'Mumbai')\n"
       ]
      }
     ],
     "prompt_number": 28
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "* in Function calls"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "A * can appear in function calls as well. The semantics is in this case are \"inverse\" to a star in a function definition. An argument will be unpacked and not packed. In other words, the elements of the list or tuple are singularized: "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def arithmetic_mean(x, *l):\n",
      "    \"\"\" The function calculates the arithmetic mean of a non-empty\n",
      "        arbitrary number of numbers \"\"\"\n",
      "    sum = x\n",
      "    for i in l:\n",
      "        sum += i\n",
      "\n",
      "    return sum / (1.0 + len(l))\n",
      "\n",
      "y=(1.0,2.0,3.0,4.0)\n",
      "arithmetic_mean(*y) #Unpack the elements of the tuple and then call the function"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 30,
       "text": [
        "2.5"
       ]
      }
     ],
     "prompt_number": 30
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Arbitrary Keyword Parameters"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "There is also a mechanism for an arbitrary number of keyword parameters. To do this, we use the double asterisk \"**\" notation: "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def f(**args):\n",
      "    print(args)\n",
      "f(de=\"Germnan\",en=\"English\",fr=\"French\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "{'fr': 'French', 'de': 'Germnan', 'en': 'English'}\n"
       ]
      }
     ],
     "prompt_number": 42
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "** in Function calls"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 47
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Global and Local Variables"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def func():\n",
      "    print(s) #Since nothing was assigned to var s in this function. It is treated as global var\n",
      "             #so you can access it\n",
      "\n",
      "s=\"I was assigned outside func\" \n",
      "func()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def func():\n",
      "    s=\"I was assigned inside func\"\n",
      "    print(s) #Since you assigned a new string to s in func(). It is treated as local var\n",
      "\n",
      "s=\"I was assigned outside func\" \n",
      "func()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "I was assigned inside func\n"
       ]
      }
     ],
     "prompt_number": 53
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#The following program will generate an error because the interpreter does not know whether to \n",
      "#treat 's' a local or global var.\n",
      "def func():\n",
      "    print(s)\n",
      "    s=\"I was assigned inside func\"\n",
      "    print(s) \n",
      "\n",
      "s=\"I was assigned outside func\" \n",
      "func()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Also Local vars of functions can't be accessed from outside, when the function call has finished.\n",
      "def func():\n",
      "    s = \"I was assigned inside func\"\n",
      "\n",
      "func()\n",
      "print(s) #***For some strange reason this is printing in IPython Notebook***"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def func():\n",
      "    global s #Here we are explicitly telling the interpreter to treat s as global var\n",
      "    print(s)\n",
      "    s=\"I was assigned inside func\"\n",
      "    print(s)\n",
      "\n",
      "s=\"I was assigned outside func\" \n",
      "func()\n",
      "print(s)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "I was assigned outside func\n",
        "I was assigned inside func\n",
        "I was assigned inside func\n"
       ]
      }
     ],
     "prompt_number": 56
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "File Reading and Writing"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "A string is a sequence of Unicode characters. But a file on disk is not a sequence of Unicode characters; a file on disk is a sequence of bytes. So if you read a \u201ctext file\u201d from disk, how does Python convert that sequence of bytes into a sequence of characters? It decodes the bytes according to a specific character encoding algorithm and returns a sequence of Unicode characters (otherwise known as a string). So <b>Always</b> specify an encoding parameter when you open a file. "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Reading from file\n",
      "import os\n",
      "os.chdir(\"/Users/spaladug/PythonTraining\")\n",
      "fobj = open(\"infile.txt\",\"r\",encoding='US-ASCII') #Always specify an encoding parameter when you \n",
      "                                                  #open a file.\n",
      "print(\"Encoding: \" + fobj.encoding)\n",
      "print(\"Opening Mode: \" + fobj.mode)\n",
      "print(\"File name: \" + fobj.name)\n",
      "for line in fobj:\n",
      "    print(line.rstrip()) #S.rstrip([chars]) Returns a copy of the string S with trailing whitespace \n",
      "                         #removed. If chars is given & not None, remove characters in chars instead.\n",
      "fobj.close()# Do not forget to close files."
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Encoding: US-ASCII\n",
        "Opening Mode: r\n",
        "File name: infile.txt\n",
        "This is my first file reading excercise.\n",
        "I have never used python to read files.\n",
        "Uh! What a relief, now I know how to read files.\n"
       ]
      }
     ],
     "prompt_number": 102
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Writing to a file\n",
      "fh = open(\"/Users/spaladug/PythonTraining/fileout.txt\", \"w\", encoding=\"utf-8\")\n",
      "fh.write(\"To write or not to write\\n\" \\\n",
      "         \"that is the question!\\n\")\n",
      "fh.close() #Do not forget to close files after writing especially as it will lead to \n",
      "           #data inconsistency and hence corrupted files."
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 100
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "You will often find the with statement for reading and writing files. The advantage is that the file will be automatically closed after the indented block after the with has finished execution: "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Reading and writing simultaneously\n",
      "with open('/Users/spaladug/PythonTraining/infile.txt') as infile, \\\n",
      "     open('/Users/spaladug/PythonTraining/outfile.txt', 'w') as outfile:\n",
      "        i = 1\n",
      "        for line in infile:\n",
      "            print(line.rstrip())\n",
      "            outfile.write(str(i) + \": \" + line)\n",
      "            i += 1"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "This is my first file reading excercise.\n",
        "I have never used python to read files.\n",
        "Uh! What a relief, now I know how to read files.\n"
       ]
      }
     ],
     "prompt_number": 81
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "There is one possible problem, which we have to point out: What happens if we open a file for writing, and this file already exists. You can consider yourself fortunate, if the content of this file was of no importance, or if you have a backup of it. Otherwise you have a problem, because as soon as an open() with a \"w\" has been executed the file will be removed. This is often what you want, but sometimes you just want to append to the file, like it's the case with logfiles.\n",
      "If you want to append something to an existing file, you have to use \"a\" instead of \"w\"."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "So far we worked on files line by line by using a for loop. Very often, especially if the file is not too large, it's more convenient to read the file into a complete data structure, e.g. a string or a list. The file can be closed after reading and the work is accomplished on this data structure: "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "text_in_entirefile = open('/Users/spaladug/PythonTraining/infile.txt',\"r\",encoding=\"utf-8\").readlines()\n",
      "print(text_in_entirefile[0].rstrip())"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "This is my first file reading excercise.\n"
       ]
      }
     ],
     "prompt_number": 89
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Resetting the File's Current Postion"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "It is possible to set a file's position to a desired position, by using the seek. To work with seek, we will often need the method tell, which \"tells\" us the current position. "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "fobj = open('/Users/spaladug/PythonTraining/infile.txt',\"r\")\n",
      "print(fobj.tell())\n",
      "print(fobj.read(10))\n",
      "print(fobj.tell())\n",
      "print(fobj.read().rstrip())\n",
      "print(fobj.tell())\n",
      "fobj.seek(11)\n",
      "print(fobj.read(5))\n",
      "print(fobj.seek(fobj.tell()-5)) #It's also possible to set the file position relative to the current\n",
      "                                # position by using tell.\n",
      "print(fobj.read(5))\n",
      "fobj.close()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "0\n",
        "This is my\n",
        "10\n",
        " first file reading excercise.\n",
        "I have never used python to read files.\n",
        "Uh! What a relief, now I know how to read files.\n",
        "130\n",
        "first\n",
        "11\n",
        "first\n"
       ]
      }
     ],
     "prompt_number": 95
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Reading Binary Files"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Not all files contain text. Some of them contain pictures. Opening a file in binary mode is simple but subtle. The only difference from opening it in text mode is that the mode parameter contains a 'b' character. A binary stream object has no encoding attribute. That makes sense, right? You\u2019re reading (or writing) bytes, not strings, so there\u2019s no conversion for Python to do. What you get out of a binary file is exactly what you put into it, no conversion necessary. "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "an_image = open('dhruv.jpg', mode='rb')\n",
      "close(an_image)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Serialization"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "On the surface, the concept of serialization is simple. You have a data structure in memory that you want to save, reuse, or send to someone else. How would you do that? Well, that depends on how you want to save it, how you want to reuse it, and to whom you want to send it. Many games allow you to save your progress when you quit the game and pick up where you left off when you relaunch the game. (Actually, many non-gaming applications do this as well.) In this case, a data structure that captures \u201cyour progress so far\u201d needs to be stored on disk when you quit, then loaded from disk when you relaunch. The data is only meant to be used by the same program that created it, never sent over a network, and never read by anything other than the program that created it. Therefore, the interoperability issues are limited to ensuring that later versions of the program can read data written by earlier versions.\n",
      "\n",
      "For cases like this, the pickle module is ideal. It\u2019s part of the Python standard library, so it\u2019s always available. It\u2019s fast; the bulk of it is written in C, like the Python interpreter itself. It can store arbitrarily complex Python data structures. "
     ]
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Pickle Module"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The pickle module takes a Python data structure and saves it to a file. Be sure to open your pickle files in binary mode, or the data will get corrupted during writing. "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import pickle\n",
      "\n",
      "dic_struct = {\n",
      "\"fruits\":[\"apple\",\"banana\",\"clementine\"],\n",
      "\"cars\" : (\"audi\",\"BMW\",\"camry\")\n",
      "}\n",
      "\n",
      "print(\"dic_struct = \" + str(dic_struct))\n",
      "\n",
      "with open('dic_struct.pickle', 'wb') as fp:\n",
      "    pickle.dump(dic_struct, fp)\n",
      "\n",
      "with open('dic_struct.pickle', 'rb') as fup:\n",
      "    dic_struct_unpickled = pickle.load(fup)\n",
      "\n",
      "print(\"dic_struct_unpickled = \" + str(dic_struct_unpickled))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "dic_struct = {'fruits': ['apple', 'banana', 'clementine'], 'cars': ('audi', 'BMW', 'camry')}\n",
        "dic_struct_unpickled = {'fruits': ['apple', 'banana', 'clementine'], 'cars': ('audi', 'BMW', 'camry')}\n"
       ]
      }
     ],
     "prompt_number": 110
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The examples in the previous section showed how to serialize a Python object directly to a file on disk. But what if you don\u2019t want or need a file? You can also serialize to a bytes object in memory. \n",
      "\n",
      "The pickle.dumps( ) function (note the 's' at the end of the function name) performs the same serialization as the pickle.dump( ) function. Instead of taking a stream object and writing the serialized data to a file on disk, it simply returns the serialized data.\n",
      "\n",
      "The pickle.loads( ) function (again, note the 's' at the end of the function name) performs the same deserialization as the pickle.load( ) function. Instead of taking a stream object and reading the serialized data from a file, it takes a bytes object containing serialized data, such as the one returned by the pickle.dumps( ) function. "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import pickle\n",
      "\n",
      "dic_struct = {\n",
      "\"fruits\":[\"apple\",\"banana\",\"clementine\"],\n",
      "\"cars\" : (\"audi\",\"BMW\",\"camry\")\n",
      "}\n",
      "\n",
      "b = pickle.dumps(dic_struct)\n",
      "print(type(b))\n",
      "dic_struct_unpickled = pickle.loads(b)\n",
      "print(dic_struct_unpickled)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "<class 'bytes'>\n",
        "{'fruits': ['apple', 'banana', 'clementine'], 'cars': ('audi', 'BMW', 'camry')}\n"
       ]
      }
     ],
     "prompt_number": 112
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import pickletools\n",
      "with open('dic_struct.pickle', 'rb') as f:\n",
      "    pickletools.dis(f)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The most interesting piece of information in that disassembly is on the last line, because it includes the version of the pickle protocol with which this file was saved. There is no explicit version marker in the pickle protocol. To determine which protocol version was used to store a pickle file, you need to look at the markers (\u201copcodes\u201d) within the pickled data and use hard-coded knowledge of which opcodes were introduced with each version of the pickle protocol. "
     ]
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Shelve Module"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "pickle is for serializing some object (or objects) as a single bytestream in a file.\n",
      "\n",
      "shelve builds on top of pickle, it implements a serialization dictionary where objects are not only pickled but are also associated with a key (some string), so you can load your shelved data file and access your pickled objects via keys. This could be more convenient if you were to serialize many objects.\n",
      "\n",
      "<b>Because the shelve module is backed by pickle, it is insecure to load a shelf from an untrusted source. Like with pickle, loading a shelf can execute arbitrary code.</b>\n",
      "\n",
      "The shelve module can be easily used. Actually, it is as easy as using a dictionay in Python. Before we can use a shelf object, we have to import the module. After this, we have to open a shelve object with the shelve method open. The open method opens a special shelf file for reading and writing: "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import shelve\n",
      "contacts = shelve.open(\"contacts\")\n",
      "contacts[\"Sri\"] = {\"First\":\"Sri\",\"Last\":\"Paladugu\",\"Phone\":\"909-72-5891\"}\n",
      "contacts[\"Dhruv\"] = {\"First\":\"Dhruv\",\"Last\":\"Paladugu\",\"Phone\":\"510-764-6553\"}\n",
      "contacts.close()\n",
      "\n",
      "recontacts = shelve.open(\"contacts\")\n",
      "print(recontacts) #recontacts is a shelf\n",
      "print(recontacts[\"Sri\"]) # retrieve the value for the key \"Sri\"\n",
      "print(dict(recontacts)) # convert the shelf into a dictionary\n",
      "recontacts.close()\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "<shelve.DbfilenameShelf object at 0x103f2f2b0>\n",
        "{'Phone': '909-72-5891', 'Last': 'Paladugu', 'First': 'Sri'}\n",
        "{'Dhruv': {'Phone': '510-764-6553', 'Last': 'Paladugu', 'First': 'Dhruv'}, 'Sri': {'Phone': '909-72-5891', 'Last': 'Paladugu', 'First': 'Sri'}}\n"
       ]
      }
     ],
     "prompt_number": 117
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Reloading Python Modules"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from importlib import reload\n",
      "import os\n",
      "os.listdir()\n",
      "import fiboiter\n",
      "reload(fiboiter)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 126,
       "text": [
        "<module 'fiboiter' from '/Users/spaladug/PythonTraining/fiboiter.py'>"
       ]
      }
     ],
     "prompt_number": 126
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "A module has a private symbol table, which is used as the global symbol table by all functions defined in the module. This is a way to prevent that a global variable of a module accidentally clashes with a user's global variable with the same name. Global variables of a module can be accessed with the same notation as functions, i.e. modname.name\n",
      "\n",
      "Don't forget the caveats of using this method : When a module is reloaded, its dictionary (containing the module\u2019s global variables) is retained . Redefinitions of names will override the old definitions, so this is generally not a problem. If the new version of a module does not define a name that was defined by the old version, the old definition remains"
     ]
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Executing Modules as Scripts"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Fibonacci sequence generator\n",
      "#Now save this script in the file fiboiter.py\n",
      "#In IPython u can run this script using command: run fiboiter 10\n",
      "#In python command line u can run this script using the command: python fiboiter.py 10  \n",
      "def fibo(n):\n",
      "    a = 0\n",
      "    b = 1\n",
      "    for i in range(n):\n",
      "        a, b = b, a+b\n",
      "    return a\n",
      "\n",
      "if __name__ == \"__main__\":\n",
      "    import sys\n",
      "    print(fibo(int(sys.argv[1])))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Renaming a Namespace"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "While importing a module, you can rename namespace as desired. For example in the following \n",
      "example the namespace math is imported as mathematics"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math as mathematics\n",
      "print(mathematics.tan(mathematics.pi/3))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1.7320508075688767\n"
       ]
      }
     ],
     "prompt_number": 129
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "It is also possible to import just a few methods from a module."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from math import pi, pow as power, sin as sinus\n",
      "print(power(2,3))\n",
      "print(sinus(pi/2))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "8.0\n",
        "1.0\n"
       ]
      }
     ],
     "prompt_number": 131
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Module search path"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      " If you import a module, let's say \"import abc\", the interpreter searches for this module in the following locations and in the order given:\n",
      "    1. The directory of the top-level file, i.e. the file being executed. \n",
      "    \n",
      "    2. The directories of PYTHONPATH, if this global variable is set.\n",
      "\n",
      "    3. standard installation path Linux/Unix e.g. in /usr/lib/python2.5. \n",
      "    \n",
      "It's possible to find out where a module is located after it has been imported: "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math, random\n",
      "print(math.__file__)\n",
      "print(random.__file__)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "/Users/spaladug/anaconda/lib/python3.4/lib-dynload/math.so\n",
        "/Users/spaladug/anaconda/lib/python3.4/random.py\n"
       ]
      }
     ],
     "prompt_number": 3
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Content of a module"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#With the built-in function dir() and the name of the module as an argument, you can list all valid \n",
      "#attributes and methods for that module. \n",
      "print(dir(math))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "['__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'hypot', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']\n"
       ]
      }
     ],
     "prompt_number": 7
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Calling dir() without an argument, a list with the names in the current local scope is returned.\n",
      "import math\n",
      "fruits = [\"apple\",\"banana\",\"clementine\"]\n",
      "print(dir())"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "['In', 'Out', '_', '_1', '_4', '_8', '__', '___', '__builtin__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', '_dh', '_i', '_i1', '_i10', '_i2', '_i3', '_i4', '_i5', '_i6', '_i7', '_i8', '_i9', '_ih', '_ii', '_iii', '_oh', '_sh', 'exit', 'fruits', 'get_ipython', 'math', 'quit', 'random']\n"
       ]
      }
     ],
     "prompt_number": 10
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#It is possible to get a list of the built-in functions.\n",
      "print(dir(__builtin__))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Module Packages"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "It's possible to put several modules into a Package. A directory of Python code is said to be a package.\n",
      "A package is imported like a \"normal\" module.\n",
      "Each directory named within the path of a package must also contain a file named __init__.py, or else your package import will fail. "
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Regular Expressions"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Reference[Book]: Core Python Application Programming"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "If you want to use regular expressions in Python, you have to import the <b>re</b> module, which provides methods and functions to deal with regular expressions.\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import re\n",
      "if (re.search(\"cat\",\"Hey, cats and dogs are not friends\")):\n",
      "    print(\"Found a cat\")\n",
      "else:\n",
      "    print(\"cat not found\")\n",
      "x = re.search(\"cat\",\"Hey, cats and dogs are not friends\")\n",
      "print(x)\n",
      "y = re.search(\"cow\",\"Hey, cats and dogs are not friends\")\n",
      "print(y)\n",
      "z = re.search(r\".at\",\"Hey, cats and dogs are not friends\")\n",
      "print(z)\n",
      "\n",
      "if (re.search(r\"[aA]pple\",\"Apple, apple\")):\n",
      "    print(\"Found\")\n",
      "else:\n",
      "    print(\"Not Found\")\n",
      "\n",
      "print(re.search(r\"[aA]pple\",\"Apple, apple\"))\n",
      "print(re.search(r\"[A-Za-z]pple\",\"Apple, apple\"))\n",
      "print(re.search(r\"[a-z]pple[1-9]*\",\"apple123\"))\n",
      "#If caret \"^\" is used directly after an opening sqare bracket, it negates the choice \n",
      "#So [^0-9] denotes the choice \"any character but a digit\"\n",
      "print(re.search(r\"[^a-z]pple[1-9]*\",\"1pple123\"))\n",
      "\n",
      "#Word Boundary\n",
      "print(re.search(r\"\\bgood\\b\",\"I am a good boy\"))# /bword/b matches word boundary\n",
      "print(re.search(r\"\\bgood\",\"I am a goodboy\"))# contains word \"goodboy\" which starts with good\n",
      "print(re.search(r\"good\\b\",\"I am verygood boy\"))# contains word \"verygood\" which ends with good\n",
      "print(re.search(r\"\\Bgood\",\"I am verygoodboy\"))# The sentence should contain but not begin with word \n",
      "                                              # \"good\"\n",
      "\n",
      "#Multiple Occurence - Repetition using closure operators\n",
      "print(re.search(r\"I am( good)? boy\",\"I am boy\")) #If you want to make good optional. i.e., the regex\n",
      "print(re.search(r\"I am( good)? boy\",\"I am good boy\"))# should match whether good is present or not.\n",
      "print(re.search(r\"ap{2}le\",\"apple\")) #{N} - N occurences of preceding char\n",
      "print(re.search(r\"ap{2,5}le\",\"apppple\")) #{M,N} - M to N occurences of preceding char\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "raw",
     "metadata": {},
     "source": [
      "\\d \tMatches any decimal digit; equivalent to the set [0-9].\n",
      "\\D \tThe complement of \\d. It matches any non-digit character; equivalent to the set [^0-9].\n",
      "\\s \tMatches any whitespace character; equivalent to [ \\t\\n\\r\\f\\v].\n",
      "\\S \tThe complement of \\s. It matches any non-whitespace character; equiv. to [^ \\t\\n\\r\\f\\v].\n",
      "\\w \tMatches any alphanumeric character; equivalent to [a-zA-Z0-9_]. With LOCALE, it will match the set [a-zA-Z0-9_] plus characters defined as letters for the current locale.\n",
      "\\W \tMatches the complement of \\w.\n",
      "\\b \tMatches the empty string, but only at the start or end of a word.\n",
      "\\B \tMatches the empty string, but not at the start or end of a word.\n",
      "\\\\ \tMatches a literal backslash."
     ]
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Matching strings with match()"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# match() only works if the pattern is at the begining of the string\n",
      "print(re.match(\"foo\",\"food on the table\").group())\n",
      "\n",
      "m = re.match(\"foo\", \"food on the table\")\n",
      "if m is not None:\n",
      "    print(m.group())"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "foo\n",
        "foo\n"
       ]
      }
     ],
     "prompt_number": 79
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Searching vs Matching"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The chances are greater that the pattern you seek is somewhere in the middle\n",
      "of a string, rather than at the beginning. This is where search() comes\n",
      "in handy. Note that the equivalent\n",
      "regex object methods optionally take pos and endpos arguments to\n",
      "specify the search boundaries of the target string."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(re.search(\"foo\",\"put food on the table\").group())\n",
      "\n",
      "regexp = \"bat|cat|hat|rat\"\n",
      "s = re.search(regexp, \"tiger is a cat\")\n",
      "m = re.match(regexp, \"tiger is a cat\")\n",
      "if s is not None:\n",
      "    print(\"search succeded: \" + s.group())\n",
      "else:\n",
      "    print(\"search failed\")\n",
      "\n",
      "if m is not None:\n",
      "    print(\"match succeded\" + m.group())\n",
      "else:\n",
      "    print(\"match failed\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "foo\n",
        "search succeded: cat\n",
        "match failed\n"
       ]
      }
     ],
     "prompt_number": 82
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Designating Groups with Parentheses ( ( ) )"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "One good example of why you would want to group regular expressions\n",
      "is when you have two different regexes with which you want to\n",
      "compare a string. Another reason is to group a regex in order to use a repetition\n",
      "operator on the entire regex (as opposed to an individual character\n",
      "or character class). One side effect of using parentheses is that the substring that matched\n",
      "the pattern is saved for future use. These subgroups can be recalled for the\n",
      "same match or search, or extracted for post-processing."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Regular expression patterns must be\n",
      "compiled into regex objects before any pattern matching can occur. For regexes,\n",
      "which are compared many times during the course of execution, we highly\n",
      "recommend using precompilation because, again, regexes have to be compiled\n",
      "anyway, so doing it ahead of time is prudent for performance reasons.\n",
      "re.compile() provides this functionality."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(\"#* 1 *#\")\n",
      "m = re.match(\"(\\w\\w\\w)-(\\d\\d\\d)\",\"abc-123\")\n",
      "if m is not None:\n",
      "    print(m.group())  # entire match\n",
      "    print(m.groups()) # all subgroups\n",
      "    print(m.group(0)) # same as m.group()\n",
      "    print(m.group(1)) # subgroup 1\n",
      "    print(m.group(2)) # subgroup 2\n",
      "    \n",
      "print(\"#* 2 *#\")\n",
      "m = re.match(\"(ab)\",\"ab\")\n",
      "if m is not None:\n",
      "    print(m.group())  # entire match\n",
      "    print(m.groups()) # all subgroups\n",
      "    print(m.group(1)) # subgroup 1\n",
      "\n",
      "print(\"#* 3 *#\")\n",
      "m = re.match(\"(a)(b)\",\"ab\")\n",
      "if m is not None:\n",
      "    print(m.group())  # entire match\n",
      "    print(m.groups()) # all subgroups\n",
      "    print(m.group(1)) # subgroup 1\n",
      "    print(m.group(2)) # subgroup 1\n",
      "\n",
      "print(\"#* 4 *#\")\n",
      "m = re.match(\"a(b)\",\"ab\")\n",
      "if m is not None:\n",
      "    print(m.group())  # entire match\n",
      "    print(m.groups()) # all subgroups\n",
      "    print(m.group(1)) # subgroup 1\n",
      "\n",
      "print(\"#* 5 *#\")\n",
      "m = re.match(\"((a)(b))\",\"ab\")\n",
      "if m is not None:\n",
      "    print(m.group())  # entire match\n",
      "    print(m.groups()) # all subgroups\n",
      "    print(m.group(0)) # same as m.group()\n",
      "    print(m.group(1)) # subgroup 1\n",
      "    print(m.group(2)) # subgroup 2\n",
      "    print(m.group(3)) # subgroup 3"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#This example illustrates how grouping using () can be referenced using \\1, \\2, \\3 etc.\n",
      "#In this case we are telling the interpreter to search for aa or pp pattern.\n",
      "n = re.search(r\"([ap])\\1\",\"maaple syrup\")\n",
      "if n is not None:\n",
      "    print(\"matched\")\n",
      "else:\n",
      "    print(\"not matched\")\n",
      "print(n.group())"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "matched\n",
        "aa\n"
       ]
      }
     ],
     "prompt_number": 197
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Finding Every Occurrence with findall()\n",
      "and finditer()"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "findall() looks for all non-overlapping occurrences of a regex pattern in a\n",
      "string. It is similar to search() in that it performs a string search, but it differs\n",
      "from match() and search() in that findall() always returns a list."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(re.findall('CAR', 'carry the barcardi to the car',re.I)) #re.I => ignore care\n",
      "print(re.finditer(r\"(Th\\w+) and (Th\\w+)\", \"That and This\").__next__().groups())\n",
      "print(next(re.finditer(r\"(Th\\w+) and (Th\\w+)\", \"That and This\")).groups())\n",
      "[g.groups() for g in re.finditer(r\"(Th\\w+) and (Th\\w+)\", \"That and This\")]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "['car', 'car', 'car']\n",
        "('That', 'This')\n",
        "('That', 'This')\n"
       ]
      },
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 112,
       "text": [
        "[('That', 'This')]"
       ]
      }
     ],
     "prompt_number": 112
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Searching and Replacing with sub()\n",
      "and subn()"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "There are two functions/methods for search-and-replace functionality: sub()\n",
      "and subn(). They are almost identical and replace all matched occurrences\n",
      "of the regex pattern in a string with some sort of replacement. The\n",
      "replacement is usually a string, but it can also be a function that returns a\n",
      "replacement string. subn() is exactly the same as sub(), but it also returns\n",
      "the total number of substitutions made\u2014both the newly substituted string\n",
      "and the substitution count are returned as a 2-tuple."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(re.sub('X', 'Mr. Smith', 'attn: X \\t Dear X'))\n",
      "print(re.subn('X', 'Mr. Smith', 'attn: X \\t Dear X'))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "attn: Mr. Smith \t Dear Mr. Smith\n",
        "('attn: Mr. Smith \\t Dear Mr. Smith', 2)\n"
       ]
      }
     ],
     "prompt_number": 117
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "As we saw in an earlier section, in addition to being able to pull out the\n",
      "matching group number using the match object\u2019s group() method, you can\n",
      "use \\N, where N is the group number to use in the replacement string.\n",
      "Below, we\u2019re just converting the American style of date presentation, MM/\n",
      "DD/YY{,YY} to the format used by all other countries, DD/MM/YY{,YY}:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(re.sub(r'(\\d{1,2})/(\\d{1,2})/(\\d{2}|\\d{4})', r'\\2/\\1/\\3', '12/16/1999'))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "16/12/1999\n"
       ]
      }
     ],
     "prompt_number": 122
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "There are raw string literals, which are exactly the string literals marked by a 'r' before the opening quote. Ex:- r'. . .'\n",
      "\n",
      "A \"raw string literal\" is a slightly different syntax for a string literal, in which a backslash, \\, is taken as meaning \"just a backslash\" (except when it comes right before a quote that would otherwise terminate the literal) -- no \"escape sequences\" to represent newlines, tabs, backspaces, form-feeds, and so on. In normal string literals, each backslash must be doubled up to avoid being taken as the start of an escape sequence.\n",
      "\n",
      "This syntax variant exists mostly because the syntax of regular expression patterns is heavy with backslashes (but never at the end, so the \"except\" clause above doesn't matter) and it looks a bit better when you avoid doubling up each of them -- that's all. It also gained some popularity to express native Windows file paths (with backslashes instead of regular slashes like on other platforms), but that's very rarely needed (since normal slashes mostly work fine on Windows too) and imperfect (due to the \"except\" clause above).\n",
      "\n",
      "r'. . .' is a byte string, ru'. . .' and ur'. . .' are Unicode strings, and any of the other three kinds of quoting also produces exactly the same types of strings (so for example r'. . .', r'''. . .''', r\". . .\", r\"\"\". . .\"\"\" are all byte strings, and so on).\n",
      "\n",
      "In Python, u'. . .' is of course always distinct from just '. . .' -- the former is a unicode string, the latter is a byte string. The Unicode object of course takes more memory space"
     ]
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Extension Notations (?...)"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "(?...) is an extension notation and not a group specifier. The first character after the \"?\" determines what the meaning and further syntax of the construct is. Following are some currently supported extensions.\n",
      "\n",
      "With the (?iLmsux) set of options, users can specify one or more flags\n",
      "directly into a regular expression rather than via compile() or other re\n",
      "module functions."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(re.findall(r'(?i)yes', 'yes? Yes. YES!!'))\n",
      "#?i - ignore case. ?m - multiline\n",
      "print(re.findall(r'(?im)(^th[\\w ]+)', \"\"\"\n",
      "This is the firstline.\n",
      "another line,\n",
      "this line is third\n",
      "\"\"\"))\n",
      "# ?s is dotall\n",
      "print(re.findall(r'(?s)th.+', \"\"\" \n",
      "This is the firstline.\n",
      "another line,\n",
      "this line is third\n",
      "\"\"\"))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The re.X/VERBOSE flag is quite interesting; it lets users create more\n",
      "human-readable regular expressions by suppressing whitespace characters\n",
      "within regexes (except those in character classes or those that are\n",
      "backslash-escaped). Furthermore, <b><i>hash/comment/octothorpe symbols (#)\n",
      "can also be used to start a comment</i></b>, also as long as they\u2019re not within a\n",
      "character class backslash-escaped."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "k = re.search(r\"\\((\\d{3})\\) (\\d{3})-(\\d{4})\", '(800) 555-1212')\n",
      "if k is not None:\n",
      "    print(\"matched\")\n",
      "else:\n",
      "    print(\"not-matched\")\n",
      "\n",
      "#The following code is equivalent to the above code but it is much cleaner\n",
      "# and self explanatory because of the comments.\n",
      "#See the example below, the code can be aligned as you like since whitespace \n",
      "# is not considered part of regex (unless u escape with \\ or place it in []).\n",
      "#You can even place comments.\n",
      "m = re.search(r'''(?x)\n",
      "          \\((\\d{3})\\) # area code\n",
      "          [ ]  # space\n",
      "          (\\d{3}) # prefix\n",
      "          - # dash\n",
      "          (\\d{4}) # endpoint number\n",
      "          ''', '(800) 555-1212')\n",
      "print(m.groups())\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "matched\n",
        "('800', '555', '1212')\n"
       ]
      }
     ],
     "prompt_number": 217
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#(?:...) A non-capturing version of regular parentheses. Matches whatever regular expression is \n",
      "#inside the parentheses, but the substring matched by the group cannot be retrieved after \n",
      "#performing a match or referenced later in the pattern.\n",
      "\n",
      "n = re.search(r\"([ap])\\1\",\"maaple syrup\") #backreferencing allowed\n",
      "print(n.group())\n",
      "n = re.search(r\"(?:[ap])[ap]\",\"maaple syrup\") #backreferencing not allowed\n",
      "print(n.group())\n",
      "\n",
      "#The (?:...) notation should be fairly popular; with it, you can group\n",
      "#parts of a regex, but it does not save them for future retrieval or use. This\n",
      "#comes in handy when you don\u2019t want superfluous matches that are saved\n",
      "#and never used\n",
      "print(re.findall(r'http://(?:\\w+\\.)*(\\w+\\.com)','''http://www.google.com, http://google.com, \n",
      "http://code.google.com'''))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "aa\n",
        "aa\n",
        "['google.com', 'google.com', 'google.com']\n"
       ]
      }
     ],
     "prompt_number": 215
    },
    {
     "cell_type": "raw",
     "metadata": {},
     "source": [
      "You can use the (?P<name>) and (?P=name) notations together. The former\n",
      "saves matches by using a name identifier rather than using increasing\n",
      "numbers, starting at one and going through N, which are then retrieved\n",
      "later by using \\1, \\2, ... \\N. You can retrieve them in a similar manner\n",
      "using \\g<name>."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(re.search(r'\\((?P<areacode>\\d{3})\\) (?P<prefix>\\d{3})-(?P<lastfour>\\d{4})',\n",
      "          '(800) 555-1212').groupdict())\n",
      "\n",
      "#backreferencing (?P<name>) using (?P=name)\n",
      "print(bool(re.search(r'''(?x)\n",
      "        (?P<month>\\d{2})-(?P<day>\\d{2})-(?P<year>\\d{4})\n",
      "        [ ]\n",
      "        (?P=month)\\.(?P=day)\\.(?P=year)\n",
      "        [ ]\n",
      "        \\((?P=month)\\) \\((?P=day)\\) \\((?P=year)\\)\n",
      "        '''\n",
      ",'12-16-1998 12.16.1998 (12)(16)(1998)')))\n",
      "\n",
      "#substitution\n",
      "print(re.sub(r'(?P<month>\\d{2})[-/.](?P<day>\\d{2})[-/.](?P<year>\\d{4})',\n",
      "          '\\g<day>/\\g<month>/\\g<year>','12-16-1998'))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "{'lastfour': '1212', 'areacode': '800', 'prefix': '555'}\n",
        "True\n",
        "16/12/1998\n"
       ]
      }
     ],
     "prompt_number": 241
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "You use the (?=...) and (?!...) notations to perform a lookahead in\n",
      "the target string without actually consuming those characters. The first is\n",
      "the positive lookahead assertion, while the latter is the negative."
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(re.findall(r'\\w+(?= van Rossum)',\n",
      " '''\n",
      " Guido van Rossum\n",
      " Tim Peters\n",
      " Alex Martelli\n",
      " Just van Rossum\n",
      " Raymond Hettinger\n",
      " '''))\n",
      "\n",
      "print(re.findall(r'(?m)^\\s+(?!noreply|postmaster)(\\w+)',\n",
      "'''\n",
      " sales@phptr.com\n",
      " postmaster@phptr.com\n",
      " eng@phptr.com\n",
      " noreply@phptr.com\n",
      " admin@phptr.com\n",
      " '''))\n",
      "\n",
      "['{}@aw.com'.format(e.group(1)) for e in \\\n",
      " re.finditer(r'(?m)^\\s+(?!noreply|postmaster)(\\w+)',\n",
      " '''\n",
      " sales@phptr.com\n",
      " postmaster@phptr.com\n",
      " eng@phptr.com\n",
      " noreply@phptr.com\n",
      " admin@phptr.com\n",
      " ''')]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "['Guido', 'Just']\n",
        "['sales', 'eng', 'admin']\n"
       ]
      },
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 250,
       "text": [
        "['sales@aw.com', 'eng@aw.com', 'admin@aw.com']"
       ]
      }
     ],
     "prompt_number": 250
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Splitting (on Delimiting Pattern) with\n",
      "split()"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The re module and regex object method split() work similarly to its\n",
      "string counterpart, but rather than splitting on a fixed string, they split a\n",
      "string based on a regex pattern, adding some significant power to string\n",
      "splitting capabilities. If you do not want the string split for every occurrence\n",
      "of the pattern, you can specify the maximum number of splits by setting\n",
      "a value (other than zero) to the max argument."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(re.split(':', 'str1:str2:str3'))\n",
      "\n",
      "DATA = (\n",
      " 'Mountain View, CA 94040',\n",
      " 'Sunnyvale, CA',\n",
      " 'Los Altos, 94023',\n",
      " 'Cupertino 95014',\n",
      " 'Palo Alto CA',\n",
      " )\n",
      "\n",
      "for datum in DATA:\n",
      "    print(re.split(', |(?= (?:\\d{5}|[A-Z]{2})) ', datum))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "['str1', 'str2', 'str3']\n",
        "['Mountain View', 'CA', '94040']\n",
        "['Sunnyvale', 'CA']\n",
        "['Los Altos', '94023']\n",
        "['Cupertino', '95014']\n",
        "['Palo Alto', 'CA']\n"
       ]
      }
     ],
     "prompt_number": 126
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Conditional regular expressions"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The regex conditional is an IF\u2026THEN\u2026ELSE construct. Its basic form is this:\n",
      "(?(A)X|Y)\n",
      "This means \"if proposition A is true, then match pattern X; otherwise, match pattern Y.\"\n",
      "\n",
      "Often, you don't need the ELSE case or the THEN case:\n",
      "<ul>\n",
      "    <li> \n",
      "        (?(A)X) says \"if proposition A is true, then match pattern X.\" \n",
      "        (?(A)X|) means the same \u2014 but the alternation bar can be dropped.\n",
      "    </li>\n",
      "    <li>\n",
      "        (?(A)|X) amounts to saying \"if proposition A is not true, then match pattern X.\" \n",
      "        If you translate the IF\u2026THEN\u2026ELSE construction literally, it says \n",
      "        \"if proposition A is true, then match the empty string (which always matches at every position),\n",
      "        otherwise match pattern X.\"\n",
      "    </li>\n",
      "</ul>\n",
      "To check if a numbered capture group has been set, we use something like:\n",
      "    (?(1)foo|bar)\n",
      "In this exact pattern, if Group 1 has been set, the engine must match the literal characters foo. \n",
      "If not, it must match the literal characters bar."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "bool(re.search(r'(?:(x)|y)(?(1)y|x)', 'xy'))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 251,
       "text": [
        "True"
       ]
      }
     ],
     "prompt_number": 251
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Lambda, filter, reduce and map"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Ref: <a href=\"http://www.python-course.eu/python3_lambda.php\">www.phython-course.eu</a>\n",
      "\n",
      "The lambda operator or lambda function is a way to create small anonymous functions, i.e. functions without a name. These functions are throw-away functions, i.e. they are just needed where they have been created. Lambda functions are mainly used in combination with the functions filter(), map() and reduce(). The lambda feature was added to Python due to the demand from Lisp programmers.\n",
      "The general syntax of a lambda function is quite simple:\n",
      "\n",
      "<p style=\"text-align:center\"> <b>lambda argument_list: expression</b> </p>\n",
      "\n",
      "The argument list consists of a comma separated list of arguments and the expression is an arithmetic expression using these arguments. You can assign the function to a variable to give it a name."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "sum = lambda x, y : x + y\n",
      "sum(3,5)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 252,
       "text": [
        "8"
       ]
      }
     ],
     "prompt_number": 252
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "The Map Function"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The advantage of the lambda operator can be seen when it is used in combination with the map() function. map() is a function which takes two arguments:\n",
      "<p style=\"text-align:center\"> <b> r = map(func, seq) </b> </p>\n",
      "The first argument func is the name of a function and the second a sequence (e.g. a list) seq. map() applies the function func to all the elements of the sequence seq and returns an iterator. "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def fahrenheit(T):\n",
      "    return ((float(9)/5)*T + 32)\n",
      "def celcius(T):\n",
      "    return (float(5)/9)*(T - 32)\n",
      "\n",
      "T = (70,80,90,100) #For now imagine the temp are given as fahrenheit\n",
      "celcius_temp = list(map(celcius,T))\n",
      "print(celcius_temp)\n",
      "\n",
      "fahrenheit_temp = list(map(fahrenheit, celcius_temp))\n",
      "print(fahrenheit_temp)\n",
      "\n",
      "#Now let's use lamba function. By using lambda, we wouldn't have had to define and name the \n",
      "#functions fahrenheit() and celsius().\n",
      "lambda_celcius = list(map(lambda x:(float(5)/9)*(x - 32),T))\n",
      "print(lambda_celcius)\n",
      "lambda_fahrenheit = list(map(lambda x:((float(9)/5)*x + 32),lambda_celcius))\n",
      "print(lambda_fahrenheit)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[21.11111111111111, 26.666666666666668, 32.22222222222222, 37.77777777777778]\n",
        "[70.0, 80.0, 90.0, 100.0]\n",
        "[21.11111111111111, 26.666666666666668, 32.22222222222222, 37.77777777777778]\n",
        "[70.0, 80.0, 90.0, 100.0]\n"
       ]
      }
     ],
     "prompt_number": 267
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "map( ) can be applied to more than one list. The lists have to have the same length. map( ) will apply its lambda function to the elements of the argument lists, i.e. it first applies to the elements with the 0th index, then to the elements with the 1st index until the n-th index is reached."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#let's create a linear equation 3a+2*b+c\n",
      "a , b , c = list(range(1,10,2)), list(range(11,20,2)), list(range(21,30,2))\n",
      "list(map(lambda x,y,z:3*x+2*y+z, a,b,c))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 272,
       "text": [
        "[46, 58, 70, 82, 94]"
       ]
      }
     ],
     "prompt_number": 272
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Filtering"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The function <b> filter(function, sequence) </b> offers an elegant way to filter out all the elements of a sequence \"sequence\", for which the function function returns True. i.e. an item will be produced by the iterator result of filter(function, sequence) if item is included in the sequence \"sequence\" and if function(item) returns True.\n",
      "\n",
      "In other words: The function filter(f,l) needs a function f as its first argument. f has to return a Boolean value, i.e. either True or False. This function will be applied to every element of the list l. Only if f returns True will the element be produced by the iterator, which is the return value of filter(function, sequence).\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "seq = list(range(0,11))\n",
      "list(filter(lambda x: x%2 == 0, seq))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 277,
       "text": [
        "[0, 2, 4, 6, 8, 10]"
       ]
      }
     ],
     "prompt_number": 277
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Reducing a List"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The function <b> reduce(func, seq) </b> continually applies the function func() to the sequence seq. \n",
      "It returns a single value.\n",
      "\n",
      "If seq = [ s1, s2, s3, ... , sn ], calling reduce(func, seq) works like this:\n",
      "<ul>\n",
      "    <li>At first the first two elements of seq will be applied to func, i.e. func(s1,s2) \n",
      "    The list on which reduce() works looks now like this: [ func(s1, s2), s3, ... , sn ] </li>\n",
      "    <li>In the next step func will be applied on the previous result and the third element of the list, \n",
      "    i.e. func(func(s1, s2),s3)\n",
      "    The list looks like this now: [ func(func(s1, s2),s3), ... , sn ] </li>\n",
      "    <li>Continue like this until just one element is left and return this element as the result of reduce()</li>\n",
      "</ul>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from functools import reduce\n",
      "l = list(range(0,51))\n",
      "maximum = reduce(lambda x,y: x if x>y else y, l)\n",
      "print(maximum)\n",
      "cum_sum = reduce(lambda x,y: x+y, l)\n",
      "print(cum_sum)\n",
      "\n",
      "#calculating factorial using reduce function\n",
      "flist = list(range(1,6)) #to calculate factorial of 5\n",
      "fact = reduce(lambda x,y: x*y, flist)\n",
      "print(\"factorial of 5: \", fact)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "50\n",
        "1275\n",
        "factorial of 5:  120\n"
       ]
      }
     ],
     "prompt_number": 294
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "List Comprehensions"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print([x**2 for x in [1,2,3,4]])\n",
      "print([(x,y) for x in [1,2,3] for y in [2,4] if x!=y])\n",
      "\n",
      "s1 = \"apple computer\"\n",
      "s2 = \"dell computer\"\n",
      "listaltletter = [''.join(x) for x in zip(s1,s2)]\n",
      "print(''.join(listaltletter))\n",
      "\n",
      "#generate pythogeron triplets\n",
      "[(x,y,z) for x in range(1,20) for y in range(x,20) for z in range(y,20) if (x**2+y**2 == z**2)]\n",
      "\n",
      "#Cross product aka Cartesian product\n",
      "A = ('a1','a2','a3')\n",
      "B = ('b1','b2')\n",
      "[(x,y) for x in A for y in B]\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#The Sieve of Eratosthenes to generate prime numbers\n",
      "nonprimes = {j for i in range(2, 10) for j in range(i*2, 100, i)}\n",
      "print({i for i in range(2,100) if i not in nonprimes})\n",
      "\n",
      "#Recursive implementation of Sieve of Eratosthenes to generate prime numbers\n",
      "from math import sqrt\n",
      "def prime(n):\n",
      "    if n==0:\n",
      "        return []\n",
      "    elif n==1:\n",
      "        return [1]\n",
      "    else:\n",
      "        p = prime(int(sqrt(n)))\n",
      "        nonprimes = {j for i in p for j in range(i*2, n, i)}\n",
      "        p = {i for i in range(2,n) if i not in nonprimes}\n",
      "    return p\n",
      "prime(100)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Generator comprehension"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "X = (x**2 for x in range(0,10)) #Like list comprehension. But generates an iterator instead.\n",
      "print(type(X))\n",
      "print(list(X)) #A list() or tuple() or set() function can consume the iterator\n",
      "\n",
      "unique_characters = ('E', 'D', 'M', 'O', 'N', 'S', 'R', 'Y')\n",
      "gen = (ord(c) for c in unique_characters)\n",
      "print(type(gen))\n",
      "try:\n",
      "    while(True):\n",
      "        print(next(gen), end=\" \") #U can also use next() func to unwind the generator\n",
      "except StopIteration:\n",
      "    pass\n",
      "\n",
      "print()\n",
      "\n",
      "#The above generator comprehension can also be written as a generator func. as follows:\n",
      "def map_chartoord(unique_characters):\n",
      "    for char in unique_characters:\n",
      "        yield (ord(char))\n",
      "\n",
      "func_gen = map_chartoord(unique_characters)\n",
      "print(type(func_gen))\n",
      "print(tuple(func_gen))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "<class 'generator'>\n",
        "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n",
        "<class 'generator'>\n",
        "69 68 77 79 78 83 82 89 \n",
        "<class 'generator'>\n",
        "(69, 68, 77, 79, 78, 83, 82, 89)\n"
       ]
      }
     ],
     "prompt_number": 398
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Generators"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "An iterator can be seen as a pointer to a container, e.g. a list structure, that can iterate over all the elements of this container. The iterator is an abstraction, which enables the programmer to access all the elements of a container (a set, a list and so on) without any deeper knowledge of the data structure of this container object.\n",
      "\n",
      "Generators are a special kind of function, which enable us to implement or generate iterators.\n",
      "\n",
      "Iterators are a fundamental concept of Python. Mostly, iterators are implicitly used, like in the for loop of Python."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "cities = [\"Paris\",\"Berlin\",\"London\",\"Vienna\"]\n",
      "for location in cities:\n",
      "    print(\"Location: {}\".format(location))\n",
      "\n",
      "#If we use it with a string, it loops over its characters.\n",
      "for char in \"apple\":\n",
      "    print(char,end=\" \")\n",
      "\n",
      "print()\n",
      "#If we use it with a dictionary, it loops over its keys.\n",
      "capitals = { \"France\":\"Paris\", \"Netherlands\":\"Amsterdam\", \"Germany\":\"Berlin\", \"Switzerland\":\"Bern\" }\n",
      "for country in capitals:\n",
      "    print(\"The capital of {0} is: {1}\".format(country,capitals[country]))\n",
      "\n",
      "#There are many functions which consume these iterables.\n",
      "','.join(capitals)\n",
      "','.join(cities for cities in capitals) #alternative to above command\n",
      "\n",
      "iter_city = iter(cities)\n",
      "print(iter_city.__next__())\n",
      "print(next(iter_city))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Location: Paris\n",
        "Location: Berlin\n",
        "Location: London\n",
        "Location: Vienna\n",
        "a p p l e \n",
        "The capital of Switzerland is: Bern\n",
        "The capital of Germany is: Berlin\n",
        "The capital of France is: Paris\n",
        "The capital of Netherlands is: Amsterdam\n",
        "Paris\n",
        "Berlin\n"
       ]
      }
     ],
     "prompt_number": 357
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Generators are a simple and powerful possibility to create or to generate iterators. On the surface they look like functions, but there is both a syntactical and a semantical difference. Instead of return statements you will find inside of the body of a generator only yield statements, i.e. one or more yield statements.\n",
      "\n",
      "Another important feature of generators is that the local variables and the execution start is automatically saved between calls. This is necessary, because unlike an ordinary function successive calls to a generator function don't start execution at the beginning of the function. Instead, the new call to a generator function will resume execution right after the yield statement in the code, where the last call exited. In other words: When the Python interpreter finds a yield statement inside of an iterator generated by a generator, it records the position of this statement and the local variables, and returns from the iterator. The next time this iterator is called, it will resume execution at the line following the previous yield statement. There may be more than one yield statement in the code of a generator or the yield statement might be inside the body of a loop. If there is a return statement in the code of a generator, the execution will stop with a StopIteration exception error if this code is executed by the Python interpreter.\n",
      "\n",
      "Everything what can be done with a generator can be implemented with a class based iterator as well. But the crucial advantage of generators consists in automatically creating the methods __iter__() and next().\n",
      "Generators provide a very neat way of producing data which is huge or infinite. "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Save this function in the file city_generator\n",
      "def city_generator():\n",
      "    yield(\"Konstanz\")\n",
      "    yield(\"Zurich\")\n",
      "    yield(\"Schaffhausen\")\n",
      "    yield(\"Stuttgart\")\n",
      "    \n",
      "#Now run the following commands on command line\n",
      "from city_generator import city_generator\n",
      "x = city_generator()\n",
      "print(next(x))\n",
      "print(next(x))\n",
      "print(next(x))\n",
      "print(next(x))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Modus Operandi"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Generators offer a comfortable method to generate iterators, and that's why they are called \n",
      "generators.\n",
      "\n",
      "Method of working:\n",
      "<ul>\n",
      "    <li>A generator is called like a function. It's return value is an iterator object. \n",
      "    The code of the generator will not be executed in this stage. </li>\n",
      "    <li>The iterator can be used by calling the next method. The first time the execution starts \n",
      "    like a function, i.e. the first line of code within the body of the iterator. \n",
      "    The code is executed until a yield statement is reached. </li>\n",
      "    <li>yield returns the value of the expression, which is following the keyword yield. \n",
      "    This is like a function, but Python keeps track of the position of this yield and the state of \n",
      "    the local variables is stored for the next call. At the next call, the execution continues with \n",
      "    the statement following the yield statement and the variables have the same values as they had in \n",
      "    the previous call.</li>\n",
      "    <li>The iterator is finished, if the generator body is completely worked through or if the program \n",
      "    flow encounters a return statement without a value.</li> \n",
      "</ul>\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def fib_generator():\n",
      "    a = 0\n",
      "    b = 1\n",
      "    while True:\n",
      "        yield(a)\n",
      "        a, b = b, a+b\n",
      "\n",
      "#fib_iter = fib_generator()\n",
      "#for i in range(0,10):\n",
      "#    print(next(fib_iter), end = \" \")\n",
      "\n",
      "i = 0;\n",
      "for x in fib_generator():\n",
      "    print(x, end = \" \")\n",
      "    i +=1\n",
      "    if (i > 10):\n",
      "        break"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "0 1 1 2 3 5 8 13 21 34 55 "
       ]
      }
     ],
     "prompt_number": 359
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Recursive Generators"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Generator of Generators"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def fibonacci():\n",
      "    a = 0\n",
      "    b = 1\n",
      "    while (True):\n",
      "        yield(a)\n",
      "        a, b = b, a+b\n",
      "\n",
      "def gen_n(gen,n):\n",
      "    for i in range(n):\n",
      "        yield (next(gen))\n",
      "\n",
      "g = gen_n(fibonacci(),5)\n",
      "for i in range(5):\n",
      "    print(next(g), end=\" \")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "0 1 1 2 3 "
       ]
      }
     ],
     "prompt_number": 404
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Classes"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Yuppie this is my first class. Well it does not do anything\n",
      "#pass in python is equivalent to empty braces {} in C and JAVA\n",
      "class EmptyClass:\n",
      "    pass"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The instances possess dictionaries $__dict__$, which they use to store their attributes and their corresponding values. Python's class attributes and object attributes are stored in separate dictionaries"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class DemoClassCar:\n",
      "    company = \"Ford\" #Class Attribute\n",
      "    def __init__(self,model):\n",
      "        self.model = model # Instance Attribute\n",
      "#Now save the above class in a file by the name carsclassvar\n",
      "import carsclassvar\n",
      "obj1 = DemoClassCar(\"Ikon\")\n",
      "obj2 = DemoClassCar(\"Focus\")\n",
      "\n",
      "print(obj1.company) #prints 'Ford'\n",
      "print(obj2.company) #prints 'Ford'\n",
      "\n",
      "obj1.company = \"Toyota\" #Once you assign an instance variable \"company\" will be created\n",
      "\n",
      "print(obj1.__class__.company) #prints 'Ford'\n",
      "print(obj2.__class__.company) #prints 'Ford'\n",
      "\n",
      "obj1.__class__.company = \"Honda\"\n",
      "print(obj2.company) #prints 'Honda'\n",
      "print(obj1.__class__.company) #prints 'Honda'\n",
      "print(obj2.__class__.company) #prints 'Honda'\n",
      "print(obj1.company) #prints 'Toyota'\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "If you try to access a non-existing attribute, you will raise an AttributeError. By using the function getattr, you can prevent this exception, if you provide a default value as the third argument. "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "getattr(x, 'energy', 100)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Binding attributes to objects is a general concept in Python. Even function names can have attributes. You can bind an attribute to a function name."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def func(x):\n",
      "    return x\n",
      "func.y = 10\n",
      "print(func.y)\n",
      "print(func(5))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "10\n",
        "5\n"
       ]
      }
     ],
     "prompt_number": 425
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "This can be used as a replacement for static variables in functions, which are not possible in Python. NOTE: We do not create instance attributes like this. To properly create instances we need methods."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def f(x):\n",
      "    f.counter = getattr(f, \"counter\", 0) + 1 \n",
      "    return \"Monty Python\"\n",
      "\n",
      "for i in range(10):\n",
      "    f(i)\n",
      "    \n",
      "print(f.counter)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "10\n"
       ]
      }
     ],
     "prompt_number": 426
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Methods"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "A method differs from a function only in two aspects:\n",
      "<ul>\n",
      "    <li> It belongs to a class and it is defined within a class </li>\n",
      "    <li> The first parameter in the definition of a method has to be a reference to the instance, which called the method. This parameter is usually called \"self\".</li>\n",
      "</ul>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class Robot:\n",
      "\n",
      "    def SayHello(self):\n",
      "        print(\"Hello\")\n",
      "\n",
      "if __name__ == \"__main__\":\n",
      "    x = Robot()\n",
      "    x.SayHello()\n",
      "    Robot.SayHello(x)\n",
      "    Robot.SayHello(Robot())\n",
      "    Robot.SayHello(Robot)\n",
      "    type(x).SayHello(x)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Hello\n",
        "Hello\n",
        "Hello\n",
        "Hello\n",
        "Hello\n"
       ]
      }
     ],
     "prompt_number": 433
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Instance Variables"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class Robot:\n",
      "\n",
      "    def SayHello(self):\n",
      "        print(\"Hello, I'm \" + self.name)\n",
      "\n",
      "if __name__ == \"__main__\":\n",
      "    x = Robot()\n",
      "    x.name = \"Sam\"\n",
      "    x.SayHello()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Hello, I'm Sam\n"
       ]
      }
     ],
     "prompt_number": 435
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#One improvement to the above approach is to use set Method.\n",
      "class Robot:\n",
      "\n",
      "    def SayHello(self):\n",
      "        print(\"Hello, I'm \" + self.name)\n",
      "\n",
      "    def SetName(self, name):\n",
      "        self.name = name\n",
      "\n",
      "if __name__ == \"__main__\":\n",
      "    x = Robot()\n",
      "    x.SetName(\"Sam\")\n",
      "    x.SayHello()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Hello, I'm Sam\n"
       ]
      }
     ],
     "prompt_number": 436
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "There is more than one thing about this code, which may disturb you, but the essential problem at the moment is the fact, that we create a robot and that after the creation, we shouldn't forget about naming it! If we forget it, SayHello will raise an error.\n",
      "\n",
      "We need a mechanism to initialize an instance right after its creation. This is the $__init__$ method, which we cover in the next section.\n"
     ]
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "The $__init__$ Method"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "We want to define the attributes of an instances right after its creation. $__init__$ is a method which is immediately and automatically called after an instance has been created. This name is fixed and it is not possible to chose another name. $__init__$ is one of the so-called magic methods.\n",
      "The $__init__$ method is used to initialize an instance. There is no explicit constructor or destructor method in Python, as they are known in C++ and Java. The $__init__$ method can be anywhere in a class definition, but it is usually the first method of a class, i.e. it follows right after the class header."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class Test:\n",
      "    def __init__(self):\n",
      "        print(\"__init__ method is executed\")\n",
      "t = Test()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "__init__ method is executed\n"
       ]
      }
     ],
     "prompt_number": 438
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Data Abstraction, Data Encapsulation, and Information Hiding"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Data Abstraction, Data Encapsulation and Information Hiding are often synonymously used in books and tutorials on OOP. But there is a difference. Encapsulation is seen as the bundling of data with the methods that operate on that data. Information hiding on the other hand is the principle, that some internal information or data is \"hidden\", so that it can't be accidentally changed. Data encapsulation via methods doesn't necessarily mean, that the data is hidden. You might be capable of accessing and seeing the data anyway, but using the methods is recommended. Finally, data abstraction is present, if both data hiding and data encapsulation is used. This means data abstraction is the broader term:\n",
      "<center> <b> Data Abstraction = Data Encapsulation + Data Hiding  </b> </center>"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Encapsulation is often accomplished by providing two kinds of methods for attributes: The methods for retrieving or accessing the values of attributes are called getter methods. Getter methods do not change the values of attributes, they just return the values. The methods used for changing the values of attributes are called setter methods.\n"
     ]
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "$__str__$ and $__repr__$ Methods"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The $__str__$ method depicts various data as string by using the str function, which uses \"magically\" the internal $__str__$ method of the corresponding data type. $__repr__$ is similar, it also produces a string representation. "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "mylist = [\"one\",\"two\", \"three\"]\n",
      "print(type(str(mylist)))\n",
      "print(type(repr(mylist)))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "<class 'str'>\n",
        "<class 'str'>\n"
       ]
      }
     ],
     "prompt_number": 446
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "If you apply str or repr to an object, Python is looking for a corresponding method $__str__$ or $__repr__$ in the class definition of the object. If the method does exist, it will be called. "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class Test:\n",
      "    def __init__(self):\n",
      "        print(\"Hello Mike Testing\")\n",
      "t = Test()\n",
      "str(t) #We did not declare __str__ method in Test class. So it just prints the object info."
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Hello Mike Testing\n"
       ]
      },
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 451,
       "text": [
        "'<__main__.Test object at 0x1038d4128>'"
       ]
      }
     ],
     "prompt_number": 451
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "\n",
      "If a class has a $__str__$ method, the method will be used for an instance x of that class, if either the function str is applied to it or if it is used in a print function. $__str__$ will not be used, if repr is called, or if we try to output the value directly in an interactive Python shell."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class Test:\n",
      "    def __init__(self):\n",
      "        print(\"Hello Mike Testing\")\n",
      "    def __str__(self):\n",
      "        return \"str function is defined\"\n",
      "t = Test()\n",
      "print(str(t)) \n",
      "print(t)\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Hello Mike Testing\n",
        "str function is defined\n",
        "str function is defined\n"
       ]
      }
     ],
     "prompt_number": 458
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "If a class has only the $__repr__$ method and no $__str__$ method, $__repr__$ will be applied in the situations, where $__str__$ would be applied, if it were available. A frequently asked question is when to use $__repr__$ and when $__str__$. $__str__$ is always the right choice, if the output should be for the end user or in other words, if it should be nicely printed. $__repr__$ on the other hand is used for the internal representation of an object. The output of $__repr__$ should be - if feasible - a string which can be parsed by the python interpreter. The result of this parsing is in an equal object. The point is if you apply repr( ) method to an object ' o ' and then apply eval function then you get your object ' o ' back.\n",
      "\n",
      "Example: eval( repr( o ) ) == o\n",
      "\n",
      "But the same is not true when you apply eval( ) function to objects on which you applied str( ) method \n",
      "\n",
      "i.e., \n",
      "\n",
      "eval( str( o ) ) will result in error"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class Robot:\n",
      "\n",
      "    def __init__(self, name, build_year):\n",
      "        self.name = name\n",
      "        self.build_year = build_year\n",
      "\n",
      "    def __repr__(self):\n",
      "        return \"Robot(\\\"\" + self.name + \"\\\",\" +  str(self.build_year) +  \")\"\n",
      "     \n",
      "if __name__ == \"__main__\":\n",
      "    x = Robot(\"Marvin\", 1979)\n",
      "        \n",
      "    x_str = str(x)\n",
      "    print(x_str)\n",
      "    print(\"Type of x_str: \", type(x_str))\n",
      "    new = eval(x_str) #This is possible because here the interpreter is calling repr method\n",
      "    print(new)\n",
      "    print(\"Type of new:\", type(new))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Robot(\"Marvin\",1979)\n",
        "Type of x_str:  <class 'str'>\n",
        "Robot(\"Marvin\",1979)\n",
        "Type of new: <class '__main__.Robot'>\n"
       ]
      }
     ],
     "prompt_number": 459
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\n",
      "class Robot:\n",
      "\n",
      "    def __init__(self, name, build_year):\n",
      "        self.name = name\n",
      "        self.build_year = build_year\n",
      "\n",
      "    def __repr__(self):\n",
      "        return \"Robot(\\\"\" + self.name + \"\\\",\" +  str(self.build_year) +  \")\"\n",
      "\n",
      "    def __str__(self):\n",
      "        return \"Name: \" + self.name + \", Build Year: \" +  str(self.build_year)\n",
      "     \n",
      "if __name__ == \"__main__\":\n",
      "    x = Robot(\"Marvin\", 1979)\n",
      "    \n",
      "    x_repr = repr(x)\n",
      "    print(x_repr, type(x_repr))\n",
      "    new = eval(x_repr)\n",
      "    print(new)\n",
      "    print(\"Type of new:\", type(new))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Robot(\"Marvin\",1979) <class 'str'>\n",
        "Name: Marvin, Build Year: 1979\n",
        "Type of new: <class '__main__.Robot'>\n"
       ]
      }
     ],
     "prompt_number": 460
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Public - Protected - and Private Attributes"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "<ul>\n",
      "\n",
      "    <li> Private attributes should only be used by the owner, i.e. inside of the class definition itself.</li>\n",
      "    <li> Protected (restricted) Attributes may be used, but at your own risk. Essentially, this means, that they should only be used under certain conditions.</li>\n",
      "    <li> Public Attributes can and should be freely used.</li>\n",
      "\n",
      "</ul>\n",
      "\n",
      "Python uses a special naming scheme for attributes to control the accessibility of the attributes. So far, we have used attribute names, which can be freely used inside or outside of a class definition, as we have seen. This corresponds to public attributes of course.\n",
      "There are two ways to restrict the access to class attributes:\n",
      "<ul>\n",
      "    <li>First, we can prefix an attribute name with a leading underscore \"\\_\". This marks the attribute as protected. It tells users of the class not to use this attribute unless inside of a  subclass definition.</li>\n",
      "    <li>Second, we can prefix an attribute name with two leading underscores \"__\". The attribute is now inaccessible and invisible from outside. It's neither possible to read nor write to those attributes except inside of the class definition itself.</li>\n",
      "</ul>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class A():\n",
      "    def __init__(self):\n",
      "        self.__priv = \"I am private\"\n",
      "        self._prot = \"I am protected\"\n",
      "        self.pub = \"I am public\"\n",
      "obj = A()\n",
      "print(obj.pub)\n",
      "print(obj._prot)\n",
      "print(obj.__priv)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "One might have expected a message like \"\\__priv is private\". We get the message \"AttributeError: 'A' object has no attribute '\\__priv'\" instead, which looks like a \"lie\". There is such an attribute, but we are told that there isn't. This is perfect information hiding. Telling a user, that an attribute name is private, means that we make some information visible, i.e. the existence or non-existence of a private variable.\n",
      "\n",
      "Our next task consists in rewriting our Robot class. Though we have Getter and Setter methods for the name and the build_year, we can access the attributes directly as well, because we have defined them as public attributes. Data Encapsulation means, that we should only be able to access private attributes via getters and setters.\n",
      "\n",
      "We have to replace each occurrence of self.name and self.build_year by self.\\__name and self.\\__build\\_year. "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class Robot:\n",
      "\n",
      "    def __init__(self, name, build_year):\n",
      "        self.__name = name\n",
      "        self.__build_year = build_year\n",
      "\n",
      "    def SayHello(self):\n",
      "        print(\"Hi, I'm \" + self.__name)\n",
      "\n",
      "    def SetName(self, name):\n",
      "        self.__name = name\n",
      "\n",
      "    def GetName(self):\n",
      "        return self.__name\n",
      "\n",
      "    def SetBuildYear(self, build_year):\n",
      "        self.__build_year = build_year\n",
      "\n",
      "    def GetBuildYear(self):\n",
      "        return str(self.__build_year)\n",
      "\n",
      "    def __repr__(self):\n",
      "        return \"Robot(\\\"\" + self.__name + \"\\\",\" +  str(self.__build_year) +  \")\"\n",
      "\n",
      "    def __str__(self):\n",
      "        return \"Name: \" + self.__name + \", Build Year: \" +  str(self.__build_year)\n",
      "\n",
      "     \n",
      "if __name__ == \"__main__\":\n",
      "    x = Robot(\"Marvin\", 1979)\n",
      "    y = Robot(\"Caliban\", 1993)\n",
      "    for rob in [x, y]:\n",
      "        rob.SayHello()\n",
      "        print(\"I was built in the year \" + rob.GetBuildYear() + \"!\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Hi, I'm Marvin\n",
        "I was built in the year 1979!\n",
        "Hi, I'm Caliban\n",
        "I was built in the year 1993!\n"
       ]
      }
     ],
     "prompt_number": 467
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Destructor"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "What we said about constructors holds true for destructors as well. There is no \"real\" destructor, but something similar, i.e. the method $__del__$. It is called when the instance is about to be destroyed and if there is no other reference to this instance. If a base class has a $__del__( )$ method, the derived class's $__del__( )$ method, if any, must explicitly call it to ensure proper deletion of the base class part of the instance. "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class Robot():\n",
      "    \n",
      "    def __init__(self, name):\n",
      "        print(name + \" has been created!\")\n",
      "        \n",
      "    def __del__(self):\n",
      "        print (\"Robot has been destroyed\")\n",
      "        \n",
      "        \n",
      "if __name__ == \"__main__\":\n",
      "    x = Robot(\"Tik-Tok\")\n",
      "    y = Robot(\"Jenkins\")\n",
      "    z = x\n",
      "    print(\"Deleting x\")\n",
      "    del x\n",
      "    print(\"Deleting z\")\n",
      "    del z\n",
      "    del y"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Tik-Tok has been created!\n",
        "Jenkins has been created!\n",
        "Deleting x\n",
        "Deleting z\n",
        "Robot has been destroyed\n",
        "Robot has been destroyed\n"
       ]
      }
     ],
     "prompt_number": 469
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The usage of the $__del__$ method is very problematic. If we change the previous code to personalize the deletion of a robot, we create an error."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class Robot():\n",
      "    \n",
      "    def __init__(self, name):\n",
      "        print(name + \" has been created!\")\n",
      "        \n",
      "    def __del__(self):\n",
      "        print (self.name + \" says bye-bye!\")\n",
      "        \n",
      "        \n",
      "if __name__ == \"__main__\":\n",
      "    x = Robot(\"Tik-Tok\")\n",
      "    y = Robot(\"Jenkins\")\n",
      "    z = y\n",
      "    print(\"Deleting x\")\n",
      "    del x\n",
      "    print(\"Deleting z\")\n",
      "    del z\n",
      "    del y"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Tik-Tok has been created!\n",
        "Jenkins has been created!\n",
        "Deleting x\n",
        "Deleting z\n"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stderr",
       "text": [
        "Exception ignored in: <bound method Robot.__del__ of <__main__.Robot object at 0x10474a198>>\n",
        "Traceback (most recent call last):\n",
        "  File \"<ipython-input-471-c288cd0eec12>\", line 7, in __del__\n",
        "AttributeError: 'Robot' object has no attribute 'name'\n",
        "Exception ignored in: <bound method Robot.__del__ of <__main__.Robot object at 0x10474a5f8>>\n",
        "Traceback (most recent call last):\n",
        "  File \"<ipython-input-471-c288cd0eec12>\", line 7, in __del__\n",
        "AttributeError: 'Robot' object has no attribute 'name'\n"
       ]
      }
     ],
     "prompt_number": 471
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class C: \n",
      "\n",
      "    counter = 0 #Class variable\n",
      "    \n",
      "    def __init__(self):\n",
      "        type(self).counter += 1 #Access class variable using type(self).var\n",
      "\n",
      "    def __del__(self):\n",
      "        type(self).counter -= 1 \n",
      "\n",
      "if __name__ == \"__main__\":\n",
      "    x = C()\n",
      "    print(\"Number of instances: : \" + str(C.counter))\n",
      "    y = C()\n",
      "    print(\"Number of instances: : \" + str(C.counter))\n",
      "    del x\n",
      "    print(\"Number of instances: : \" + str(C.counter))\n",
      "    del y\n",
      "    print(\"Number of instances: : \" + str(C.counter))    "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Number of instances: : 1\n",
        "Number of instances: : 2\n",
        "Number of instances: : 1\n",
        "Number of instances: : 0\n"
       ]
      }
     ],
     "prompt_number": 493
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Static Methods"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "It's easy to turn a method into a static method. All we have to do is to add a line with \"@staticmethod\" directly in front of the method header. It's the decorator syntax.\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class Robot:\n",
      "    __counter = 0 # Private Class Variable\n",
      "    \n",
      "    def __init__(self):\n",
      "        type(self).__counter += 1\n",
      "        \n",
      "    @staticmethod\n",
      "    def RobotInstances(): #Static Method\n",
      "        return Robot.__counter\n",
      "        \n",
      "\n",
      "if __name__ == \"__main__\":\n",
      "    print(Robot.RobotInstances())\n",
      "    x = Robot()\n",
      "    print(x.RobotInstances())\n",
      "    y = Robot()\n",
      "    print(x.RobotInstances())\n",
      "    print(Robot.RobotInstances())"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "0\n",
        "1\n",
        "2\n",
        "2\n"
       ]
      }
     ],
     "prompt_number": 494
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Class Methods"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Static methods shouldn't be confused with class methods. Like static methods class methods are not bound to instances, but unlike static methods class methods are bound to a class. The first name of a class method is a reference to a class, i.e. a class object. They can be called via an instance or the class name. One use people have found for class methods is to create inheritable alternative constructors."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class Robot:\n",
      "    __counter = 0\n",
      "    \n",
      "    def __init__(self):\n",
      "        type(self).__counter += 1\n",
      "        \n",
      "    @classmethod\n",
      "    def RobotInstances(cls):\n",
      "        return cls, Robot.__counter\n",
      "        \n",
      "if __name__ == \"__main__\":\n",
      "    print(Robot.RobotInstances())\n",
      "    x = Robot()\n",
      "    print(x.RobotInstances())\n",
      "    y = Robot()\n",
      "    print(x.RobotInstances())\n",
      "    print(Robot.RobotInstances())"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(<class '__main__.Robot'>, 0)\n",
        "(<class '__main__.Robot'>, 1)\n",
        "(<class '__main__.Robot'>, 2)\n",
        "(<class '__main__.Robot'>, 2)\n"
       ]
      }
     ],
     "prompt_number": 497
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class A(object):\n",
      "    def foo(self,x):\n",
      "        print (\"executing foo({0},{1})\".format(self,x))\n",
      "\n",
      "    @classmethod\n",
      "    def class_foo(cls,x):\n",
      "        print (\"executing class_foo({0},{1})\".format(cls,x))\n",
      "\n",
      "    @staticmethod\n",
      "    def static_foo(x):\n",
      "        print (\"executing static_foo({})\".format(x) )   \n",
      "\n",
      "a=A()\n",
      "a.foo(1) #a is bound to foo\n",
      "a.class_foo(1) #a is not bound to class_foo, rather the class A is bound to class_foo\n",
      "A.class_foo(1) \n",
      "a.static_foo(1) #static_foo is neither bound to instance nor to class \n",
      "A.static_foo(1)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "executing foo(<__main__.A object at 0x10474aef0>,1)\n",
        "executing class_foo(<class '__main__.A'>,1)\n",
        "executing class_foo(<class '__main__.A'>,1)\n",
        "executing static_foo(1)\n",
        "executing static_foo(1)\n"
       ]
      }
     ],
     "prompt_number": 508
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The are mainly two use cases for class methods: First, the so-called factory methods, which we will not cover here, and the second, the cases, where we have static methods, which have to call other static methods. To do this, we would have to hard code the class name, if we had to use static methods. This is a problem, if we are in a use case, where we have inherited classes. "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class fraction(object):\n",
      "\n",
      "    def __init__(self, n, d):\n",
      "        self.numerator, self.denominator = fraction.reduce(n, d)\n",
      "        \n",
      "\n",
      "    #@staticmethod\n",
      "    def gcd(a,b):\n",
      "        while b != 0:\n",
      "            a,b = b,a%b\n",
      "        return a\n",
      "\n",
      "    @classmethod\n",
      "    def reduce(cls, n1, n2):\n",
      "        g = cls.gcd(n1, n2)\n",
      "        return (n1//g, n2//g) # integer division\n",
      "\n",
      "    def __str__(self):\n",
      "        return str(self.numerator)+'/'+str(self.denominator)\n",
      "\n",
      "print(fraction(8,24))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1/3\n"
       ]
      }
     ],
     "prompt_number": 513
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Properties Vs. Setters and Getters"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Most of the modern OOP languages like JAVA use Getter and Setter Methods to get and set values of instance variables. Now you must be wondering how is that data hiding (aka encapsulation) when you can view and manipulate the internal state of an object. Having getters and setters does not in itself break encapsulation. What does break encapsulation is having a getter and a setter for every data member (every field, in java lingo). That is one step away from making all data members public.\n",
      "\n",
      "The point of encapsulation is not that you should not be able to know or to change the object's state from outside the object, but that you should have a reasonable policy for doing it.\n",
      "\n",
      "Consider an example of a class Person. Let's say a person has a name, a social security number, and an age. Let's say that we do not allow people to ever change their names or social security numbers. However, the person's age should be incremented by 1 every year. In this case, you would provide a constructor that would initialize the name and the SSN to the given values, and which would initialize the age to 0. You would also provide a method incrementAge(), which would increase the age by 1. You would also provide getters for all three. No setters are required in this case.\n",
      "\n",
      "In this design you allow the state of the object to be inspected from outside the class, and you allow it to be changed from outside the class. However, you do not allow the state to be changed arbitrarily. There is a policy, which effectively states that the name and the SSN cannot be changed at all, and that the age can be incremented by 1 year at a time."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Now lets see the python way of doing things\n",
      "class P:\n",
      "    def __init__(self,x):\n",
      "        self.x = x\n",
      "p1 = P(10)\n",
      "print(p1.x) #This is beautiful. But does not hide data and also does not do any sanity check on data"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "10\n"
       ]
      }
     ],
     "prompt_number": 7
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class P:\n",
      "    ''' Now lets include some code implementation to setter Method'''\n",
      "    def __init__(self,x):\n",
      "        self.setX(x)\n",
      "\n",
      "    def getX(self):\n",
      "        return self.__x\n",
      "\n",
      "    def setX(self, x):\n",
      "        if x < 0:\n",
      "            self.__x = 0\n",
      "        elif x > 1000:\n",
      "            self.__x = 1000\n",
      "        else:\n",
      "            self.__x = x\n",
      "p1 = P(2000)\n",
      "p2 = P(-1)\n",
      "print(\"p1 is: {} and p2 is: {}\".format(p1.getX(),p2.getX()))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "p1 is: 1000 and p2 is: 0\n"
       ]
      }
     ],
     "prompt_number": 11
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The getter and setter methods make the code look ugly. Let us see if a cleaner implementation is possible."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class P:\n",
      "    '''This implementation allows us to use variables names to assign and retrieve values. A method \n",
      "    which is used for setting a value is decorated with \"@property\", i.e. we put this line directly \n",
      "    in front of the header. The method which has to function as the setter is decorated with \n",
      "    \"@x.setter\". If the function had been called \"f\", we would have had to decorate it with \n",
      "    \"@f.setter\". Two things are noteworthy: We just put the code line \"self.x = x\" in the \n",
      "    __init__ method and the property method x is used to check the limits of the values. The second \n",
      "    interesting thing is, that we wrote \"two\" methods with the same name and a different number of \n",
      "    parameters \"def x(self)\" and \"def x(self,x)\". This should not be possible, it works here due to \n",
      "    the decorating syntax'''\n",
      "    \n",
      "    def __init__(self,x):\n",
      "        self.x = x\n",
      "\n",
      "    @property\n",
      "    def x(self):\n",
      "        return self.__x\n",
      "\n",
      "    @x.setter       #func_name.setter\n",
      "    def x(self, x):\n",
      "        if x < 0:\n",
      "            self.__x = 0\n",
      "        elif x > 1000:\n",
      "            self.__x = 1000\n",
      "        else:\n",
      "            self.__x = x\n",
      "\n",
      "p1 = P(-500)\n",
      "print(p1.x)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "0\n"
       ]
      }
     ],
     "prompt_number": 12
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "From what we have written so far, and what can be seen in other books and tutorials as well, we could easily get the impression, that there is a one-to-one connection between properties (or mutator methods) and the attributes, i.e. that each attribute has or should have its own property (or getter-setter-pair) and the other way around. Even in other object oriented languages than Python, it's usually not a god idea to implement a class like that. The main reason is, that many attributes are only internally needed and creating interfaces for the user of the class increases unnecessarily the usability of the class. The possible user of a class shouldn't be \"drowned\" with umpteen - of mainly unnecessary - methods or properties!\n",
      "\n",
      "So the gist is that not every attribute needs to have its own property method. Provide a property method only to those which actual need it."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class Robot:\n",
      "\n",
      "    def __init__(self, name, build_year, lk = 0.5, lp = 0.5 ):\n",
      "        self.name = name\n",
      "        self.build_year = build_year\n",
      "        self.__potential_physical = lk\n",
      "        self.__potential_psychic = lp\n",
      "\n",
      "    @property\n",
      "    def condition(self):\n",
      "        s = self.__potential_physical + self.__potential_psychic\n",
      "        if s <= -1:\n",
      "           return \"I feel miserable!\"\n",
      "        elif s <= 0:\n",
      "           return \"I feel bad!\"\n",
      "        elif s <= 0.5:\n",
      "           return \"Could be worse!\"\n",
      "        elif s <= 1:\n",
      "           return \"Seems to be okay!\"\n",
      "        else:\n",
      "           return \"Great!\" \n",
      "  \n",
      "if __name__ == \"__main__\":\n",
      "    x = Robot(\"Marvin\", 1979, 0.2, 0.4 )\n",
      "    y = Robot(\"Caliban\", 1993, -0.4, 0.3)\n",
      "    print(x.condition)\n",
      "    print(y.condition)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Inheritance"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class BaseClassName:\n",
      "    pass\n",
      "\n",
      "#The syntax for a subclass definition\n",
      "class DerivedClassName(BaseClassName):\n",
      "    pass"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 14
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class Person:\n",
      "\n",
      "    def __init__(self, first, last):\n",
      "        self.firstname = first\n",
      "        self.lastname = last\n",
      "\n",
      "    def Name(self):\n",
      "        return self.firstname + \" \" + self.lastname\n",
      "\n",
      "class Employee(Person):\n",
      "    \n",
      "    def __init__(self, first, last, empid):\n",
      "        '''The __init__ method of our Employee class explicitly invokes \n",
      "        the __init__method of the Person class. We could have used super instead. \n",
      "        super().__init__(first, last) is automatically replaced by a call \n",
      "        to the superclasses method'''\n",
      "        Person.__init__(self, first, last)\n",
      "        #super().__init__(first,last) #This type of method invocation does not take self as argument\n",
      "        self.empid = empid\n",
      "\n",
      "    def GetEmployee(self):\n",
      "        return self.Name() + \", \" +  self.empid\n",
      "\n",
      "x = Person(\"Marge\", \"Simpson\")\n",
      "y = Employee(\"Homer\", \"Simpson\", \"1007\")\n",
      "\n",
      "print(x.Name())\n",
      "print(y.GetEmployee())\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Marge Simpson\n",
        "Homer Simpson, 1007\n"
       ]
      }
     ],
     "prompt_number": 17
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Overloading and Overriding"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "We have overridden the method $__str__$ from Person in Employee. By the way, we have overridden $__init__$ also. Method overriding is an object-oriented programming feature that allows a subclass to provide a different implementation of a method that is already defined by its superclass or by one of its superclasses. The implementation in the subclass overrides the implementation of the superclass by providing a method with the same name, same parameters or signature, and same return type as the method of the parent class. "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class Person:\n",
      "\n",
      "    def __init__(self, first, last, age):\n",
      "        self.firstname = first\n",
      "        self.lastname = last\n",
      "        self.age = age\n",
      "\n",
      "    def __str__(self):\n",
      "        return self.firstname + \" \" + self.lastname + \", \" + str(self.age)\n",
      "\n",
      "class Employee(Person):\n",
      "\n",
      "    def __init__(self, first, last, age, empid):\n",
      "        super().__init__(first, last, age)\n",
      "        self.empid = empid\n",
      "\n",
      "    def __str__(self):\n",
      "        return super().__str__() + \", \" +  self.empid\n",
      "\n",
      "\n",
      "x = Person(\"Marge\", \"Simpson\", 36)\n",
      "y = Employee(\"Homer\", \"Simpson\", 28, \"1007\")\n",
      "\n",
      "print(x)\n",
      "print(y)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Marge Simpson, 36\n",
        "Homer Simpson, 28, 1007\n"
       ]
      }
     ],
     "prompt_number": 19
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "In the context of object-oriented programming, you might have heard about \"overloading\" as well. Overloading is the ability to define the same method, with the same name but with a different number of arguments and types. It's the ability of one function to perform different tasks, depending on the number of parameters or the types of the parameters. Overloading is not supported in Python. \n",
      "If we need such a behaviour, we can simulate it with default parameters."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def f(n, m=None):\n",
      "    if m:\n",
      "        return n + m +42\n",
      "    else:\n",
      "        return n + 42\n",
      "print(f(1))\n",
      "print(f(1,1))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "43\n",
        "44\n"
       ]
      }
     ],
     "prompt_number": 22
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The * operator can be used as a more general approach for a family of functions with 1, 2, 3, or even more parameters:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def f(*x):\n",
      "    sum = 0\n",
      "    for i in x:\n",
      "        sum = sum + i\n",
      "    return sum\n",
      "\n",
      "print(f(1,2,3,4))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "10\n"
       ]
      }
     ],
     "prompt_number": 24
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Multiple Inheritance"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#A class definition, where a child class SubClassName inherits from the parent classes BaseClass1, \n",
      "#BaseClass2, BaseClass3, and so on, looks like this:\n",
      "class SubclassName(BaseClass1, BaseClass2, BaseClass3, ...):\n",
      "    pass"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Polymorphism"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Polymorphism in Computer Science is the ability to present the same interface for differing underlying forms. We can have in some programming languages polymorphic functions or methods for example. Polymorphic functions or methods can be applied to arguments of different types, and they can behave differently depending on the type of the arguments to which they are applied. We can also define the same function name with a varying number of parameter.\n",
      "\n",
      "Python is implicitly polymorphic."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def f(x, y):\n",
      "    print(\"values: \", x, y)\n",
      "\n",
      "f(1, 2)\n",
      "f([3,4],[5,6])\n",
      "f(\"Sri\", \"Paladugu\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "values:  1 2\n",
        "values:  [3, 4] [5, 6]\n",
        "values:  Sri Paladugu\n"
       ]
      }
     ],
     "prompt_number": 28
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Operator Overloading"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "It's even possible to overload the \"+\" operator as well as all the other operators for the purposes of your own class. To do this, you need to understand the underlying mechanism. There is a special (or a \"magic\") method for every operator sign. The method The magic method for the \"+\" sign is the $__add__$ method. For \"-\" it is $__sub__$ and so on. The mechanism works like this: If we have an expression \"x + y\" and x is an instance of class K, then Python will check the class definition of K. If K has a method $__add__$ it will be called with $x.__add__(y)$, otherwise we will get an error message. We use the method $__iadd__$ to implement the extended assignment."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class Length:\n",
      "\n",
      "    __metric = {\"mm\" : 0.001, \"cm\" : 0.01, \"m\" : 1, \"km\" : 1000,\n",
      "                \"in\" : 0.0254, \"ft\" : 0.3048, \"yd\" : 0.9144,\n",
      "                \"mi\" : 1609.344 }\n",
      "    \n",
      "    def __init__(self, value, unit = \"m\" ):\n",
      "        self.value = value\n",
      "        self.unit = unit\n",
      "    \n",
      "    def Convert2Metres(self):\n",
      "        return self.value * Length.__metric[self.unit]\n",
      "    \n",
      "    def __add__(self, other):\n",
      "        l = self.Convert2Metres() + other.Convert2Metres()\n",
      "        return Length(l / Length.__metric[self.unit], self.unit ) #return the result in units of\n",
      "                                                                  # left variable.    \n",
      "    def __str__(self):\n",
      "        return str(self.Convert2Metres())\n",
      "    \n",
      "    def __repr__(self):\n",
      "        return \"Length(\" + str(self.value) + \", '\" + self.unit + \"')\"\n",
      "\n",
      "if __name__ == \"__main__\":\n",
      "    x = Length(4)\n",
      "    print(x)\n",
      "    y = eval(repr(x))\n",
      "    print(repr(y))\n",
      "    \n",
      "    z = Length(4.5, \"yd\") + Length(1)\n",
      "    print(repr(z)) #the result will be displayed in units of left variable which is yd in this case.\n",
      "    print(\"Length of z in meters: \")#the result will be displayed in meters as \"__str__\" method \n",
      "                                    #is called.\n",
      "    print(z)  \n",
      "    \n",
      "    x += Length(1) #__iadd__ method will be called.\n",
      "    print(\"Length of x: \")\n",
      "    print(repr(x))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "4\n",
        "Length(4, 'm')\n",
        "Length(5.593613298337708, 'yd')\n",
        "Length of z in meters: \n",
        "5.1148\n",
        "Length of x: \n",
        "Length(5.0, 'm')\n"
       ]
      }
     ],
     "prompt_number": 50
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Extending base classes"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class Plist(list):\n",
      "\n",
      "    def __init__(self, l):\n",
      "        list.__init__(self, l)\n",
      "\n",
      "    def push(self, item):\n",
      "        self.append(item)\n",
      "\n",
      "\n",
      "if __name__ == \"__main__\":\n",
      "    x = Plist([3,4])\n",
      "    x.push(47)\n",
      "    print(x)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[3, 4, 47]\n"
       ]
      }
     ],
     "prompt_number": 51
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Iterator"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "An iterator is just a class that defines an $__iter__()$ method.\n",
      "\n",
      "All three of these class methods, $__init__, __iter__, and __next__,$ begin and end with a pair of underscore (_) characters. Why is that? There\u2019s nothing magical about it, but it usually indicates that these are \u201cspecial methods.\u201d The only thing \u201cspecial\u201d about special methods is\n",
      "that they aren\u2019t called directly; Python calls them when you use some\n",
      "other syntax on the class or an instance of the class."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class Fib:\n",
      "    def __init__(self, max):\n",
      "        '''\u201cCalling\u201d Fib(max) is really creating an instance of this class and\n",
      "            calling its __init__() method with max. The __init__() method\n",
      "            saves the maximum value as an instance variable so other methods\n",
      "            can refer to it later.'''\n",
      "        self.max = max\n",
      "    \n",
      "    def __iter__(self):\n",
      "        '''The __iter__() method is called whenever someone calls iter(fib). (As you\u2019ll see in a \n",
      "        minute, a for loop will call this automatically, but you can also call it yourself \n",
      "        manually.) \n",
      "        After performing beginning-of-iteration initialization (in this case, resetting self.a \n",
      "        and self.b, our two counters), the __iter__() method can return any object that implements \n",
      "        a __next__() method. In this case (and in most cases), __iter__() simply returns self, \n",
      "        since this class implements its own __next__() method.\n",
      "        '''\n",
      "        self.a = 0\n",
      "        self.b = 1\n",
      "        return self\n",
      "    \n",
      "    def __next__(self):\n",
      "        '''\n",
      "        The __next__() method is called whenever someone calls next() on an iterator of an instance \n",
      "        of a class.\n",
      "        \n",
      "        When the __next__() method raises a StopIteration exception, this signals to the caller \n",
      "        that the iteration is exhausted. Unlike most exceptions, this is not an error; it\u2019s a \n",
      "        normal condition that just means that the iterator has no more values to generate. If the \n",
      "        caller is a for loop, it will notice this StopIteration exception and gracefully exit the \n",
      "        loop. (In other words, it will swallow the exception.) This little bit of magic is actually \n",
      "        the key to using iterators in for loops.\n",
      "        \n",
      "        To spit out the next value, an iterator\u2019s __next__() method simply returns the value. Do \n",
      "        not use yield here; that\u2019s a bit of syntactic sugar that only applies when you\u2019re using \n",
      "        generators. Here you\u2019re creating your own iterator from scratch; use return instead.\n",
      "        '''\n",
      "        fib = self.a\n",
      "        if fib > self.max:\n",
      "            raise StopIteration\n",
      "        self.a , self.b = self.b, self.a + self.b\n",
      "        return fib\n",
      "\n",
      "fibo = Fib(10)\n",
      "for n in fibo:\n",
      "    print(n, end = \" \")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Making Assertions"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The assert statement is followed by any valid Python expression. If the expression\n",
      "evaluates to True, the assert statement does nothing.\n",
      "However, if the Python expression evaluates to False, the assert statement will raise an AssertionError.\n",
      "You can also include a human-readable message that is printed if the AssertionError is raised."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "assert 1+1 == 2 # True\n",
      "assert 1+1 == 3 # Raises Exception\n",
      "assert 1+1 == 4, \"I am going to print now\" # Raises Exception"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Exception Handling"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Exceptions handling in Python is very similar to Java. The code, which harbours the risk of an exception, is embedded in a try block. But whereas in Java exceptions are caught by catch clauses, we have statements introduced by an \"except\" keyword in Python. It's possible to \"create custome-made\" exceptions: With the raise statement it's possible to force a specified exception to occur."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "while True:\n",
      "    try:\n",
      "        n = input(\"Please enter an integer: \")\n",
      "        n = int(n)\n",
      "        break\n",
      "    except ValueError:\n",
      "        print(\"Not a valid integer! Please try again ...\")\n",
      "print(\"Great, you successfully entered an integer!\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "name": "stdout",
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Please enter an integer: ew\n"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Not a valid integer! Please try again ...\n"
       ]
      },
      {
       "name": "stdout",
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Please enter an integer: 1\n"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Great, you successfully entered an integer!\n"
       ]
      }
     ],
     "prompt_number": 406
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      " A try statement may have more than one except clause for different exceptions. But at most one except clause will be executed.\n",
      "\n",
      "Our next example shows a try clause, in which we open a file for reading, read a line from this file and convert this line into an integer. There are at least two possible exceptions:\n",
      "<ul>\n",
      "<li> an IOError </li>\n",
      "<li> ValueError </li>\n",
      "</ul>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import sys\n",
      "\n",
      "try:\n",
      "    f = open('integers.txt')\n",
      "    s = f.readline()\n",
      "    i = int(s.strip())\n",
      "except IOError as e:\n",
      "    print(\"I/O error({0}): {1}\".format(e.errno, e.strerror))\n",
      "except ValueError:\n",
      "    print(\"No valid integer in line.\")\n",
      "except:\n",
      "    print(\"Unexpected error:\", sys.exc_info()[0])\n",
      "    raise"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "I/O error(13): Permission denied\n"
       ]
      }
     ],
     "prompt_number": 411
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "An except clause may name more than one execption in a tuple of error names, as we see in the following example:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "try:\n",
      "    f = open('integers.txt')\n",
      "    s = f.readline()\n",
      "    i = int(s.strip())\n",
      "except (IOError, ValueError):\n",
      "    print(\"An I/O error or a ValueError occurred\")\n",
      "except:\n",
      "    print(\"An unexpected error occurred\")\n",
      "    raise"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "An I/O error or a ValueError occurred\n"
       ]
      }
     ],
     "prompt_number": 412
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Custom-made Exceptions"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#You can create your own exception as below.\n",
      "raise SyntaxError(\"Sorry, my fault!\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "ename": "SyntaxError",
       "evalue": "Sorry, my fault! (<string>)",
       "output_type": "pyerr",
       "traceback": [
        "\u001b[0;36m  File \u001b[0;32m\"<string>\"\u001b[0;36m, line \u001b[0;32munknown\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m Sorry, my fault!\n"
       ]
      }
     ],
     "prompt_number": 413
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The best or the Pythonic way to do this, consists in defining an exception class which inherits from the Exception class. "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class MyException(Exception):\n",
      "    pass\n",
      "\n",
      "raise MyException(\"An exception doesn't always prove the rule!\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "ename": "MyException",
       "evalue": "An exception doesn't always prove the rule!",
       "output_type": "pyerr",
       "traceback": [
        "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[0;31mMyException\u001b[0m                               Traceback (most recent call last)",
        "\u001b[0;32m<ipython-input-414-f1c81348c0ce>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m     \u001b[0;32mpass\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mMyException\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"An exception doesn't always prove the rule!\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
        "\u001b[0;31mMyException\u001b[0m: An exception doesn't always prove the rule!"
       ]
      }
     ],
     "prompt_number": 414
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Clean-up Actions (try ... except ... else ... finally)"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "A finally clause is always executed before leaving the try statement, whether an exception has occurred or not. When an exception has occurred in the try clause and has not been handled by an except clause (or it has occurred in a except or else clause), it is re-raised after the finally clause has been executed. The finally clause is also executed \u201con the way out\u201d when any other clause of the try statement is left via a break, continue or return statement. An else block has to be positioned after all the except clauses. An else clause will be executed if the try clause doesn't raise an exception."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "try:\n",
      "    raise KeyboardInterrupt\n",
      "finally:\n",
      "    print(\"Goodbye!!!\")\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Goodbye!!!\n"
       ]
      },
      {
       "ename": "KeyboardInterrupt",
       "evalue": "",
       "output_type": "pyerr",
       "traceback": [
        "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
        "\u001b[0;32m<ipython-input-419-8cd05a40f734>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0;32mraise\u001b[0m \u001b[0mKeyboardInterrupt\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Goodbye!!!\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
        "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
       ]
      }
     ],
     "prompt_number": 419
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def division(x,y):\n",
      "    try:\n",
      "        result = x/y\n",
      "    except ZeroDivisionError:\n",
      "        print(\"second argument cannot be zero\")\n",
      "    else:\n",
      "        print(\"The result is: \" + str(result))\n",
      "    finally:\n",
      "        print(\"Cleaning house finally\")\n",
      "division(1,5)\n",
      "division(1,0)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "The result is: 0.2\n",
        "Cleaning house finally\n",
        "second argument cannot be zero\n",
        "Cleaning house finally\n"
       ]
      }
     ],
     "prompt_number": 421
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import sys\n",
      "file_name = \"integer.txt\"\n",
      "text = []\n",
      "try:\n",
      "    fh = open(file_name, 'r')\n",
      "except IOError:\n",
      "    print('cannot open', file_name)\n",
      "else:\n",
      "    text = fh.readlines()\n",
      "    fh.close()\n",
      "\n",
      "if text:\n",
      "    print(text[100])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "cannot open integer.txt\n"
       ]
      }
     ],
     "prompt_number": 422
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Sample Programs"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Fibonacci sequence generator\n",
      "def iter_fibo(n):\n",
      "    a = 0\n",
      "    b = 1\n",
      "    for i in range(n):\n",
      "        a, b = b, a+b\n",
      "    return a\n",
      "\n",
      "#With recursion (Recursion) using \"memoization\" to improve performace\n",
      "def rec_fibo(n):\n",
      "    mem = {0:0,1:1}\n",
      "    if n not in mem:\n",
      "        mem[n] = rec_fibo(n-1) + rec_fibo(n-2)\n",
      "    \n",
      "    return mem[n]        \n",
      "        \n",
      "n = eval(input(\"Enter the value of n: \"))\n",
      "print(\"****Without Recursion****\")\n",
      "for i in range(n):\n",
      "    print(iter_fibo(i), end = \" \")\n",
      "\n",
      "print(\"\\n****With Recursion****\")\n",
      "for i in range(n):\n",
      "    print(rec_fibo(i), end = \" \")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "name": "stdout",
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Enter the value of n: 5\n"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "****Without Recursion****\n",
        "0 1 1 2 3 \n",
        "****With Recursion****\n",
        "0 1 1 2 3 "
       ]
      }
     ],
     "prompt_number": 6
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Pascal's Triangle:\n",
      "print ([1])\n",
      "list_prev = [1,1]\n",
      "print(list_prev)\n",
      "for j in range(0,4):\n",
      "    list_curr = [1]\n",
      "    for i in range(1,len(list_prev)):\n",
      "        list_curr.append(list_prev[i-1] + list_prev[i])\n",
      "    list_curr.append(1)\n",
      "    print(list_curr)\n",
      "    list_prev = list_curr[:]\n",
      "\n",
      "#Using identity\n",
      "numb = 5\n",
      "print((numb)*\" \" + str(1), end = \"\")\n",
      "for n in range(1,numb+1):\n",
      "    print(\"\")\n",
      "    prev_elem = 1\n",
      "    print((numb-n)*\" \" + str(prev_elem), end = \" \")\n",
      "    for k in range(1,n+1):\n",
      "        prev_elem *= (n-k+1)/k\n",
      "        print(int(prev_elem), end = \" \")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[1]\n",
        "[1, 1]\n",
        "[1, 2, 1]\n",
        "[1, 3, 3, 1]\n",
        "[1, 4, 6, 4, 1]\n",
        "[1, 5, 10, 10, 5, 1]\n",
        "     1\n",
        "    1 1 \n",
        "   1 2 1 \n",
        "  1 3 3 1 \n",
        " 1 4 6 4 1 \n",
        "1 5 10 10 5 1 "
       ]
      }
     ],
     "prompt_number": 7
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for i in range(1,16):\n",
      "    if i%3 == 0 and i%5 == 0:\n",
      "        print(\"FizzBuzz\", end = \" \")\n",
      "    elif i%3 == 0:\n",
      "        print(\"Fizz\", end = \" \")\n",
      "    elif i%5 == 0:\n",
      "        print(\"Buzz\", end = \" \")\n",
      "    else:\n",
      "        print(i, end = \" \")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz "
       ]
      }
     ],
     "prompt_number": 8
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#string reversal\n",
      "string=\"apple\"\n",
      "i = len(string)-1\n",
      "while i >= 0:\n",
      "    print(string[i], end=\"\")\n",
      "    i = i-1;"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "elppa"
       ]
      }
     ],
     "prompt_number": 9
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#check if 2 input words are anagrams\n",
      "string1 = input(\"First word: \")\n",
      "string2 = input(\"Second word: \")\n",
      "if(sorted(string1)==sorted(string2)):\n",
      "    print(\"anagram\")\n",
      "else:\n",
      "    print(\"not anagram\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "name": "stdout",
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "First word: apple\n"
       ]
      },
      {
       "name": "stdout",
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Second word: leppa\n"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "anagram\n"
       ]
      }
     ],
     "prompt_number": 10
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Acronym generator\n",
      "phrase = input(\"Enter the phrase for which you need acronym for: \")\n",
      "words = phrase.upper().split();\n",
      "for item in words:\n",
      "    if(item not in [\"OF\" , \"&\" , \"AND\"]):\n",
      "        print(item[0], end=\"\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "name": "stdout",
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Enter the phrase for which you need acronym for: Vignan University\n"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "VU"
       ]
      }
     ],
     "prompt_number": 11
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#count the number of occurences of a letter in a string\n",
      "def charCount(character, string):\n",
      "    count = 0\n",
      "    for each_char in string:\n",
      "        if each_char == character:\n",
      "            count = count+1\n",
      "    return count\n",
      "\n",
      "string = input(\"Enter a word or a sentence: \")\n",
      "character = input(\"Enter a letter for which you would like to get the # of occurences: \")\n",
      "\n",
      "count = charCount(character, string)\n",
      "\n",
      "print(\"The character '\" + character + \"' occured \" + str(count) + \" times in the sentence '\" \n",
      "      + string + \"'\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "name": "stdout",
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Enter a word or a sentence: apple is good\n"
       ]
      },
      {
       "name": "stdout",
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Enter a letter for which you would like to get the # of occurences: e\n"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "The character 'e' occured 1 times in the sentence 'apple is good'\n"
       ]
      }
     ],
     "prompt_number": 12
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Find if a given number is prime or not\n",
      "def isPrime(number):\n",
      "    for i in range(2,round(number**0.5)+1):\n",
      "        if number%i == 0:\n",
      "            return False\n",
      "    return True\n",
      "\n",
      "number = input(\"Enter a number: \")\n",
      "if isPrime(int(number)) == True:\n",
      "    print(number + \" is prime!\")\n",
      "else:\n",
      "    print(number + \" is not prime!\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "name": "stdout",
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Enter a number: 25\n"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "25 is not prime!\n"
       ]
      }
     ],
     "prompt_number": 13
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Guess the number game\n",
      "import random\n",
      "Name = input(\"Hello what is your name? \")\n",
      "print(\"Well \" + Name + \" I am thinking of a number between 1 and 20.\")\n",
      "compGenNumb = random.randint(1,20)\n",
      "attempts = 0\n",
      "while attempts < 6:\n",
      "    print(\"Take a guess\")\n",
      "    guess = input()\n",
      "    if int(guess) > compGenNumb:\n",
      "        print(\"Your guess is too high! Try again\")\n",
      "    elif int(guess) < compGenNumb:\n",
      "        print(\"Your guess is too low! Try again\")\n",
      "    else:\n",
      "        print(\"You lucky dawg, you guessed it right\")\n",
      "        break\n",
      "    attempts = attempts+1\n",
      "if attempts == 6:\n",
      "    print(\"Sorry you ran out of lives !!! Looser!!! Looser!!! Looser!!!\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "name": "stdout",
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Hello what is your name? sri\n"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Well sri I am thinking of a number between 1 and 20.\n",
        "Take a guess\n"
       ]
      },
      {
       "name": "stdout",
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "20\n"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Your guess is too high! Try again\n",
        "Take a guess\n"
       ]
      },
      {
       "name": "stdout",
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "10\n"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Your guess is too high! Try again\n",
        "Take a guess\n"
       ]
      },
      {
       "name": "stdout",
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "5\n"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Your guess is too low! Try again\n",
        "Take a guess\n"
       ]
      },
      {
       "name": "stdout",
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "7\n"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "You lucky dawg, you guessed it right\n"
       ]
      }
     ],
     "prompt_number": 14
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Hangman game\n",
      "import random\n",
      "Ascii_art_images = {\n",
      "0:\n",
      "'''\n",
      "  +----+\n",
      "  |    |\n",
      "       |\n",
      "       |\n",
      "       |\n",
      "       |\n",
      "-------+-------      \n",
      "'''\n",
      ",\n",
      "1:\n",
      "'''\n",
      "  +----+\n",
      "  |    |\n",
      "  o    |\n",
      "       |\n",
      "       |\n",
      "       |\n",
      "-------+-------      \n",
      "'''\n",
      ",\n",
      "2:\n",
      "'''\n",
      "  +----+\n",
      "  |    |\n",
      "  o    |\n",
      " /     |\n",
      "       |\n",
      "       |\n",
      "-------+-------      \n",
      "'''\n",
      ",\n",
      "3:\n",
      "'''\n",
      "  +----+\n",
      "  |    |\n",
      "  o    |\n",
      " /|    |\n",
      "       |\n",
      "       |\n",
      "-------+-------      \n",
      "'''\n",
      ",\n",
      "4:\n",
      "'''\n",
      "  +----+\n",
      "  |    |\n",
      "  o    |\n",
      " /|\\   |\n",
      "       |\n",
      "       |\n",
      "-------+-------      \n",
      "'''\n",
      ",\n",
      "5:\n",
      "'''\n",
      "  +----+\n",
      "  |    |\n",
      "  o    |\n",
      " /|\\   |\n",
      " /     |\n",
      "       |\n",
      "-------+-------      \n",
      "'''\n",
      ",\n",
      "6:\n",
      "'''\n",
      "  +----+\n",
      "  |    |\n",
      "  o    |\n",
      " /|\\   |\n",
      " / \\   |\n",
      "       |\n",
      "-------+-------      \n",
      "'''\n",
      "}\n",
      "\n",
      "words = [\"aardvark\",\"antelope\",\"bat\",\"cat\",\"dog\",\"elephant\",\"frog\",\"goat\",\n",
      "         \"horse\"]\n",
      "\n",
      "alphabets = [\"A\",\"B\",\"C\",\"D\",\"E\",\"F\",\"G\",\"H\",\"I\",\"J\",\"K\",\"L\",\n",
      "            \"M\",\"N\",\"O\",\"P\",\"Q\",\"R\",\"S\",\"T\",\"U\",\"V\",\"W\",\"X\",\"Y\",\"Z\"]\n",
      "def genRandomWord():\n",
      "    return words[random.randint(0,len(words)-1)]\n",
      "\n",
      "def displayBoard(wordList):\n",
      "    print(\"|\" + \"|\".join(wordList) + \"|\")\n",
      "    \n",
      "def isValidGuess(letter, guessedLetters):\n",
      "    if letter not in alphabets:\n",
      "        print(\"Your guess can only be an alphabet from A to Z. Try again\")\n",
      "        return False\n",
      "    elif letter in guessedLetters:\n",
      "        print(\"You have already guessed \" + letter + \" Try again\")\n",
      "        print(guessedLetters)\n",
      "        return False\n",
      "    else:\n",
      "        guessedLetters.append(letter)\n",
      "        return True\n",
      "        \n",
      "        \n",
      "print(\"Welcome to HANGMAN the ultimate word guessing game\")\n",
      "\n",
      "compGeneratedWord = genRandomWord().upper()\n",
      "compGenWordList = list(compGeneratedWord)\n",
      "guessInComplete = True\n",
      "guessedLetters = []\n",
      "lives = 0\n",
      "displayIndex = 0\n",
      "guessedCorrectly = [\"*\"]*len(compGeneratedWord)\n",
      "print(Ascii_art_images.get(displayIndex))\n",
      "print(\"|_\"*len(compGeneratedWord)+\"|\")\n",
      "\n",
      "while ( lives < 6 and (\"*\" in guessedCorrectly) ):\n",
      "    print(\"Guess a letter : \", end=\"\")\n",
      "    userGuess=input().upper()\n",
      "    \n",
      "    while (not isValidGuess(userGuess, guessedLetters)):\n",
      "        userGuess=input().upper()\n",
      "\n",
      "    if userGuess in compGenWordList:\n",
      "        print(\"Letter '\" + userGuess + \"' is in the word\")\n",
      "        for i in range(0,len(compGeneratedWord)):\n",
      "            if compGenWordList[i] == userGuess:\n",
      "                guessedCorrectly[i] = userGuess\n",
      "        displayBoard(guessedCorrectly)\n",
      "    else:\n",
      "        lives = lives+1\n",
      "        print(Ascii_art_images.get(lives))\n",
      "\n",
      "\n",
      "if (lives <6 ):\n",
      "    print(\"Congrats you guessed the word '\" + compGeneratedWord + \" 'correctly\")\n",
      "else:\n",
      "    print(\"Sorry!!! No more chances left. The word is '\" + compGeneratedWord + \"'\")\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "class Point:\n",
      "    '''Geometric representation of point'''\n",
      "    def __init__(self,x,y):\n",
      "        '''Initialization Method'''\n",
      "        self.move(x,y)\n",
      "    def move(self, x, y):\n",
      "        '''Move the point to the co-ordinates supplied'''\n",
      "        self.x = x\n",
      "        self.y = y\n",
      "    def reset(self):\n",
      "        self.move(0,0)\n",
      "    def calc_distance(self, other_point):\n",
      "        return math.sqrt(\n",
      "                (self.x-other_point.x)**2 +\n",
      "                (self.y-other_point.y)**2)\n",
      "\n",
      "p1 = Point(4,5)\n",
      "p2 = Point(5,4)\n",
      "    #Point.move(p1,4,5)    \n",
      "#Point.move(p2,2.0,3.0)\n",
      "assert(Point.calc_distance(p1,p2)==Point.calc_distance(p2,p1))\n",
      "print(Point.calc_distance(p1,p2))\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1.4142135623730951\n"
       ]
      }
     ],
     "prompt_number": 16
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class SecretString:\n",
      "    '''A not-at-all secure way to store a secret string.'''\n",
      "    def __init__(self, plain_string, pass_phrase):\n",
      "        self.__plain_string = plain_string\n",
      "        self.__pass_phrase = pass_phrase\n",
      "    def decrypt(self, pass_phrase):\n",
      "        '''Only show the string if the pass_phrase is correct.'''\n",
      "        if pass_phrase == self.__pass_phrase:\n",
      "            return self.__plain_string\n",
      "        else:\n",
      "            return ''\n",
      "\n",
      "secret_string = SecretString(\"ACME: Top Secret\", \"antwerp\")\n",
      "#print(secret_string.decrypt(\"antwerp\"))\n",
      "print(secret_string.SecretString__plainstring)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "ename": "AttributeError",
       "evalue": "'SecretString' object has no attribute 'SecretString__plainstring'",
       "output_type": "pyerr",
       "traceback": [
        "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
        "\u001b[0;32m<ipython-input-17-f1af436a9083>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0msecret_string\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mSecretString\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"ACME: Top Secret\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"antwerp\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     14\u001b[0m \u001b[0;31m#print(secret_string.decrypt(\"antwerp\"))\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 15\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msecret_string\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mSecretString__plainstring\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
        "\u001b[0;31mAttributeError\u001b[0m: 'SecretString' object has no attribute 'SecretString__plainstring'"
       ]
      }
     ],
     "prompt_number": 17
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "choice = input(\"Enter your choice: \")\n",
      "def print_apple():\n",
      "    print(\"apple\")\n",
      "def print_pear():\n",
      "    print(\"pear\")\n",
      "\n",
      "fruits = {\n",
      "    \"1\": print_apple,\n",
      "    \"2\": print_pear\n",
      "}\n",
      "\n",
      "fruit = fruits.get(choice)\n",
      "if fruit:\n",
      "    fruit()\n",
      "else:\n",
      "    print(\"{0} is not a valid choice\".format(choice))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class Contact:\n",
      "    all_contacts = []\n",
      "    def __init__(self, name, email):\n",
      "        self.name = name\n",
      "        self.email = email\n",
      "        Contact.all_contacts.append(self)\n",
      "        \n",
      "class Supplier(Contact):\n",
      "    def order(self, order):\n",
      "        print(\"If this were a real system we would send \"\n",
      "            \"{} order to {}\".format(order, self.name))\n",
      "\n",
      "mySupplier = Supplier(\"Sri\",\"spaladug@gmail.com\")\n",
      "mySupplier.order(\"Apple\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class ContactList(list):\n",
      "    def search(self, name):\n",
      "        matching_contacts = []\n",
      "        for contact in self:\n",
      "            if name in contact.name:\n",
      "                matching_contacts.append(contact)\n",
      "        return matching_contacts\n",
      "    \n",
      "class Contact:\n",
      "    all_contacts = ContactList()\n",
      "    def __init__(self,name,email):\n",
      "        self.name = name\n",
      "        self.email = email\n",
      "        Contact.all_contacts.append(self)\n",
      "\n",
      "firstContact = Contact(\"John Chu\", \"john1@gmail.com\")\n",
      "secondContact = Contact(\"Apple Mier\", \"john2@gmail.com\")\n",
      "[c.name for c in Contact.all_contacts.search(\"John\")]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = \"apple\"\n",
      "b = \"ppl\"\n",
      "if b in a:\n",
      "    print (\"found\")\n",
      "else:\n",
      "    print(\"not found\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class LongNameDict:\n",
      "    def longest_key(self):\n",
      "        longest = None\n",
      "        for key in self:\n",
      "            if not longest or len(key) > len(longest):\n",
      "                longest = key\n",
      "        return longest"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": []
    }
   ],
   "metadata": {}
  }
 ]
}