lesson 2/lecture-02.ipynb

{
 "metadata": {
  "name": ""
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "#Python Course, lesson 2\n",
      "#Advanced pure python"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "skip"
      }
     },
     "source": [
      "###Contents:\n",
      "- Programming paradigmes in Python\n",
      "    - Imperative programming\n",
      "    - Structural programming\n",
      "    - Functional programming\n",
      "    - Object oriented programming\n",
      "- Error handling\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "        "
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "##Programming paradigmes in Python\n",
      "###Overview\n",
      "- __Imperative programming__\n",
      "    - Use sequentially ordered statements to change program state\n",
      "- __Structural programming__\n",
      "    - Structure your code in modules\n",
      "- __Functional programming__\n",
      "    - Write you code as functions.\n",
      "    - Pure functional programming: No statements only functions without side effects\n",
      "- __Object- oriented programming__\n",
      "    - Distribute you code into classes"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "##Programming paradigmes in Python\n",
      "###Imperative programming\n",
      "Use sequentially ordered statements to change program state, as in iPython\n",
      "\n",
      "__Pro:__\n",
      "\n",
      "- Fast\n",
      "- Easy for small programs\n",
      "\n",
      "__Con:__\n",
      "\n",
      "- Chaotic for larger programs\n",
      "- Difficult to test`\n",
      "- Difficult to reuse code between programs\n",
      "- Difficult to reuse code in program -> Code duplication -> BAD!!!"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "##Programming paradigmes in Python\n",
      "###Example Prime list generator\n",
      "To simplify the example, 2 is ignored."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "n = 100\n",
      "primes = []\n",
      "for p in range(3,n):\n",
      "\n",
      "    \n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "n = 100\n",
      "primes = []\n",
      "for p in range(3,n):\n",
      "    for x in range(2,p):\n",
      "        if p%x==0:\n",
      "            break\n",
      "    else:\n",
      "        primes.append(p)\n",
      "print primes\n"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "notes"
      }
     },
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "n\n"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "notes"
      }
     },
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "##Programming paradigmes in Python\n",
      "###Structural programming\n",
      "Structure your code in modules and packages\n",
      "\n",
      "__Pro:__\n",
      "\n",
      "- Easy to reuse code between programs\n",
      "- Easier to reuse code in program\n",
      "\n",
      "\n",
      "__Con:__\n",
      "\n",
      "- You need to create and switch between multiple files(modules)\n",
      "- Difficult to test`\n",
      "\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import prime_module"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print prime_module.primes\n",
      "print prime_module.__file__"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "##Programming paradigmes in Python\n",
      "###Structural programming - packages\n",
      "package = folder containing (possibly empty) `__init__.py`\n",
      "\n",
      "Current working directory (cwd):\n",
      "\n",
      "- file: `prime_module.py` [function: \"def prime_list(n)...\"]\n",
      "- folder: `my_package`\n",
      "    - file: `__init__.py` [empty]\n",
      "    - file: `prime_module.py` [function: \"def prime_list(n)...\"]\n",
      "- folder: `my_folder`\n",
      "    - file: `prime_module.py` [function: \"def prime_list(n)...\"]\n",
      "        "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from my_package import prime_module\n",
      "print prime_module.primes\n",
      "print prime_module.__file__"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from my_folder import prime_module"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "##Programming paradigmes in Python\n",
      "###Functional programming\n",
      "Write you code as functions.\n",
      "Pure functional programming: No statements only functions without side effects\n",
      "\n",
      "__Pro:__\n",
      "\n",
      "- Easy to reuse code between programs\n",
      "- Easy to reuse code in program\n",
      "- Very easy to test as a function given the same input always produces the same output\n",
      "\n",
      "__Con:__\n",
      "\n",
      "- Chaotic for large programs if not structured into modules\n",
      "- No state -> results cannot be reused -> slow (depending on intelligence of compiler/interpreter)\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "n = 100\n",
      "primes = []\n",
      "for p in range(3,n):\n",
      "    for x in range(2,p):\n",
      "        if p%x==0:\n",
      "            break\n",
      "    else:\n",
      "        primes.append(p)\n",
      "print primes"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def prime_list(n):\n",
      "    primes = []\n",
      "    for p in range(3,n):\n",
      "        for x in range(2,p):\n",
      "            if p%x==0:\n",
      "                break\n",
      "        else:\n",
      "            primes.append(p)\n",
      "    return primes\n",
      "print prime_list(100)"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "notes"
      }
     },
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def prime_list(n):\n",
      "    primes = []\n",
      "    for p in range(3,n):\n",
      "        if is_prime(p):\n",
      "            primes.append(p)\n",
      "    return primes\n",
      "\n",
      "def is_prime(p):\n",
      "    for x in range(2,p):\n",
      "        if p%x==0:\n",
      "            return False\n",
      "    else:\n",
      "        return True\n",
      "print prime_list(100)"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "notes"
      }
     },
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def prime_list(n):\n",
      "    return [p for p in range(3,n) if is_prime(p)]\n",
      "\n",
      "def is_prime(p):\n",
      "    return all([p%x for x in xrange(2,p)])\n",
      "    \n",
      "print prime_list(100)"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "notes"
      }
     },
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def prime_list(n):\n",
      "    return [p for p in range(3,n) if all([p%x for x in xrange(2,p)])]\n",
      "\n",
      "    \n",
      "print prime_list(100)"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "notes"
      }
     },
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "#Programming paradigmes in Python\n",
      "##Functional programming - functions\n",
      "- __map__(*function, sequence*) -> list (python 3: generator)\n",
      "    - Apply function to each element in sequence\n",
      "- __filter__(*function, sequence*) -> list (python 3: generator)\n",
      "    - Filter sequence to contain elements where function(element)==True only\n",
      "- __reduce__(*function, sequence*) -> object\n",
      "    - Reduce sequence to single value by a function f(x,y) -> z, i.e.\n",
      "      f(s[0], f(s[1], f(s[3], s[4])))\n",
      "    - Ex: `reduce(sum, [2,4,6])` -> sum(2, sum(4, 6)) -> sum(2,10) -> 12"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def prime_list(n):\n",
      "    return [p for p in range(3,n) if is_prime(p)]\n",
      "\n",
      "def is_prime(p):\n",
      "    return all([p%x for x in range(2,p)])\n",
      "    \n",
      "print prime_list(100)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def prime_list(n):\n",
      "    def add(a,b):\n",
      "        return a+b\n",
      "    return reduce(add, filter(is_prime, range(3,n)))\n",
      "\n",
      "def is_prime(p):\n",
      "    def not_div(x):\n",
      "        return p%x>0\n",
      "    return all(map(not_div,range(2,p)))\n",
      "    \n",
      "print prime_list(100)"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "notes"
      }
     },
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "#list vs generator\n",
      "- __List__\n",
      "    - All elements generated at once\n",
      "- __Generator__ (lazy list)\n",
      "    - Elements generated when needed"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "###List"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def my_list(n):\n",
      "    l = []\n",
      "    i = 0\n",
      "    while i<n:\n",
      "        l.append(i)\n",
      "        i+=1\n",
      "    return l\n",
      "\n",
      "print my_list(10)\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def my_list(n):\n",
      "    l = []\n",
      "    for i in range(n):\n",
      "        l.append(i)\n",
      "    return l\n",
      "\n",
      "print my_list(10)"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "notes"
      }
     },
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def my_list(n):\n",
      "    return [x for x in range(n)]\n",
      "\n",
      "print my_list(10)\n"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "notes"
      }
     },
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def my_list(n):\n",
      "    return range(n)\n",
      "\n",
      "print my_list(10)"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "notes"
      }
     },
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "my_list = range\n",
      "print my_list(10)"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "notes"
      }
     },
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "###Generator"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def my_generator(n):\n",
      "    i = 0\n",
      "    while i<n:\n",
      "        yield(i)\n",
      "        i+=1\n",
      "    \n",
      "print my_generator(10)    \n",
      "\n",
      "\n",
      "\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for i in my_generator(5):\n",
      "    print i"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def my_generator(n):\n",
      "    for in xrange(n):\n",
      "        yield(i)\n",
      "    \n",
      "print my_generator(10)   "
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "notes"
      }
     },
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def my_generator(n):\n",
      "    return (x for x in xrange(n))\n",
      "print my_generator(10)"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "notes"
      }
     },
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "my_generator = xrange\n",
      "print my_generator(10)"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "notes"
      }
     },
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def test(range_, exp=30):\n",
      "    for x in range_(2**exp):\n",
      "        if x==3:\n",
      "            break"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#test with generator\n",
      "%timeit test(xrange)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#test with list\n",
      "%timeit test(range,30)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "`[x for x in ...]`  -> List\n",
      "\n",
      "`(x for x in ...)`  -> Generator\n",
      "\n",
      "##Python 2:\n",
      "- __xrange__: Generator\n",
      "- __range__: List\n",
      "\n",
      "##Python 3 (+ python 2 when using template.py)\n",
      "- __xrange__: Gone!!!\n",
      "- __range__: Generator\n",
      "- __list(range(x))__: List"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "#Programming paradigmes in Python\n",
      "##Functional programming - Anonyous lambda functions\n",
      "\n",
      "`lambda arg_0,...,arg_n : <function body>`\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def pow(x,e=2):\n",
      "    return x**e\n",
      "print pow(4)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#refactor\n",
      "pow = lambda x: x**2\n",
      "print pow(4)"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "notes"
      }
     },
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#refactor\n",
      "print (lambda x: x**2)(5)"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "notes"
      }
     },
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#example\n",
      "print  map(lambda x: x**2, range(4))"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "notes"
      }
     },
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "#Exercise: Lazy prime list generator"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Modify `generator_map` to be a generator version of the of the built-in `map` function"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def generator_map(f,seq):\n",
      "    return map(f,seq) #Modify this line\n",
      "\n",
      "#Test\n",
      "assert not isinstance(generator_map(lambda x : x**2, [1,2,3,4]), list)\n",
      "for a,b in zip(generator_map(lambda x : x**2, [1,2,3,4]), [1,4,9,16]):\n",
      "    assert a==b\n",
      "assert a==b==16\n",
      "print \"Yeah!\"    "
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "In order to benefit from `generator_map` being a generator, `is_primes` must return as soon as _any_ number that is divisible by x is found.\n",
      "\n",
      "- Modify `is_prime_any` to use `any` instead of `all`\n",
      "- Note how it is tested without code duplication!!!"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def is_prime_all(p):\n",
      "    return all(map(lambda x : p%x, xrange(2,p)))\n",
      "\n",
      "def is_prime_any(p,map_=map):\n",
      "    return all(map_(lambda x : p%x, xrange(2,p))) #Modify this line\n",
      "\n",
      "for p in range(3,100):\n",
      "    for map_ in [map, generator_map]:\n",
      "        assert is_prime_all(p)==is_prime_any(p, map_)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "- Finish `is_prime_generator2` to be a lambda function analougue to `is_prime_generator2`\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def prime_list(n, is_prime_func=is_prime_all):\n",
      "    return map(is_prime_func, range(3,n))\n",
      "\n",
      "\n",
      "def is_prime_generator1(p):\n",
      "    return is_prime_any(p, generator_map)\n",
      "\n",
      "#Your generator lambda function\n",
      "is_prime_generator2 = lambda p ...\n",
      "\n",
      "\n",
      "\n",
      "assert prime_list(100)==prime_list(100, is_prime_generator1)\n",
      "assert prime_list(100)==prime_list(100, is_prime_generator2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "###Speed test \n",
      "- What do you expect\n",
      "- Run test below\n",
      "- Was the result as expected\n",
      "- Try other values of n\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "n=1000\n",
      "%timeit prime_list(n)\n",
      "%timeit prime_list(n, lambda p : is_prime_any(p, generator_map))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "##Programming paradigmes in Python\n",
      "###Object-oriented programming\n",
      "Organize code in classes\n",
      "\n",
      "__Pro:__\n",
      "\n",
      "- Cohession: State and method can be organized in coherrent objects\n",
      "- Encapsulation: Implementation details can be hidden for users by private fields and methods (Limited support)\n",
      "- Decoupling: Programs can be split into decoupled classes, that interacts via a simple interface (Limited support)\n",
      "- Inherritance: Extend and change existing classes (instead of copy/paste/modify = code duplication = Bad!!!)\n",
      "\n",
      "- Testing may be easy\n",
      "\n",
      "__Con:__\n",
      "\n",
      "- Some overhead for simple programs\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class Prime(object):\n",
      "    def __init__(self, n, last_number):\n",
      "        self.n = n\n",
      "        self.last_number = last_number\n",
      "\n",
      "    def last_prime(self):\n",
      "        return self.n\n",
      "\n",
      "    def __str__(self):\n",
      "        return \"I am: %2d, prime: %s,\\tprev prime: %s\" % (self.n, \n",
      "                                                          bool(isinstance(self, Prime)), \n",
      "                                                          self.last_number.last_prime())\n",
      "\n",
      "\n",
      "class NonPrime(object):\n",
      "    def __init__(self, n, last_number):\n",
      "        self.n = n\n",
      "        self.last_number = last_number\n",
      "\n",
      "    def last_prime(self):\n",
      "        return self.last_number.last_prime()\n",
      "\n",
      "    def __str__(self):\n",
      "        return \"I am: %2d, prime: %s,\\tprev prime: %s\" % (self.n, \n",
      "                                                          bool(isinstance(self, Prime)), \n",
      "                                                          self.last_number.last_prime())\n",
      "\n",
      "class Two(object):\n",
      "    def __init__(self):\n",
      "        self.n = 2\n",
      "        self.last_number = None\n",
      "\n",
      "    def last_prime(self):\n",
      "        return self.n\n",
      "\n",
      "    def __str__(self):\n",
      "        return \"I am:  2, prime: True,\\tprev prime: --\"\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "is_prime = lambda n : all([n%x for x in range(2,n)])\n",
      "\n",
      "numbers = [Two()]\n",
      "\n",
      "for n in range(3,13):\n",
      "    if is_prime(n):\n",
      "        numbers.append(Prime(n, numbers[-1]))\n",
      "    else:\n",
      "        numbers.append(NonPrime(n, numbers[-1]))\n",
      "\n",
      "for n in numbers:\n",
      "    print n"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "I am:  2, prime: True,\tprev prime: --\n",
        "I am:  3, prime: True,\tprev prime: 2\n",
        "I am:  4, prime: False,\tprev prime: 3\n",
        "I am:  5, prime: True,\tprev prime: 3\n",
        "I am:  6, prime: False,\tprev prime: 5\n",
        "I am:  7, prime: True,\tprev prime: 5\n",
        "I am:  8, prime: False,\tprev prime: 7\n",
        "I am:  9, prime: False,\tprev prime: 7\n",
        "I am: 10, prime: False,\tprev prime: 7\n",
        "I am: 11, prime: True,\tprev prime: 7\n",
        "I am: 12, prime: False,\tprev prime: 11\n"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#refactor\n",
      "class Number(object):\n",
      "    def __init__(self, n, last_number):\n",
      "        self.n = n\n",
      "        self.last_number = last_number\n",
      "\n",
      "    def info(self, prev_prime):\n",
      "        return \"I am: %2d, prime: %s,\\tprevious prime: %s\" % (self.n, \n",
      "                                    bool(isinstance(self, Prime)), \n",
      "                                    prev_prime)\n",
      "        \n",
      "    def __str__(self):\n",
      "        return self.info(self.last_number.last_prime())\n",
      "    \n",
      "class Prime(Number):\n",
      "    def last_prime(self):\n",
      "        return self.n\n",
      "\n",
      "class NonPrime(Number):\n",
      "    def last_prime(self):\n",
      "        return self.last_number.last_prime()\n",
      "\n",
      "    \n",
      "class Two(Prime):\n",
      "    def __init__(self):\n",
      "        Prime.__init__(self, 2,None)\n",
      "\n",
      "    def __str__(self):\n",
      "        return self.info(\"--\")\n",
      "\n",
      "\n",
      "\n",
      "is_prime = lambda n : all([n%x for x in range(2,n)])\n",
      "\n",
      "numbers = [Two()]\n",
      "\n",
      "for n in range(3,13):\n",
      "    if is_prime(n):\n",
      "        numbers.append(Prime(n, numbers[-1]))\n",
      "    else:\n",
      "        numbers.append(NonPrime(n, numbers[-1]))\n",
      "\n",
      "for n in numbers:\n",
      "    print n"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "notes"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "I am:  2, prime: True,\tprevious prime: --\n",
        "I am:  3, prime: True,\tprevious prime: 2\n",
        "I am:  4, prime: False,\tprevious prime: 3\n",
        "I am:  5, prime: True,\tprevious prime: 3\n",
        "I am:  6, prime: False,\tprevious prime: 5\n",
        "I am:  7, prime: True,\tprevious prime: 5\n",
        "I am:  8, prime: False,\tprevious prime: 7\n",
        "I am:  9, prime: False,\tprevious prime: 7\n",
        "I am: 10, prime: False,\tprevious prime: 7\n",
        "I am: 11, prime: True,\tprevious prime: 7\n",
        "I am: 12, prime: False,\tprevious prime: 11\n"
       ]
      }
     ],
     "prompt_number": 2
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "##Exercise Magic number\n",
      "Make a class `MagicInt` that satisfies the assert statements, i.e:\n",
      "\n",
      "- Is a int\n",
      "- Makes 2 + 2 = 5\n",
      "- Result of addition is also a MagicInt object\n",
      "- Lets len(magicInt) return the number of digits\n",
      "- Has a property `prime` that returns `True` the if it is a prime.\n",
      "- Allows the user to set the `prime` property manually"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class MagicInt(...\n",
      "    \n",
      "        \n",
      "#Do not modify code below\n",
      "two = MagicInt(2)\n",
      "m127 = MagicInt(127)\n",
      "\n",
      "# a int\n",
      "assert isinstance(two, int)\n",
      "\n",
      "# 2 + 2 = 5\n",
      "assert two + two == 5\n",
      "assert two + 3 == 5\n",
      "\n",
      "#Result of addition is also a MInt object\n",
      "assert isinstance(two + two, MagicInt)\n",
      "assert isinstance(two + 3, MagicInt)\n",
      "\n",
      "# len() return the number of digits\n",
      "assert len(two)==1\n",
      "assert len(m127) == 3\n",
      "assert len(MagicInt(-127)) == 3\n",
      "\n",
      "# property prime that returns True the if it is a prime\n",
      "assert m127.prime\n",
      "assert (two+m127).prime==False\n",
      "\n",
      "# Allow the user to set the 'prime' property manually\n",
      "m127.prime = False\n",
      "assert m127.prime==False\n",
      "\n",
      "print \"Yeah!!! All asserts satisfied\"\n",
      "\n",
      "\n",
      "  \n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    }
   ],
   "metadata": {}
  }
 ]
}