Day1 - synchrotron 2015 training advanced - group 2.ipynb

{
 "metadata": {
  "name": "",
  "signature": "sha256:b9706bff71835c02334c9d080f11d1ef7dd2624178aa49933cb007e94790aacb"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "Python Advanced Course - Day 1"
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Course Outline"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "    ADVANCED PYTHON COURSE \n",
      "\n",
      "    This python course will cover the following (in no particular order): \n",
      "\n",
      "    Python Revision\n",
      "        types, dictionaries, lists\n",
      "        variables\n",
      "        functions, classes\n",
      "        modules, import\n",
      "        python interpreter\n",
      "        SortedDict\n",
      "\n",
      "    Object Oriented Programming\n",
      "        general revision, methods and attributes / properties\n",
      "        inheritance vs composition\n",
      "        Multiple Inheritance\n",
      "\n",
      "    Modular Programming\n",
      "        swapping out functions, objects even modules\n",
      "        interfaces and keeping them the same - 'programming to interfaces'\n",
      "        architectural layers\n",
      "\n",
      "    Creating a professional project structure\n",
      "        How to organise your modules\n",
      "        Import statements - tricks and trap and best practice\n",
      "\n",
      "    Design Patterns\n",
      "        Introduction to Patterns\n",
      "        Patterns: General Issues\n",
      "        Strategy pattern\n",
      "            factory\n",
      "            adapter\n",
      "                adapter interface implements push and pop 'nice_list1'\n",
      "                nice_list1 - adds push, pop and implements in terms of US python list\n",
      "                nice_list2 - has push, pop and implements in terms of UK collections.deque\n",
      "        Observer pattern\n",
      "        Adapter pattern\n",
      "\n",
      "    Agile and Team Programming\n",
      "        Unit testing   *** TESTING ***\n",
      "            Unit vs Integration\n",
      "        Agile project planning\n",
      "\n",
      "    Logging\n",
      "        Some ideas in the Flask tutorial above\n",
      "\n",
      "    Closures and *args and **kwargs\n",
      "        http://simeonfranklin.com/blog/2012/jul/1/python-decorators-in-12-steps/\n",
      "        Lambda operator by itself and in combination with map, filter or reduce functions\n",
      "        Generators\n",
      "\n",
      "    Decorators\n",
      "        classic intro - http://en.wikipedia.org/wiki/Python_syntax_and_semantics#Decorators\n",
      "        great practical TUTORIAL - http://pydanny-event-notes.readthedocs.org/en/latest/PyconAU2011/decorators.html\n",
      "            includes property, setter\n",
      "        staticmethod or classmethod \n",
      "        pre condition decorator - http://stackoverflow.com/questions/12151182/python-precondition-postcondition-for-member-function-how\n",
      "        ADVANCED\tbuild your own\n",
      "        http://www.pydanny.com/python-decorator-cheatsheet.html \n",
      "\n",
      "\n",
      "    SHELL programming\n",
      "        basics of shell commands and the console\n",
      "        http://www.python-course.eu/os_module_shell.php\n",
      "        sys module \n",
      "            http://www.python-course.eu/sys_module.php\n",
      "\n",
      "    Database\n",
      "        sqllite, http://www.python-course.eu/sql_python.php\n",
      "        Firefox DB tool\n",
      "        SQL\n",
      "        Postgres\n",
      "\n",
      "    Web Development with Python - Flask ?? \n",
      "        requests library\n",
      "        Http\n",
      "        MVC\n",
      "        routes, views, templates, models\n",
      "        DB\n",
      "        Flask - http://flask.pocoo.org/    ** MORE WEIGHT ON THIS ***\n",
      "            TUTORIAL http://flask.pocoo.org/docs/0.10/quickstart/#a-minimal-application\n"
     ]
    },
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "Revision of Python"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = 1\n",
      "print x"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1\n"
       ]
      }
     ],
     "prompt_number": 2
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "this is how to **assign a value** to a variable"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = 1\n",
      "x = \"fred\"\n",
      "x = 'fred'\n",
      "x = \"\"\"fred's mum and she was called \"sally\"\n",
      "\n",
      "\"\"\"\n",
      "print x"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "fred's mum and she was called \"sally\"\n",
        "\n",
        "\n"
       ]
      }
     ],
     "prompt_number": 3
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = \"\\\"\"\n",
      "print x"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\"\n"
       ]
      }
     ],
     "prompt_number": 5
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = r'sdf\\\"''sssdfsdfsdfZZ'  # to investigate\n",
      "print x"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "sdf\\\"sssdfsdfsdfZZ\n"
       ]
      }
     ],
     "prompt_number": 7
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = 12.0\n",
      "print x"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "12.0\n"
       ]
      }
     ],
     "prompt_number": 8
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print 4/5.0\n",
      "print 4/float(5)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "0.8\n",
        "0.8\n"
       ]
      }
     ],
     "prompt_number": 13
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = True\n",
      "x = False\n",
      "x = 4 > 5\n",
      "print x"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "False\n"
       ]
      }
     ],
     "prompt_number": 14
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "type(False)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 15,
       "text": [
        "bool"
       ]
      }
     ],
     "prompt_number": 15
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "type(0)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 16,
       "text": [
        "int"
       ]
      }
     ],
     "prompt_number": 16
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print type(1), type(\"asd\"), type(True), type(1.0)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "<type 'int'> <type 'str'> <type 'bool'> <type 'float'>\n"
       ]
      }
     ],
     "prompt_number": 17
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = \"sdf\"\n",
      "assert type(x) == str  # cheap type checking trick"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 25
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = [1,2,3,4]\n",
      "print x"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[1, 2, 3, 4]\n"
       ]
      }
     ],
     "prompt_number": 26
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print type([])  "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "<type 'list'>\n"
       ]
      }
     ],
     "prompt_number": 27
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print [\"of\", \"course\", 1, 2, [3], [[[]]], True]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "['of', 'course', 1, 2, [3], [[[]]], True]\n"
       ]
      }
     ],
     "prompt_number": 28
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "d = {'name':'sam', 'address':'12 smith st'}\n",
      "print d\n",
      "print d['address']"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "{'name': 'sam', 'address': '12 smith st'}\n",
        "12 smith st\n"
       ]
      }
     ],
     "prompt_number": 29
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "d['name'] = 'mary'  # changing a dictionary\n",
      "print d"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "{'name': 'mary', 'address': '12 smith st'}\n"
       ]
      }
     ],
     "prompt_number": 30
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# dictionaries can be complex\n",
      "person = {\n",
      "    'name': 'fred',\n",
      "    'address': {\n",
      "        'number': 20,\n",
      "        'street': 'smith st'\n",
      "    },\n",
      "    'data' : ['came and visited today',\n",
      "              'phoned me up yesterday']\n",
      "}\n",
      "print person"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "{'data': ['came and visited today', 'phoned me up yesterday'], 'name': 'fred', 'address': {'street': 'smith st', 'number': 20}}\n"
       ]
      }
     ],
     "prompt_number": 34
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import pprint\n",
      "pprint.pprint(person)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "{'address': {'number': 20, 'street': 'smith st'},\n",
        " 'data': ['came and visited today', 'phoned me up yesterday'],\n",
        " 'name': 'fred'}\n"
       ]
      }
     ],
     "prompt_number": 35
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print person.keys()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "['data', 'name', 'address']\n"
       ]
      }
     ],
     "prompt_number": 38
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = (1,2)  # tuple - read only.  x = (1,) - tuple with one element\n",
      "x = [1,2]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 37
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import os\n",
      "print dir(os)[-20:]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "['system', 'tcgetpgrp', 'tcsetpgrp', 'tempnam', 'times', 'tmpfile', 'tmpnam', 'ttyname', 'umask', 'uname', 'unlink', 'unsetenv', 'urandom', 'utime', 'wait', 'wait3', 'wait4', 'waitpid', 'walk', 'write']\n"
       ]
      }
     ],
     "prompt_number": 42
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print os.curdir"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        ".\n"
       ]
      }
     ],
     "prompt_number": 41
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print \"ksadhajksdhkjashdiuwyiuweyr839732487238974mcn\"[-20:]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "yr839732487238974mcn\n"
       ]
      }
     ],
     "prompt_number": 43
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print \"abvcDEF\".lower()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "abvcdef\n"
       ]
      }
     ],
     "prompt_number": 44
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "using *dir* to list all methods (functions) in an object"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dir(\"asd\")[-10:]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 47,
       "text": [
        "['rstrip',\n",
        " 'split',\n",
        " 'splitlines',\n",
        " 'startswith',\n",
        " 'strip',\n",
        " 'swapcase',\n",
        " 'title',\n",
        " 'translate',\n",
        " 'upper',\n",
        " 'zfill']"
       ]
      }
     ],
     "prompt_number": 47
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dir(int)[-10:]  # just pull out the last few values"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 48,
       "text": [
        "['__subclasshook__',\n",
        " '__truediv__',\n",
        " '__trunc__',\n",
        " '__xor__',\n",
        " 'bit_length',\n",
        " 'conjugate',\n",
        " 'denominator',\n",
        " 'imag',\n",
        " 'numerator',\n",
        " 'real']"
       ]
      }
     ],
     "prompt_number": 48
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print \"some string\".__class__"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "<type 'str'>\n"
       ]
      }
     ],
     "prompt_number": 49
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "if True:\n",
      "    print \"yes\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "yes\n"
       ]
      }
     ],
     "prompt_number": 50
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for i in range(10,20,2):\n",
      "    print i,"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "10 12 14 16 18\n"
       ]
      }
     ],
     "prompt_number": 55
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "type(range(10,20,2))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 56,
       "text": [
        "list"
       ]
      }
     ],
     "prompt_number": 56
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print type(xrange(1,20))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "<type 'xrange'>\n"
       ]
      }
     ],
     "prompt_number": 57
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "functions"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# functions\n",
      "def add(a,b):\n",
      "    return a + b\n",
      "print add(10,20)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "30\n"
       ]
      }
     ],
     "prompt_number": 62
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# default parameters in a function\n",
      "def add(a=1, b=1):\n",
      "    return a + b\n",
      "print add()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "2\n"
       ]
      }
     ],
     "prompt_number": 81
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "classes"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# classes combine both data and behaviour\n",
      "class A:\n",
      "    pass\n",
      "a = A()\n",
      "print a"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "<__main__.A instance at 0x1047d4560>\n"
       ]
      }
     ],
     "prompt_number": 58
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print dir(A)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "['__doc__', '__module__']\n"
       ]
      }
     ],
     "prompt_number": 59
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class A:\n",
      "    def who_invented_python(self):\n",
      "        return \"this is guido\"\n",
      "    def add(self, a, b):\n",
      "        return a + b \n",
      "a = A()\n",
      "print dir(a)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "['__doc__', '__module__', 'add', 'who_invented_python']\n"
       ]
      }
     ],
     "prompt_number": 68
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print a.who_invented_python()\n",
      "print a.add(1,1)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "this is guido\n",
        "2\n"
       ]
      }
     ],
     "prompt_number": 69
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class A:\n",
      "    def __init__(self, a=0, b=0):\n",
      "        self.a = a\n",
      "        self.b = b\n",
      "    def who_invented_python(self):\n",
      "        return \"this is guido\"\n",
      "    def add(self):\n",
      "        return self.a + self.b \n",
      "a1 = A(1,2)\n",
      "a2 = A(100,200)\n",
      "a3 = A(59)\n",
      "print a1, a2, a3\n",
      "print a1.a, a1.b, 'result is', a1.add()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "<__main__.A instance at 0x104828a70> <__main__.A instance at 0x104828b48> <__main__.A instance at 0x104828830>\n",
        "1 2 result is 3\n"
       ]
      }
     ],
     "prompt_number": 75
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "my_objects = [a1, a2, a3, A(2000,1)]\n",
      "for a in my_objects:\n",
      "    print a, a.add()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "<__main__.A instance at 0x104828a70> 3\n",
        "<__main__.A instance at 0x104828b48> 300\n",
        "<__main__.A instance at 0x104828830> 59\n",
        "<__main__.A instance at 0x10480b3b0> 2001\n"
       ]
      }
     ],
     "prompt_number": 79
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for a in [a1, a2, a3, A(2000,1)]:\n",
      "    print \"Object %s contains a=%d b=%d which results in %d\" % (id(a), a.a, a.b, a.add())"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Object 4370631280 contains a=1 b=2 which results in 3\n",
        "Object 4370631496 contains a=100 b=200 which results in 300\n",
        "Object 4370630704 contains a=59 b=0 which results in 59\n",
        "Object 4370631928 contains a=2000 b=1 which results in 2001\n"
       ]
      }
     ],
     "prompt_number": 82
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Copies of objects vs. references to the same object\n",
      "print a\n",
      "c = a  # reference not a ccopy\n",
      "print id(a), id(c)\n",
      "print c.add()\n",
      "print a.add()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "<__main__.A instance at 0x104828cf8>\n",
        "4370631928 4370631928\n",
        "2001\n",
        "2001\n"
       ]
      }
     ],
     "prompt_number": 89
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "list1 = [1,2,3]\n",
      "list2 = list1  # a reference\n",
      "list1.append(4)\n",
      "print list1, list2"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[1, 2, 3, 4] [1, 2, 3, 4]\n"
       ]
      }
     ],
     "prompt_number": 90
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = 10\n",
      "def manipulate_int(n):\n",
      "    n = n+1\n",
      "manipulate_int(x)  # will x get changed?   no \n",
      "print x"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "10\n"
       ]
      }
     ],
     "prompt_number": 91
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print list1\n",
      "def manipulate_list(lzt):\n",
      "    lzt.append(4)\n",
      "manipulate_list(list1)  # will list1 get changed?  yes!!\n",
      "print list1"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[1, 2, 3, 4]\n",
        "[1, 2, 3, 4, 4]\n"
       ]
      }
     ],
     "prompt_number": 92
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      " - strings and integers (and probably tuples) are passed by value\n",
      " - lists and dictionaries and objects are passed by reference"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def manipulate_list(lzt):\n",
      "    lzt.append(4)\n",
      "    return lzt\n",
      "x = [1,2,3]\n",
      "y = manipulate_list(x)\n",
      "print y\n",
      "print x # has the original list been affected? - yes cos by reference\n",
      "# are x and y the same thing?"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[1, 2, 3, 4]\n",
        "[1, 2, 3, 4]\n"
       ]
      }
     ],
     "prompt_number": 93
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print id(x), id(y)\n",
      "print id(x) == id(y)\n",
      "print x is y"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "4370512928 4370512928\n",
        "True\n",
        "True\n"
       ]
      }
     ],
     "prompt_number": 96
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = [1,2,3]\n",
      "y = [1,2,3]  # a second 'instance' of a list\n",
      "print x is y"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "False\n"
       ]
      }
     ],
     "prompt_number": 97
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# [] is just syntactic 'sugar' to make instances of a list more easilt\n",
      "z = list()\n",
      "z.append(1)\n",
      "z.append(2)\n",
      "print z"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[1, 2]\n"
       ]
      }
     ],
     "prompt_number": 99
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dir(x)[-10:]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 100,
       "text": [
        "['__subclasshook__',\n",
        " 'append',\n",
        " 'count',\n",
        " 'extend',\n",
        " 'index',\n",
        " 'insert',\n",
        " 'pop',\n",
        " 'remove',\n",
        " 'reverse',\n",
        " 'sort']"
       ]
      }
     ],
     "prompt_number": 100
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x.insert(0, 9999)  # insert at start of a list\n",
      "print x"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[9999, 9999, 9999, 9999, 9999, 9999, 9999, 1, 2, 3]\n"
       ]
      }
     ],
     "prompt_number": 109
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print isinstance(x, list)\n",
      "print isinstance(x, str)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "True\n",
        "False\n"
       ]
      }
     ],
     "prompt_number": 110
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = [1,2,9,4]\n",
      "print x\n",
      "print 'result of sort', x.sort()  \n",
      "# sort returns none so that you are not confused and think \n",
      "# that a copy has been made.  Its all operating on the original object."
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[1, 2, 9, 4]\n",
        "result of sort None\n"
       ]
      }
     ],
     "prompt_number": 112
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# res = sort([1,2,3])   # 'old' functional thinking\n",
      "#x.sort().sort()  # would work if sort returned a reference to itself - ruby does"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 120
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "s = \"HELLO there\"\n",
      "print s.lower()\n",
      "print s.upper()\n",
      "s = \"THIS is another EXAMPLE\"\n",
      "print s.lower().upper()   # yes can do this because strings by value and return\n",
      "print s  # original string"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "hello there\n",
        "HELLO THERE\n",
        "THIS IS ANOTHER EXAMPLE\n",
        "THIS is another EXAMPLE\n"
       ]
      }
     ],
     "prompt_number": 118
    },
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "The concept of an Interface"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "This applies to a function 'signature' which is the name of the function and its parameters (the number of them and their parameter names).  This also applies to a class - implementing an 'interface'.  APIs are an interface to a system etc. "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def add_ver1(a,b):\n",
      "    return a+b\n",
      "\n",
      "def add_ver2(a=1,b=2):\n",
      "    result = a + b\n",
      "    return result\n",
      "\n",
      "# add_ver1(1,1)\n",
      "# add_ver2(b=100, 200)\n",
      "\n",
      "print add_ver1(1,2)\n",
      "print add_ver2(1,2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "3\n",
        "3\n"
       ]
      }
     ],
     "prompt_number": 122
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print {1:100,2:200}.keys()\n",
      "print {1:100,2:200}.values()\n",
      "for k,v in {1:100,2:200}.items():\n",
      "    print k,v"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[1, 2]\n",
        "[100, 200]\n",
        "1 100\n",
        "2 200\n"
       ]
      }
     ],
     "prompt_number": 126
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# loops through and calls our add function repeatedly\n",
      "def add_bunch_of_stuff():\n",
      "    results = []\n",
      "    for a,b in [(1,1), (1,2), (3,10)]:\n",
      "#         result = add_ver1(a,b)\n",
      "        result = add_ver2(a,b)  # swap in the other function cos its got the same 'interface'\n",
      "        results.append(result)\n",
      "    return results\n",
      "print add_bunch_of_stuff()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[2, 3, 13]\n"
       ]
      }
     ],
     "prompt_number": 130
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Variation 1 - assign the function 'name/reference' to a variable\n",
      "#add_func = add_ver2  # strategy pattern - set the function to call here\n",
      "add_func = add_ver1\n",
      "#from my_config import func   # could do this sort of thing to keep config external\n",
      "print type(add_ver2), type(func)\n",
      "print add_ver2 is func\n",
      "def add_bunch_of_stuff():\n",
      "    results = []\n",
      "    for a,b in [(1,1), (1,2), (3,10)]:\n",
      "        result = add_func(a,b)\n",
      "        results.append(result)\n",
      "    return results\n",
      "print add_bunch_of_stuff()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "<type 'function'> <type 'function'>\n",
        "False\n",
        "[2, 3, 13]\n"
       ]
      }
     ],
     "prompt_number": 135
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Or pass in the function you want to use !!\n",
      "def add_bunch_of_stuff(add_func):\n",
      "    results = []\n",
      "    for a,b in [(1,1), (1,2), (3,10)]:\n",
      "        result = add_func(a,b)\n",
      "        results.append(result)\n",
      "    return results\n",
      "print add_bunch_of_stuff(add_ver1)  # passing in the add function to the looping function"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[2, 3, 13]\n"
       ]
      }
     ],
     "prompt_number": 136
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Interfaces using Classes - an interface 'agreement'"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Java would do something like:\n",
      "# Interface Doer:\n",
      "#     void do();\n",
      "#     int do2();\n",
      "\n",
      "class InterfaceDoer(object):\n",
      "    # never want calls to reach the parent.\n",
      "    # only way to stop them coming here is for subclasses to override EVERY\n",
      "    # method listed here.  Which is the point of this trick: to ensure\n",
      "    # subclasses are fullfilling their 'agreement' to implement these 2 methods\n",
      "    def do(self): raise RuntimeError('Not implemented')\n",
      "    def do2(self):  raise RuntimeError('Not implemented')\n",
      "\n",
      "class DoV0(InterfaceDoer):\n",
      "    def do(self):  # this 'overrides' the parent version of do\n",
      "        pass\n",
      "\n",
      "o = DoV0()\n",
      "# o.do2()  # would fail"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 142
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class DoToday(InterfaceDoer):\n",
      "    def do(self):\n",
      "        return 'do today'\n",
      "    def do2(self):\n",
      "        return 'do2 today'\n",
      "\n",
      "class DoTomorrow(InterfaceDoer):\n",
      "    def do(self):\n",
      "        return 'do tomorrow'\n",
      "    def do2(self):\n",
      "        return 'do2 tomorrow'\n",
      "\n",
      "# strategy pattern - which lets you inject or swap out object implemtations\n",
      "# o = DoToday()\n",
      "o = DoTomorrow()\n",
      "\n",
      "# o could be an instance of either class - the following code doesn't know!\n",
      "# Benefit - the code below doesn't need to change when you improve the Do class\n",
      "print o.do()\n",
      "print o.do2()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "do tomorrow\n",
        "do2 tomorrow\n"
       ]
      }
     ],
     "prompt_number": 148
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def do_stuff(o):\n",
      "    print \"don't put off \" + o.do() + \" what you can do \" + o.do2()\n",
      "do_stuff(DoToday())\n",
      "\n",
      "# or\n",
      "obj = DoTomorrow()\n",
      "do_stuff(obj)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "don't put off do today what you can do do2 today\n",
        "don't put off do tomorrow what you can do do2 tomorrow\n"
       ]
      }
     ],
     "prompt_number": 153
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Example config\n",
      "\n",
      "try:\n",
      "    with open('interface_example/config.txt') as f:\n",
      "        contents = f.read()\n",
      "        if 'use_v1' in contents:\n",
      "            print 'using v1'\n",
      "            o = DoToday()\n",
      "        else:\n",
      "            # if not defined in config, just use latest version\n",
      "            print 'using v2'\n",
      "            o = DoTomorrow()\n",
      "except IOError as e:\n",
      "    # config file not defined so make a decision to use v2\n",
      "    print type(e), e, 'Using v1 by default because config file not there'\n",
      "    o = DoToday()\n",
      "    \n",
      "# finally use it\n",
      "do_stuff(o)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "using v2\n",
        "don't put off do tomorrow what you can do do2 tomorrow\n"
       ]
      }
     ],
     "prompt_number": 155
    },
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "Design Patterns"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "From Wikipedia http://en.wikipedia.org/wiki/Design_pattern_(computer_science)\n",
      "\n",
      "In software engineering, a design pattern is a general repeatable solution to a commonly occurring problem in software design. A design pattern is not a finished design that can be transformed directly into code. It is a description or template for how to solve a problem that can be used in many different situations. Object-oriented design patterns typically show relationships and interactions between classes or objects, without specifying the final application classes or objects that are involved. Algorithms are not thought of as design patterns, since they solve computational problems rather than design problems.\n",
      "Not all software patterns are design patterns. Design patterns deal specifically with problems at the level of software design. Other kinds of patterns, such as architectural patterns, describe problems and solutions that have alternative scopes."
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Strategy - Design Pattern"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class SortStrategy:  # interface\n",
      "    def sort(self): raise RuntimeError('n/a')\n",
      "        \n",
      "class SimpleSort(SortStrategy):\n",
      "    def sort(self, lzt):\n",
      "        lzt.sort()\n",
      "        \n",
      "class DummySort(SortStrategy):\n",
      "    def sort(self, lzt):\n",
      "        pass\n",
      "        \n",
      "class ZooAnimals:\n",
      "    def __init__(self, strategy_object):\n",
      "        self.animals = ['cat', 'mouse', 'anaconda', 'zebra', 'tortoise']\n",
      "\n",
      "#         self.strategy = SimpleSort()\n",
      "#         self.strategy = strategy_object\n",
      "        self.set_strategy(strategy_object)\n",
      "        \n",
      "    def report(self):\n",
      "        self.strategy.sort(self.animals)\n",
      "        print self.animals\n",
      "        \n",
      "    def set_strategy(self, strategy_obj):\n",
      "        if not hasattr(strategy_obj, 'sort'):\n",
      "            raise RuntimeError('your strategy_obj does not appear to implement sort, mate!')\n",
      "        self.strategy = strategy_obj\n",
      "\n",
      "# animals = ZooAnimals(SimpleSort())\n",
      "animals = ZooAnimals(DummySort())\n",
      "animals.report()\n",
      "animals.set_strategy(SimpleSort())\n",
      "animals.report()\n",
      "# animals.set_strategy(\"\")  # checking works!"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "['cat', 'mouse', 'anaconda', 'zebra', 'tortoise']\n",
        "['anaconda', 'cat', 'mouse', 'tortoise', 'zebra']\n"
       ]
      }
     ],
     "prompt_number": 160
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "1. pass in string and do an if else etc. to figure out which strategy object to use\n",
      "2. pass in the strategy object in the constructor when we build the zoo object (very much like passing in a function to call)\n",
      "\n",
      "Note: get the strategy object by importing from a particular module or get the object from a 'factory' that produces objects based on strings."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# two factories - both implemented as functions that return an object\n",
      "\n",
      "def get(mode):  # very simple factory\n",
      "    if mode =='simple': return SimpleSort()\n",
      "    elif mode == 'dummy': return DummySort()\n",
      "    else: raise RuntimeError('no such sort strategy mate!')\n",
      "\n",
      "def get2(mode):  # very simple factory\n",
      "    registry = {\n",
      "        'simple': SimpleSort,\n",
      "        'dummy': DummySort,\n",
      "    }\n",
      "    classname = registry[mode]  # get class \n",
      "    obj = classname()  # create an instance of the class\n",
      "    return obj\n",
      "\n",
      "sort_strategy_object = get2('simple')\n",
      "animals = ZooAnimals(sort_strategy_object)\n",
      "animals.report()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "['anaconda', 'cat', 'mouse', 'tortoise', 'zebra']\n"
       ]
      }
     ],
     "prompt_number": 161
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# factory implemented as a class\n",
      "\n",
      "class Factory:\n",
      "    def __init__(self):\n",
      "        self.registry = {\n",
      "            'simple': SimpleSort,\n",
      "        }\n",
      "        self.add_strategy('dummy', DummySort)\n",
      "        self.add_strategy('bubblesort', None)  # TODO\n",
      "        \n",
      "    def get(self, mode):\n",
      "        classname = self.registry[mode]  # get class \n",
      "        obj = classname()  # create an instance of the class\n",
      "        return obj  \n",
      "    \n",
      "    def add_strategy(self, classname, classref):\n",
      "        self.registry[classname] = classref\n",
      "\n",
      "f = Factory()\n",
      "\n",
      "class ReverseSortStrategy:\n",
      "    def sort(self, lzt): \n",
      "        return lzt.sort(reverse=True)\n",
      "f.add_strategy('reverse', ReverseSortStrategy)\n",
      "\n",
      "sort_strategy_object = f.get('dummy')\n",
      "animals = ZooAnimals(sort_strategy_object)\n",
      "animals.report()\n",
      "\n",
      "animals.strategy = f.get('simple')  # setting of strategy attribute directly!\n",
      "animals.report()\n",
      "\n",
      "animals.set_strategy(f.get('reverse')) # use a more official way\n",
      "animals.report()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "['cat', 'mouse', 'anaconda', 'zebra', 'tortoise']\n",
        "['anaconda', 'cat', 'mouse', 'tortoise', 'zebra']\n",
        "['zebra', 'tortoise', 'mouse', 'cat', 'anaconda']\n"
       ]
      }
     ],
     "prompt_number": 162
    },
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "Observer design pattern"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Interfaces (optional)\n",
      "\n",
      "# class SubjectInterface(object):\n",
      "#     # __init__ method creates a list called 'self.observers'\n",
      "#     def register_observer(self, observer): raise RuntimeError(\"not implemented\")\n",
      "#     def notify_all(self, event_str): raise RuntimeError(\"not implemented\")\n",
      "    \n",
      "# class ObserverInterface(object):\n",
      "#     def notify(self, event_str): raise RuntimeError(\"not implemented\")\n",
      "    \n",
      "# Implementation\n",
      "\n",
      "class Subject(object):\n",
      "    def __init__(self):\n",
      "        self.observers = []\n",
      "    def register_observer(self, observer):\n",
      "        if observer not in self.observers:  # or make the list a set\n",
      "            self.observers.append(observer)\n",
      "    def notify_all(self, event_str):\n",
      "        for observer in self.observers:\n",
      "            observer.notify(event_str)\n",
      "    \n",
      "class Observer(object):\n",
      "    def notify(self, event_str):\n",
      "        pass\n",
      "    \n",
      "#####\n",
      "class Machine(Subject):\n",
      "    def calibrate(self):\n",
      "        pass\n",
      "class Gui(Observer):\n",
      "    def notify(self, event_str):\n",
      "        print \"GUI %s got %s\" % (id(self), event_str)\n",
      "    \n",
      "machine = Machine()\n",
      "gui = Gui()\n",
      "machine.register_observer(gui)\n",
      "machine.notify_all('meltdown')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "GUI 4365182288 got meltdown\n"
       ]
      }
     ],
     "prompt_number": 169
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "gui2 = Gui()\n",
      "machine.register_observer(gui2)\n",
      "machine.notify_all('meltdown')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "GUI 4365182288 got meltdown\n",
        "GUI 4370742160 got meltdown\n"
       ]
      }
     ],
     "prompt_number": 170
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Adding a second observer class..."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class SecurityGuy(Observer):\n",
      "    def notify(self, event_str):\n",
      "        print \"Security guy got\", event_str\n",
      "        if event_str == 'meltdown':\n",
      "            print '    leaving work early....'\n",
      "    def take_a_walk(self):\n",
      "        pass\n",
      "guy = SecurityGuy()\n",
      "machine.register_observer(guy)   \n",
      "machine.notify_all('meltdown')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "GUI 4365182288 got meltdown\n",
        "GUI 4370742160 got meltdown\n",
        "Security guy got meltdown\n",
        "Security guy got meltdown\n",
        "    leaving work early....\n"
       ]
      }
     ],
     "prompt_number": 172
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "machine.notify_all('normal reading')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "GUI 4365182288 got normal reading\n",
        "GUI 4370742160 got normal reading\n",
        "Security guy got normal reading\n",
        "Security guy got normal reading\n"
       ]
      }
     ],
     "prompt_number": 173
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "**Coupling** between subject and observer is 'light and abstract'\n",
      " - all the subject knows about its observers is that they support the nofity method.  nothing else."
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Multiple inheritance - mix in the 'Observer' as needed"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      " - Multiple inheritance - mix in the 'Observer' as needed\n",
      " - Employee is both a person and an observer, notice the notify method refers to .name and also to the notification msg."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class Person:\n",
      "    def __init__(self, name, age):\n",
      "        self.name = name\n",
      "        self.age = age\n",
      "\n",
      "class Employee(Person, Observer):\n",
      "    def notify(self, msg):\n",
      "        print \"Employee %s has got a notification %s\" % (self.name, msg)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 176
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "e = Employee(\"Fred\", 25)\n",
      "machine.register_observer(e)   \n",
      "machine.notify_all('meltdown')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "GUI 4365182288 got meltdown\n",
        "GUI 4370742160 got meltdown\n",
        "Security guy got meltdown\n",
        "Security guy got meltdown\n",
        "    leaving work early....\n",
        "Employee Fred has got a notification meltdown\n"
       ]
      }
     ],
     "prompt_number": 177
    },
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "Adapter  - Design Pattern"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Also known as wrapper.\n",
      "\n",
      "The adapter pattern is useful in situations where an **already existing class provides some or all of the services you need but does not use the interface you need**.  However you can\u2019t change the class because it is being used by too much client code that you don\u2019t want to change.  Or you can\u2019t change the class because you don\u2019t have the source code."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Use object or class adapters to define your own 'nice' interface and then call the ugly interface behind the scenes.\n",
      "\n",
      "The 'adapter' implements the interface that suits your device (e.g. australian shaver plug).\n",
      "  - One adapter implements that aussie interface by talking to a UK wall (some not nice class)\n",
      "  - Another adapter implements that aussie interface by talking to a US wall (some other not nice class)\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class OldClass:\n",
      "    def sillyname(self):\n",
      "        return \"I am silly\"\n",
      "    def reall_silly_____name_gosh(self):\n",
      "        pass\n",
      "\n",
      "class NiceClass1:         # object adapter\n",
      "    def __init__(self, oldclass):\n",
      "        self.oldclass = oldclass # OldClass()\n",
      "    def nice_name(self):\n",
      "        result = self.oldclass.sillyname()\n",
      "        return result.replace('silly', 'nice')  # add a bit of fatness\n",
      "\n",
      "class NiceClass2(OldClass):         # class based adapter\n",
      "    def nice_name(self):\n",
      "        result = self.sillyname()\n",
      "        return result.replace('silly', 'nice')  # add a bit of fatness\n",
      "\n",
      "# Object adapter test code\n",
      "nice1 = NiceClass1(OldClass())  # object adapter version needs pointer to old \n",
      "                                # Notice the 'wrapping' syntax\n",
      "# nice1 = NiceClass1()\n",
      "print nice1.nice_name()\n",
      "assert nice1.nice_name() == 'I am nice'  # cheap 'unit test'\n",
      "\n",
      "# Class based adapter test code\n",
      "nice2 = NiceClass2()  # class based adapter needs no such pointer\n",
      "print nice2.nice_name()\n",
      "assert nice2.nice_name() == 'I am nice'"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "I am nice\n",
        "I am nice\n"
       ]
      }
     ],
     "prompt_number": 188
    },
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "Homework"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Write TWO adapters that implement the same interface\n",
      "  - push\n",
      "  - pop\n",
      "  - append\n",
      "  - prepend\n",
      "  - (others you may want to define)\n",
      "  \n",
      "The first adapter should implement the above methods based on a normal python list.\n",
      "The second adapter should implement the above methods based on a collections.deque (SEE https://docs.python.org/3/library/collections.html#collections.deque)\n",
      "\n",
      "You should write some code that uses one or the other adapter interchangeably, to produce the same effect."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": []
    }
   ],
   "metadata": {}
  }
 ]
}