Day2 - synchrotron 2015 training advanced - group 2.ipynb

{
 "metadata": {
  "name": "",
  "signature": "sha256:7c91ce7069e80bf3da69530d18c6dbe80ace091c3e255516d67f1599952f03fb"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "Day2 - synchrotron 2015 training advanced"
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Last week's 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": [
      "class PythonListAdapter(object):\n",
      "    def __init__(self):\n",
      "        self.__lzt = []   # normal python list - we use this for the 'back end' implementation\n",
      "    def push(self, value):\n",
      "        self.__lzt.append(value)\n",
      "        \n",
      "    # How to do length related things\n",
      "#     def get_length(self):\n",
      "#         return len(self.__lzt)\n",
      "    def __len__(self):   # more pythonic way\n",
      "        return len(self.__lzt)\n",
      "    \n",
      "    def pop(self):\n",
      "        return self.pop_ver1()  # a mini strategy patter !! :-)\n",
      "#         return self.pop_ver2()\n",
      "    \n",
      "    def prepend(self, value):\n",
      "        self.lzt.insert(0, value)\n",
      "\n",
      "    def pop_ver1(self):\n",
      "        last_item = self.__lzt[-1]  # get last item\n",
      "        del self.__lzt[-1]    # delete it\n",
      "        return last_item\n",
      "    \n",
      "    def pop_ver2(self):\n",
      "        return self.__lzt.pop()\n",
      "    \n",
      "    def to_list(self):\n",
      "        return self.__lzt\n",
      "    \n",
      "    def __str__(self):\n",
      "        s = super(PythonListAdapter, self).__str__()\n",
      "        return 'Python List Adapter: ' + str(self.__lzt) + ' ' + s\n",
      "        "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 39
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import collections\n",
      "\n",
      "class DequeuAdapter(object):\n",
      "    def __init__(self):\n",
      "        self.lzt = collections.deque()\n",
      "    def push(self, value):\n",
      "        self.lzt.append(value)\n",
      "        \n",
      "    def prepend(self, value):\n",
      "        self.lzt.appendleft(value)\n",
      "        \n",
      "    def __len__(self):   # more pythonic way\n",
      "        return len(self.lzt)\n",
      "    \n",
      "    def to_list(self):\n",
      "        normal_list = []\n",
      "        for v in self.lzt:\n",
      "            normal_list.append(v)\n",
      "        return normal_list\n",
      "    \n",
      "        # convert in an easier way\n",
      "        return list(self.lzt)\n",
      "\n",
      "    def __str__(self):\n",
      "        s = super(DequeuAdapter, self).__str__()\n",
      "        return \"%s DequeuAdapter contains: %s\" % (s, self.lzt) "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 40
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# TEST\n",
      "\n",
      "a1 = PythonListAdapter()\n",
      "a2 = DequeuAdapter()\n",
      "\n",
      "# Strategy ;-)\n",
      "a = a1\n",
      "# a = a2\n",
      "\n",
      "assert len(a) == 0\n",
      "a.push(100)\n",
      "assert len(a) == 1\n",
      "# print a.lzt  # bad idea because accessing internals which may not be true for other adapter\n",
      "print a\n",
      "print 'done'"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Python List Adapter: [100] <__main__.PythonListAdapter object at 0x104836e50>\n",
        "done\n"
       ]
      }
     ],
     "prompt_number": 41
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Should implement a clear() method on both adapters to begin a fresh\n",
      "\n",
      "a1.push(100)\n",
      "a1.push(200)\n",
      "\n",
      "a2.push(100)\n",
      "a2.push(200)\n",
      "\n",
      "print a1\n",
      "print a2\n",
      "print a1.to_list() == a2.to_list()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Python List Adapter: [100, 100, 200, 100, 200] <__main__.PythonListAdapter object at 0x104836e50>\n",
        "<__main__.DequeuAdapter object at 0x104836e10> DequeuAdapter contains: deque([100, 200, 100, 200])\n",
        "False\n"
       ]
      }
     ],
     "prompt_number": 43
    },
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "Advanced OO concepts"
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "class attributes"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class UberParent:\n",
      "    y = 1\n",
      "    \n",
      "    def __init__(self):\n",
      "        self.x = 2\n",
      "        \n",
      "#         print 'logging', self.y\n",
      "#         print 'logging', UberParent.y\n",
      "    "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 47
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "obj = UberParent()\n",
      "print obj.x\n",
      "print obj.y"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "2\n",
        "1\n"
       ]
      }
     ],
     "prompt_number": 48
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print UberParent.y"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1\n"
       ]
      }
     ],
     "prompt_number": 49
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "UberParent.y = 300"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 54
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print obj.y"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "300\n"
       ]
      }
     ],
     "prompt_number": 55
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "obj2 = UberParent()\n",
      "obj3 = UberParent()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 52
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print obj2.y"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "300\n"
       ]
      }
     ],
     "prompt_number": 56
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Class attributes are shared and common to all children instances\n",
      "class Uber:\n",
      "    path = '/home/fred'\n",
      "    \n",
      "u1 = Uber()\n",
      "u2 = Uber()\n",
      "assert u1.path == '/home/fred'\n",
      "assert u2.path == '/home/fred'\n",
      "\n",
      "# now we do the super powerful change... !\n",
      "Uber.path = '/home/var/mary'\n",
      "assert u1.path == '/home/var/mary'\n",
      "assert u2.path == '/home/var/mary'"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 57
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "slightly more confusing - when writing to a class attribute write to a class attribute **via the instance** you DON'T change the class attribute you instead create an attribute on that instance only"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "u1.path = '/tmp'  # what effect does this have - does this change the class attribute?"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 59
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print u1.path\n",
      "print u2.path   # oops!  this creates a new attribute and hides the class attribute"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "/tmp\n",
        "/home/var/mary\n"
       ]
      }
     ],
     "prompt_number": 63
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "THUS: if you want to change a class attribute, do so via the class name e.g.\n",
      "Uber.y"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Cool use - track the number of instantiations of your class  \n",
      "class Car:\n",
      "    num_rented = 0\n",
      "    car_objects_allocated = []\n",
      "    \n",
      "    def __init__(self):\n",
      "        Car.num_rented += 1  # MUST change via class name not self.\n",
      "        Car.car_objects_allocated.append(self)\n",
      "    \n",
      "    # Interesting thought - a mini-subject/observer pattern is possible\n",
      "    # between the Car class (the subject) and the instances (observers)\n",
      "    @classmethod\n",
      "    def notify_all(cls):  # get the class name passed in\n",
      "        for car in cls.car_objects_allocated: # could also just do Car.car_objects_allocated\n",
      "            car.notify()\n",
      "    def notify(self):\n",
      "        print 'I am car %s' % self\n",
      "        \n",
      "cars = [Car() for i in range(10)]  # list comprehension - please learn\n",
      "print cars\n",
      "print Car.num_rented   # can access class attribute from class itself\n",
      "print cars[0].num_rented # can access class attribute from an instance too\n",
      "print 'Num allocated', len(Car.car_objects_allocated)\n",
      "assert cars[0] in Car.car_objects_allocated\n",
      "\n",
      "# The only way we can get to the notify all method is via an instance\n",
      "#cars[0].notify_all()\n",
      "Car.notify_all()  # this is much better, and has the 'intent' we want"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[<__main__.Car instance at 0x1042a1b48>, <__main__.Car instance at 0x1042a1998>, <__main__.Car instance at 0x104816950>, <__main__.Car instance at 0x104816518>, <__main__.Car instance at 0x1048164d0>, <__main__.Car instance at 0x1048165a8>, <__main__.Car instance at 0x104816638>, <__main__.Car instance at 0x104816680>, <__main__.Car instance at 0x1048166c8>, <__main__.Car instance at 0x104816710>]\n",
        "10\n",
        "10\n",
        "Num allocated 10\n",
        "I am car <__main__.Car instance at 0x1042a1b48>\n",
        "I am car <__main__.Car instance at 0x1042a1998>\n",
        "I am car <__main__.Car instance at 0x104816950>\n",
        "I am car <__main__.Car instance at 0x104816518>\n",
        "I am car <__main__.Car instance at 0x1048164d0>\n",
        "I am car <__main__.Car instance at 0x1048165a8>\n",
        "I am car <__main__.Car instance at 0x104816638>\n",
        "I am car <__main__.Car instance at 0x104816680>\n",
        "I am car <__main__.Car instance at 0x1048166c8>\n",
        "I am car <__main__.Car instance at 0x104816710>\n"
       ]
      }
     ],
     "prompt_number": 75
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "class methods"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class MyClass:\n",
      "    @classmethod\n",
      "    def do(cls):\n",
      "        return \"hello\"\n",
      "MyClass.do()  # notice, we don't have to create an instance in order to \n",
      "              # call a class method"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 76,
       "text": [
        "'hello'"
       ]
      }
     ],
     "prompt_number": 76
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class MyClass2:\n",
      "    @staticmethod\n",
      "    def do():  # don't even need to declare the class reference \n",
      "        return \"hello, I'm just a raw method\"\n",
      "MyClass2.do()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 77,
       "text": [
        "\"hello, I'm just a raw method\""
       ]
      }
     ],
     "prompt_number": 77
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class A:\n",
      "    pass\n",
      "\n",
      "class B(A):\n",
      "    @classmethod\n",
      "    def do(cls):\n",
      "        return \"hello %s\" % cls\n",
      "B.do()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 78,
       "text": [
        "'hello __main__.B'"
       ]
      }
     ],
     "prompt_number": 78
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Use class methods when you need to know the class on which the method\n",
      "# was invoked.  You don't always know this, esp. in cases where functionality\n",
      "# is inherited.\n",
      "\n",
      "class A:\n",
      "    @classmethod\n",
      "    def do(cls):\n",
      "        return \"hello my methods are %s\" % dir(cls)\n",
      "\n",
      "class B(A):\n",
      "    def fred(self): pass\n",
      "    \n",
      "class C(A):\n",
      "    pass\n",
      "\n",
      "print B.do()\n",
      "print C.do()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "hello my methods are ['__doc__', '__module__', 'do', 'fred']\n",
        "hello my methods are ['__doc__', '__module__', 'do']\n"
       ]
      }
     ],
     "prompt_number": 85
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class Pizza(object):\n",
      "    @staticmethod\n",
      "    def mix_ingredients(x, y):\n",
      "        return x + y\n",
      "Pizza.mix_ingredients(1,2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 86,
       "text": [
        "3"
       ]
      }
     ],
     "prompt_number": 86
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# static and class methods are typically used to access class level info\n",
      "\n",
      "class Quark(object):\n",
      "    num_created = 0\n",
      "\n",
      "    @staticmethod\n",
      "    def report():\n",
      "        return Quark.num_created\n",
      "    \n",
      "    @classmethod\n",
      "    def report2(cls):   # cls is parameter which refers to the Quark class\n",
      "        return cls.num_created\n",
      "    \n",
      "    def __init__(self):\n",
      "        Quark.num_created += 1\n",
      "\n",
      "Quark(), Quark(), Quark()\n",
      "print Quark.num_created\n",
      "print Quark.report()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "3\n",
        "3\n"
       ]
      }
     ],
     "prompt_number": 87
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "More info on this stuff https://julien.danjou.info/blog/2013/guide-python-static-class-abstract-methods"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Techniques for namespacing so that you don't have free floating functions \n",
      "# at the global level.  Note: not such a problem in python because\n",
      "# python has good modules / import / namespacing controls already.\n",
      "\n",
      "def dosomething():\n",
      "    return \"hi\"\n",
      "dosomething()\n",
      "\n",
      "# convert into a static method of a class\n",
      "\n",
      "class Util:\n",
      "    @staticmethod\n",
      "    def dosomething():\n",
      "        return \"hi\"\n",
      "Util.dosomething()\n",
      "\n",
      "# or just use python modules e.g.\n",
      "from myutil import dosomething\n",
      "dosomething()\n",
      "\n",
      "# or maybe\n",
      "import myutil\n",
      "myutil.dosomething()\n",
      "\n",
      "# or even\n",
      "from myutil import dosomething as do\n",
      "do()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "Multiple Inheritance"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class A:\n",
      "    def do1(self):\n",
      "        print 'yey do1'\n",
      "        \n",
      "class B:\n",
      "    def do2(self):\n",
      "        print 'yey again do1'\n",
      "        \n",
      "class Combo(A,B):\n",
      "    pass\n",
      "\n",
      "c = Combo()  # how cool and lazy is this class !! :-)\n",
      "print dir(c)\n",
      "c.do1()\n",
      "c.do2()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "['__doc__', '__module__', 'do1', 'do2']\n",
        "yey do1\n",
        "yey again do1\n"
       ]
      }
     ],
     "prompt_number": 89
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# what if both classes have the same method\n",
      "\n",
      "class A:\n",
      "    def do1(self):\n",
      "        print 'yey do1'\n",
      "        \n",
      "class B:\n",
      "    def do1(self):\n",
      "        print 'ZZZZZZZZZZZZZZZZZZZZZZ'\n",
      "        \n",
      "    def do2(self):\n",
      "        print 'yey again do1'\n",
      "        \n",
      "# class Combo(A,B):  # first in best dressed\n",
      "class Combo(B,A):  # first in best dressed, again, proven!\n",
      "    pass\n",
      "\n",
      "c = Combo()  # how cool and lazy is this class !! :-)\n",
      "print dir(c)\n",
      "c.do1()\n",
      "c.do2()\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "['__doc__', '__module__', 'do1', 'do2']\n",
        "ZZZZZZZZZZZZZZZZZZZZZZ\n",
        "yey again do1\n"
       ]
      }
     ],
     "prompt_number": 91
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "sometimes multiple inheritance is called 'mix-ins'"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "**JAVA** musings - java has no multiple inheritance of implementation.  \n",
      "Only this idea of 'implementing multiple interfaces'\n",
      "\n",
      "    interface A {\n",
      "        void do1();\n",
      "    }\n",
      "    interface B {\n",
      "        void do2();\n",
      "    }\n",
      "    \n",
      "    class Combo(A, B) {   # this class promises \n",
      "                          #to implement these interfaces\n",
      "        void do1() {\n",
      "            print('yey do1');\n",
      "        }\n",
      "        void do2() {\n",
      "            print('yey again do2');\n",
      "        }\n",
      "    }"
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "A non multiple inheritance way of doing multiple inheritance"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# A non multiple inheritance way of doing multiple inheritance\n",
      "# which re-uses code  -> you don't have to reimplement every time\n",
      "\n",
      "# favouring 'composition' over 'inheritance'\n",
      "\n",
      "# Combo is a kind of a container (pointers to other helper classes) composition\n",
      "\n",
      "class A:\n",
      "    def do1(self):\n",
      "        print 'yey do1'        \n",
      "class B:\n",
      "    def do1(self):  # ... is having a do1() here an issue anymore?\n",
      "        print \"I'm the other do1 that spooked you out before\"\n",
      "    def do2(self):\n",
      "        print 'yey again do1'\n",
      "        \n",
      "class Combo():\n",
      "    def __init__(self):\n",
      "        self.a = A()\n",
      "        self.b = B()\n",
      "        \n",
      "    def do1(self):\n",
      "#         self.a.do1()\n",
      "        self.b.do1()  # its OUR choice which to call.  Simple.\n",
      "        \n",
      "    def do2(self):\n",
      "        self.b.do2()\n",
      "    \n",
      "c = Combo()\n",
      "c.do1()\n",
      "c.do2()\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "I'm the other do1 that spooked you out before\n",
        "yey again do1\n"
       ]
      }
     ],
     "prompt_number": 94
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Above technique is the best of both worlds - you get code re-use with the flexibility of 'composition' / flexibilty of wiring and being able to change that wiring at runtime if you wish.\n",
      "\n",
      "ALTHOUGH: multiple inheritance is cleaner and cool too - if you are ok with behaviour being locked in at cpompile time (who you inherit from is not changeable at runtime)."
     ]
    },
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "REVIEW - References to classes and functions"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class MyClass: pass\n",
      "def my_function(): return \"my function did something\"\n",
      "\n",
      "# Use these things - notice the ()\n",
      "o = MyClass()\n",
      "my_function()\n",
      "print o\n",
      "print my_function()\n",
      "\n",
      "# References to things - notice no brackets ()\n",
      "c = MyClass\n",
      "f = my_function\n",
      "print c, type(c)\n",
      "print f, type(f)\n",
      "\n",
      "o = c() # equivalent to MyClass()\n",
      "f()    # equivalent to my_function()\n",
      "print o\n",
      "print f()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "<__main__.MyClass instance at 0x104842c68>\n",
        "my function did something\n",
        "__main__.MyClass <type 'classobj'>\n",
        "<function my_function at 0x1042b9668> <type 'function'>\n",
        "<__main__.MyClass instance at 0x104842b48>\n",
        "my function did something\n"
       ]
      }
     ],
     "prompt_number": 101
    },
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "args and kwargs"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def myf(a, b, c, d=4):\n",
      "    print a,b,c,d\n",
      "\n",
      "myf(1,2,3,4)\n",
      "myf(1,2,3)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1 2 3 4\n",
        "1 2 3 4\n"
       ]
      }
     ],
     "prompt_number": 102
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def myf(*args):\n",
      "    print args\n",
      "myf(1,2,3,4)\n",
      "myf(5,6,7,8,9,10,11,12,\"whatever\", ['hi', 'there'])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(1, 2, 3, 4)\n",
        "(5, 6, 7, 8, 9, 10, 11, 12, 'whatever', ['hi', 'there'])\n"
       ]
      }
     ],
     "prompt_number": 105
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def myf(*args):\n",
      "    for arg in args:\n",
      "        print arg\n",
      "myf(5,6,7,8,9,10,11,12,\"whatever\", ['hi', 'there'])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "5\n",
        "6\n",
        "7\n",
        "8\n",
        "9\n",
        "10\n",
        "11\n",
        "12\n",
        "whatever\n",
        "['hi', 'there']\n"
       ]
      }
     ],
     "prompt_number": 106
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Daggy normal way\n",
      "def adder(list_of_numbers):\n",
      "    total = 0\n",
      "    for num in list_of_numbers:\n",
      "        total += num\n",
      "    return total\n",
      "print adder([1,5,20])\n",
      "\n",
      "# Cool way\n",
      "def adder(*args):\n",
      "    total = 0\n",
      "    for num in args:\n",
      "        total += num\n",
      "    return total\n",
      "print adder(1,5,20)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "26\n",
        "26\n"
       ]
      }
     ],
     "prompt_number": 108
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "existing_numbers = [1,5,20]\n",
      "adder(*existing_numbers)  # trick to convert list into args for a function"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 109,
       "text": [
        "26"
       ]
      }
     ],
     "prompt_number": 109
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# supply some basic parameters follwed by an arbitrary number of them\n",
      "def myf(a, *args):\n",
      "    print a\n",
      "    print args\n",
      "myf(1,2,3,4)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1\n",
        "(2, 3, 4)\n"
       ]
      }
     ],
     "prompt_number": 110
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "kwargs"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def myf(*args, **kwargs):\n",
      "    print 'args are', args\n",
      "    print 'kwargs are', kwargs\n",
      "myf()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "args are ()\n",
        "kwargs are {}\n"
       ]
      }
     ],
     "prompt_number": 111
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "myf(1,2,3,4,5)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "args are (1, 2, 3, 4, 5)\n",
        "kwargs are {}\n"
       ]
      }
     ],
     "prompt_number": 112
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "myf(a=1, fred='flinstone')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "args are ()\n",
        "kwargs are {'a': 1, 'fred': 'flinstone'}\n"
       ]
      }
     ],
     "prompt_number": 113
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "myf(1,2,mary=300)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "args are (1, 2)\n",
        "kwargs are {'mary': 300}\n"
       ]
      }
     ],
     "prompt_number": 114
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# what happens if we have a 'weird combo of techniques' function\n",
      "def normal(a,b,d=5,e=66, *args, **kwargs):\n",
      "    print a, b\n",
      "    print args\n",
      "    print d, e\n",
      "    print kwargs\n",
      "normal(1,2,3,4,5,6,fred=100, mary=200)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1 2\n",
        "(5, 6)\n",
        "3 4\n",
        "{'mary': 200, 'fred': 100}\n"
       ]
      }
     ],
     "prompt_number": 123
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def myf(*args, **kwargs):\n",
      "    if 'runreport' in kwargs and kwargs['runreport']:\n",
      "        print \"I'm running the report\"\n",
      "# or...\n",
      "def myf(*args, **kwargs):\n",
      "    if kwargs.get('runreport', False):  # look up and get default value if it isn't there\n",
      "        print \"I'm running the report\"\n",
      "    \n",
      "myf(runreport=True)  # do something in this case\n",
      "myf(holiday=True)  # do nothing in this case\n",
      "myf(runreport=False)  # do nothing in this case\n",
      "\n",
      "myf(holiday=True, runreport=True)  # do something in this case"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "I'm running the report\n",
        "I'm running the report\n"
       ]
      }
     ],
     "prompt_number": 129
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Existing sum function in python that takes a list of integers\n",
      "# sum(1,2,3,4)  # fails cos sim expects a list\n",
      "sum([1,2,3,4]) # must do this\n",
      "\n",
      "def mysum(*args):\n",
      "    return sum(args)\n",
      "\n",
      "print mysum(1,2,3,4,5,6)  # made a cooler version of sum that takes arbitrary numbers\n",
      "                        # of paramters"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "21\n"
       ]
      }
     ],
     "prompt_number": 136
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def f1(*args):\n",
      "    print 'this f1 actually does the work', args\n",
      "    \n",
      "def f2(*args):  # Like a wrapper\n",
      "    f1(*args)\n",
      "    \n",
      "f2(1,2,3,4)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "this f1 actually does the work (1, 2, 3, 4)\n"
       ]
      }
     ],
     "prompt_number": 140
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def f1(*args):\n",
      "    print 'this f1 actually does the work', args\n",
      "    \n",
      "def f2(*args):  # A wrapper which 'adds a bit of logging functionality'\n",
      "    print 'I am calling f1 now, the params are:', args\n",
      "    result = f1(*args)\n",
      "    print 'I am returning from my long journey calling f1 and the result is', result\n",
      "    \n",
      "f2(1,2,3,4)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "I am calling f1 now, the params are: (1, 2, 3, 4)\n",
        "this f1 actually does the work (1, 2, 3, 4)\n",
        "I am returning from my long journey calling f1 and the result is None\n"
       ]
      }
     ],
     "prompt_number": 142
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def f(a,b,c):\n",
      "    print 'a=%s, b=%s, c=%s' % (a, b, c)\n",
      "    \n",
      "# All purpose wrapper, optionally add logging or whatever\n",
      "def wrapper(*args, **kwargs):\n",
      "    f(*args, **kwargs)\n",
      "    \n",
      "wrapper(1, b=100, c='fred')\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "a=1, b=100, c=fred\n"
       ]
      }
     ],
     "prompt_number": 143
    },
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "Closures"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "z = 2000  # outer outer scope\n",
      "def func():\n",
      "    x = 1  # outer scope\n",
      "    def util(a,b):  # private function inside a function - you can't call it from global scope\n",
      "        return a+b+x+z  # a and b are current scope\n",
      "    result = util(1,2) + util(5,3)\n",
      "    return result\n",
      "print func()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "4013\n"
       ]
      }
     ],
     "prompt_number": 144
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "a function has access to its current scope, and all scopes up to global scope (turtles all the way up/down perhaps)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def func_factory():\n",
      "    def inner():\n",
      "        return 1\n",
      "    return inner\n",
      "\n",
      "f = func_factory()\n",
      "print f()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1\n"
       ]
      }
     ],
     "prompt_number": 145
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def make_adder(amount):\n",
      "    def adder(n):\n",
      "        return n + amount  # 'amount' is remembered for all time as the value to add\n",
      "    return adder  # return function reference\n",
      "\n",
      "add1 = make_adder(1)\n",
      "add20 = make_adder(20)\n",
      "\n",
      "# Use it\n",
      "print add1(10)\n",
      "print add20(10)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "11\n",
        "30\n"
       ]
      }
     ],
     "prompt_number": 147
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "lambdas"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def add(a,b):\n",
      "    return a+b\n",
      "\n",
      "add = lambda a, b : a + b\n",
      "\n",
      "print add(10, 50)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "60\n"
       ]
      }
     ],
     "prompt_number": 148
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def call_f_and_add_one_hundred(f):\n",
      "    return f(1,2) + 100\n",
      "\n",
      "# passing a function to a function - use a lambda to define an\n",
      "# anonymous function \n",
      "print call_f_and_add_one_hundred(lambda a, b : a + b)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "103\n"
       ]
      }
     ],
     "prompt_number": 149
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Use lambdas to pass your sorting criteria in a short pithy way\n",
      "# and avoid having to declare an explicit function\n",
      "student_tuples = [\n",
      "        ('john', 'A', 15),\n",
      "        ('jane', 'B', 20),\n",
      "        ('dave', 'B', 10),\n",
      "]\n",
      "student_tuples.sort()\n",
      "print student_tuples"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[('dave', 'B', 10), ('jane', 'B', 20), ('john', 'A', 15)]\n"
       ]
      }
     ],
     "prompt_number": 153
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "student_tuples.sort(key=lambda student: student[2])\n",
      "print student_tuples"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[('dave', 'B', 10), ('john', 'A', 15), ('jane', 'B', 20)]\n"
       ]
      }
     ],
     "prompt_number": 154
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def which_key_func(student):\n",
      "    return student[2]\n",
      "student_tuples.sort(key=which_key_func)\n",
      "print student_tuples"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[('dave', 'B', 10), ('john', 'A', 15), ('jane', 'B', 20)]\n"
       ]
      }
     ],
     "prompt_number": 156
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "lambdas and closures"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def make_adder(amount):  # closure is a bit cleaner\n",
      "    return lambda n : n + amount\n",
      "\n",
      "add1 = make_adder(1)\n",
      "add20 = make_adder(20)\n",
      "\n",
      "# Use it\n",
      "print add1(1)\n",
      "print add20(1)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "2\n",
        "21\n"
       ]
      }
     ],
     "prompt_number": 157
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The next lesson here shows that closures only lock in parameters and local variables, not\n",
      "variables in global scope. "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "amount = 1\n",
      "# add1 = lambda n : n + amount   # just a normal function so when 'amount' \n",
      "                # changes, the function will reflect that.\n",
      "                # We don't want this.  The whole point of a closure\n",
      "                # is to 'lock in' the value of the scope at the time\n",
      "                # the function was created.\n",
      "def make_adder():\n",
      "    print 'amount is', amount\n",
      "    lock_me = amount\n",
      "    return lambda n : n + lock_me\n",
      "\n",
      "add1 = make_adder()\n",
      "\n",
      "amount = 20\n",
      "# add20 = lambda n : lambda n : n + amount\n",
      "add20 = make_adder()\n",
      "\n",
      "# Use it\n",
      "print add1(1)\n",
      "print add20(1)\n",
      "\n",
      "amount = 30\n",
      "add30 = lambda n, amount=amount : n + amount\n",
      "print add30(1)\n",
      "\n",
      "# The lesson here is that closures only lock in parameters and local variables, not\n",
      "# variables in global scope. "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "amount is 1\n",
        "amount is 20\n",
        "2\n",
        "21\n",
        "31\n"
       ]
      }
     ],
     "prompt_number": 191
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "lambdas can also be used as **anonymous functions** especially in parameters\n",
      "\n",
      "closures in general can be used to pass functions around for lazy execution\n",
      "\n",
      "and they also can save you passing lots of parameters to communicate info - just pass a function which is 'closed' over those parameters into the place where you need to execute."
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "more practical use of closures - as customised functions"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print int(\"20\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "20\n"
       ]
      }
     ],
     "prompt_number": 166
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print int(\"10110\", base=2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "22\n"
       ]
      }
     ],
     "prompt_number": 168
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Straight forward way of solving the problems\n",
      "def decode_base2(s):\n",
      "    return int(s, base=2)\n",
      "    \n",
      "print decode_base2(\"101\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "5\n"
       ]
      }
     ],
     "prompt_number": 172
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Closure based approach that the guy in the cubilcle down the hall uses\n",
      "def make_custom_int_decoder(b):\n",
      "    return lambda n : int(n, base=b)\n",
      "decode_base2 = make_custom_int_decoder(2)\n",
      "print decode_base2(\"101\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "5\n"
       ]
      }
     ],
     "prompt_number": 173
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# justification for use of above close\n",
      "decode_base16 = make_custom_int_decoder(16)\n",
      "print decode_base16(\"FFFF\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "65535\n"
       ]
      }
     ],
     "prompt_number": 174
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Closures are a way of gereating custom functions for your needs, with the paramters 'set' to some fixed values that you gave when creating the closure.\n",
      "\n",
      "Closures are like 'instances of classes' with state 'locked in'.  \n",
      "\n",
      "But closures are just single shot functions - whereas objects are more powerful and can offer multiple methods (not just one) and you can acces their state with attributes etc."
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "partials"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "partials are just easier ways of creating closures"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import functools\n",
      "decode_base16 = functools.partial(int, base=16)  # first param is the function you are 'customising'\n",
      "print decode_base16(\"FF00\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "65280\n"
       ]
      }
     ],
     "prompt_number": 176
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def adder(a,b):\n",
      "    return a+b\n",
      "add10 = functools.partial(adder, b=10)\n",
      "add20 = functools.partial(adder, b=20)\n",
      "print add10(1)\n",
      "print add20(1)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "11\n",
        "21\n"
       ]
      }
     ],
     "prompt_number": 178
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "http://tech.pro/tutorial/1520/partial-function-application-in-python\n",
      "\n",
      "The usage of the partial function is as intuitive as the example suggests: Simply pass a function and then a number of arguments. The partial function will then return a new function. This new function is like the old function with some of its parameter fixed to the arguments which were passed. "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# possibly useful example\n",
      "import datetime\n",
      "def log_template(level, message):\n",
      "    print(\"{} {}: {}\".format(datetime.datetime.now(), level, message))\n",
      "    \n",
      "log_template('info', 'this is some messgae I want to sent')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "2015-05-18 16:01:37.427765 info: this is some messgae I want to sent\n"
       ]
      }
     ],
     "prompt_number": 180
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from functools import partial\n",
      "log_info = partial(log_template, \"info\")  # be careful re order of params\n",
      "log_warning = partial(log_template, \"warning\")\n",
      "log_error = partial(log_template, \"error\")\n",
      "\n",
      "log_info(\"some message\")\n",
      "log_warning(\"some message\")\n",
      "log_error(\"some message\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "2015-05-18 16:19:06.281715 info: some message\n",
        "2015-05-18 16:19:06.281810 warning: some message\n",
        "2015-05-18 16:19:06.281883 error: some message\n"
       ]
      }
     ],
     "prompt_number": 186
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# traditional implementation\n",
      "\n",
      "def log_info(message):\n",
      "    return log_template(\"info\", message)\n",
      "def log_warning(message):\n",
      "    return log_template(\"warning\", message)\n",
      "def log_error(message):\n",
      "    return log_template(\"error\", message)\n",
      "\n",
      "log_info(\"some message\")\n",
      "log_warning(\"some message\")\n",
      "log_error(\"some message\")"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "http://www.pydanny.com/python-partials-are-fun.html"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Andy's Summary:\n",
      "\n",
      "Basically, a partial takes the name of the function followed by its parameters, and returns a callable - which is that same function bound to the parameters you supplied.\n",
      "\n",
      "Benefit: This reduces the number of parameters you need to supply to the new 'modified/cloned' function, meaning that you can hide info away (which would otherwise be supplied via those parameters) from other parts of your software system. \n",
      "\n",
      "Thus you can pass the newly manufactured callable function around into other layers of your software system and those bits of code only have to supply a reduced number of parameters which are relevant to them, in order to use the function - the other parameters have 'already been filled in'.  This reduces coupling - one layer can use a function from another layer without needing to know about the forbidden knowledge of certain parameters and the coupling that would otherwise entail.\n",
      "\n",
      "You can even supply **all** parameters when creating a partial, thus creating a callable that takes no parameters at all, which is useful in some situations e.g. a 'command pattern' like .execute() or other framework uses.\n",
      "\n",
      "P.S. Yes you can achieve the same effect via closures where you create a function which returns the new (bound or partially bound to params) function.  But using partial avoids that messiness/need for infratructure/mechanism."
     ]
    },
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "Decorators"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "A decorator is just a callable that takes a function as an argument and returns a replacement function."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def report(func):\n",
      "    print 'Just entering a %s function' % func  # happens at compile time\n",
      "    return func\n",
      "\n",
      "@report\n",
      "def add(a,b):\n",
      "    return a+b\n",
      "\n",
      "print add(1,2)\n",
      "print add(20,40)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Just entering a <function add at 0x104827398> function\n",
        "3\n",
        "60\n"
       ]
      }
     ],
     "prompt_number": 190
    },
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "Homework"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Create a decorator which logs the parameters being called and logs the result returned.  This could be applied to **any** function, thus could be a really useful decorator!"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def trace(func_we_are_decorating):\n",
      "\n",
      "    def wrapper(*args, **kwargs):\n",
      "        # log the parameters\n",
      "        # calls the func_we_are_decorating\n",
      "        # log the result\n",
      "        pass\n",
      "    \n",
      "    return wrapper\n",
      "\n",
      "@trace\n",
      "def add(a,b):\n",
      "    return a+b\n",
      "\n",
      "print add(1,2)\n",
      "print add(20,40)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    }
   ],
   "metadata": {}
  }
 ]
}