12_Optimising_1.ipynb

{
 "metadata": {
  "celltoolbar": "Slideshow",
  "name": "",
  "signature": "sha256:525a4cf154d41cebce6ea7d3ebd0fc0eda6a11eedc9ff51a4d6e107016d6a4c6"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "Optimisation\n",
      "============"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "Don't worry about it!\n",
      "---------------------\n",
      "\n",
      "**Seriously**\n",
      "\n",
      "+ Don't think about trying to optimise your code until it works and speed becomes a problem. \n",
      "+ By attempting to optimise your code, it will become \n",
      "    + less readable, \n",
      "    + more error prone, \n",
      "    + less transferable and\n",
      "    + more difficult to maintain.\n",
      "\n",
      "If you are at the point where you need to speed up execution:\n",
      "\n",
      " * Ensure you have a complete test suite that you code passes. *Don't think about optimising a function with no tests!*\n",
      " * Ensure your code is properly version controlled so that when you break it you can revert everything."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "Profilers\n",
      "---------\n",
      "\n",
      "To stop you spending weeks of your life optimising a line of code that only gets executed once you need to _profile_ your code before you do anything. This tells you how much time is spent doing different things in the code.\n",
      "\n",
      "The standard Profiler in python is `cProfile`, which is a module in the standard library. It hooks in to your code when you run it and times how long each call takes. Other profilers might use statistical sampling of running code, each has their advantages but this is the standard and good enough for most people.\n",
      "\n",
      "To use it, you can just run it as a module with your script as an argument. **Use a representative sample of data for your code** otherwise the results could be misleading. The output is very similar to gprof, which is a profiling tool that comes with gcc."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "    % python -m cProfile -s time profile_thing.py\n",
      "             880052 function calls in 1.601 seconds\n",
      "\n",
      "       Ordered by: internal time\n",
      "\n",
      "       ncalls  tottime  percall  cumtime  percall filename:lineno(function)\n",
      "        40000    0.423    0.000    0.423    0.000 {method 'format' of 'str' objects}\n",
      "        80000    0.342    0.000    0.394    0.000 profile_thing.py:22(distance)\n",
      "            1    0.230    0.230    1.601    1.601 profile_thing.py:3(<module>)\n",
      "       120000    0.096    0.000    0.112    0.000 random.py:356(uniform)\n",
      "            1    0.089    0.089    0.126    0.126 random.py:40(<module>)\n",
      "        40000    0.088    0.000    0.149    0.000 profile_thing.py:13(move)\n",
      "        40000    0.074    0.000    0.629    0.000 profile_thing.py:47(what_am_i)\n",
      "        40000    0.071    0.000    0.083    0.000 profile_thing.py:41(__init__)\n",
      "        80001    0.041    0.000    0.041    0.000 {range}\n",
      "            1    0.037    0.037    0.037    0.037 hashlib.py:55(<module>)\n",
      "        40000    0.036    0.000    0.036    0.000 {zip}\n",
      "       120000    0.025    0.000    0.025    0.000 {operator.add}\n",
      "       120000    0.015    0.000    0.015    0.000 {method 'random' of '_random.Random' objects}\n",
      "        40000    0.012    0.000    0.012    0.000 profile_thing.py:8(__init__)\n",
      "        80000    0.012    0.000    0.012    0.000 {len}\n",
      "        40000    0.009    0.000    0.009    0.000 profile_thing.py:18(locate)\n",
      "            1    0.000    0.000    0.000    0.000 {posix.urandom}\n",
      "            1    0.000    0.000    0.000    0.000 random.py:100(seed)\n",
      "            1    0.000    0.000    0.000    0.000 {function seed at 0x7f40f88afde8}\n"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The columns to look at are:\n",
      "\n",
      " * `tottime` is the total length of time that was required for that procedure. Assuming that you have used a sufficiently representative sample set, this is where you should look for what is the most expensive part of your code.\n",
      " * `percall` is the time for one call of a procedure to complete. Large numbers can indicate possible easy targets for optimisation (but only if they make up a large proportion of the total time)\n",
      " * `ncalls` is how many times that procedure is invoked; look for very high numbers for procedures that should not be called very often as this can indicate where things are in loops that shouldn't be.\n",
      "\n",
      "This can help to find places to do **high level optimisations**. Does the flow of your code make sense? Can you restructure the code to do fewer of the expensive function calls but get the same result?"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "Profiling bits of code\n",
      "----------------------\n",
      "\n",
      "Now that we know where the **hotspots** in our code are, we can focus on those and how to optimise them. We don't want to have to run the whole code every time so the best idea is to use timers to isolate the most expensive pieces of code."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import timeit\n",
      "\n",
      "timeit.timeit('map(abs, range(-100, 100))', number=10000)"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 1,
       "text": [
        "0.16485595703125"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "timeit.repeat('[abs(x) for x in range(-100, 100)]', number=10000)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 2,
       "text": [
        "[0.31686997413635254, 0.31282997131347656, 0.31310582160949707]"
       ]
      }
     ],
     "prompt_number": 2
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "`timeit` will run the code in the string the set number of times and return the time it takes to complete all of them. To do this well you need to find a number of times that will give you a representative sample and repeat your timing a few times.\n",
      "\n",
      "This is an example of where a `map` will give a slight boost in performance compared to a list comprehension, but bear in mind that a list comprehensions also allow you to add conditions (like a filter) and read more like natural language."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "Profiling with setup\n",
      "--------------------\n",
      "\n",
      "The setup argument gives us the chance to execute some statements once before the timing starts and bring things into the environment that is executing the code, which is otherwise an empty interpreter."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# A semicolon separates statements in the code\n",
      "timeit.repeat('my_int in my_list',\n",
      "              setup='my_list = range(30); my_int = 3')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "timeit.repeat('my_list.count(my_int) > 0',\n",
      "              setup='my_list = range(30); my_int = 3')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 4,
       "text": [
        "[0.9999499320983887, 0.9726009368896484, 0.9709019660949707]"
       ]
      }
     ],
     "prompt_number": 4
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Triple quoted strings allow us to span multiple lines\n",
      "setup_code = \"\"\"\n",
      "my_list = range(30)\n",
      "my_int = 30\n",
      "\"\"\"\n",
      "\n",
      "timeit.repeat('my_int in my_list', setup=setup_code)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 5,
       "text": [
        "[0.8838939666748047, 0.8576200008392334, 0.8513679504394531]"
       ]
      }
     ],
     "prompt_number": 5
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Note how `in` outperforms where we test if there is a non zero count. But be careful, the data that you use can have a huge effect on the outcome, the `in` operator is has a **shortcut** condition so will return as soon as it finds what it is looking for. You must test with a representative dataset as a **worst case scenario** for this sample offers not much improvement."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "Profiling with IPython\n",
      "----------------------\n",
      "\n",
      "In our IPython we have *magic* expressions that we can use interactively so we don't have to fuss with setups and finding appropriate repeat numbers:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# we have access to the complete local environment\n",
      "item = 12\n",
      "# the % tells IPython to invoke magic and anything on\n",
      "# the line is profiled\n",
      "%timeit item"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "10000000 loops, best of 3: 39.2 ns per loop\n"
       ]
      }
     ],
     "prompt_number": 6
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# list lookup\n",
      "data_store = [12]\n",
      "%timeit data_store[0]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "10000000 loops, best of 3: 62.8 ns per loop\n"
       ]
      }
     ],
     "prompt_number": 7
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# dict lookup\n",
      "data_store = {'item': 12}\n",
      "%timeit data_store['item']"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "10000000 loops, best of 3: 67.5 ns per loop\n"
       ]
      }
     ],
     "prompt_number": 8
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# instance attributes\n",
      "class DataStore:\n",
      "    pass\n",
      "\n",
      "data_store = DataStore()\n",
      "data_store.item = 12\n",
      "\n",
      "%timeit data_store.item"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "10000000 loops, best of 3: 72.9 ns per loop\n"
       ]
      }
     ],
     "prompt_number": 9
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# class attributes\n",
      "class DataStore:\n",
      "    item = 12\n",
      "\n",
      "data_store = DataStore()\n",
      "\n",
      "%timeit data_store.item"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "10000000 loops, best of 3: 90.4 ns per loop\n"
       ]
      }
     ],
     "prompt_number": 10
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# namedtuple\n",
      "from collections import namedtuple\n",
      "\n",
      "DataStore = namedtuple('DataStore', ['item'])\n",
      "data_store = DataStore(item=12)\n",
      "\n",
      "%timeit data_store.item"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1000000 loops, best of 3: 199 ns per loop\n"
       ]
      }
     ],
     "prompt_number": 11
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# property attribute\n",
      "class DataStore:\n",
      "    def __init__(self):\n",
      "        self._item = 12\n",
      "    @property\n",
      "    def item(self):\n",
      "        return self._item\n",
      "\n",
      "data_store = DataStore()\n",
      "\n",
      "%timeit data_store.item"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1000000 loops, best of 3: 341 ns per loop\n"
       ]
      }
     ],
     "prompt_number": 12
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Using the `%timeit` magic automatically does the repeats and works out the best number of loops so that the timing lasts for a few seconds total time.\n",
      "\n",
      "Rememeber, *only ever compare timings that have been measured on the same machine with the same execution conditions*.\n",
      "\n",
      "In this example, we have explored some of the ways to store data. Lightweight data structures, like lists and dictionaries, give fast access to their contents, but do not have a very friendly interface. Some object attribute access, like instance attributes, can be almost as cheap, but more complex data structures, like the function call associated with an unnecessary `property`, can significantly slow things down."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "Sequences\n",
      "---------"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import random\n",
      "\n",
      "# generator expressions in round brackets\n",
      "%timeit (random.random() for _random in xrange(1000))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1000000 loops, best of 3: 1.01 \u00b5s per loop\n"
       ]
      }
     ],
     "prompt_number": 13
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#make the list immediately\n",
      "%timeit [random.random() for _random in range(1000)]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "10000 loops, best of 3: 165 \u00b5s per loop\n"
       ]
      }
     ],
     "prompt_number": 14
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%timeit\n",
      "#construct the list bit-by-bit\n",
      "random_list = []\n",
      "for _random in range(1000):\n",
      "    random_list.append(random.random())"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1000 loops, best of 3: 266 \u00b5s per loop\n"
       ]
      }
     ],
     "prompt_number": 15
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "You can use multiline statements with `%%timeit`.\n",
      "\n",
      "Here we demonstrate the methods to create a sequence. The generator expression is very fast as it is _lazy_ doesn't actually do anything until you .next() it. The list comprehension is faster as it avoids the cost of setting up a `for` loop."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "Ordering for data\n",
      "-----------------"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# We need an evenly distributed set of random numbers \n",
      "# between 0 and 1 which will be the same for all tests\n",
      "numbers = [random.random() for _random in range(1000)]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 16
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%timeit\n",
      "# `pass` statements mean that we are mostly measuring the \n",
      "# performance of the loop/if/else\n",
      "for number in numbers:\n",
      "    if number == 0:\n",
      "        pass\n",
      "    elif number > 0.1:\n",
      "        pass\n",
      "    else:\n",
      "        pass"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1000 loops, best of 3: 202 \u00b5s per loop\n"
       ]
      }
     ],
     "prompt_number": 17
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%timeit\n",
      "for number in numbers:\n",
      "    if number > 0.1:\n",
      "        pass\n",
      "    elif number == 0:\n",
      "        pass\n",
      "    else:\n",
      "        pass"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "10000 loops, best of 3: 97.2 \u00b5s per loop\n"
       ]
      }
     ],
     "prompt_number": 18
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "Notice how, by structuring our tests so the most common cases come first we can speed up our code significantly. This type of **short circuit** can help to speed up other places in code too. For example `or` and `and` testing never evaluate and test the second argument and just assume that it will evaluate to the correct result. The fastest way to execute code is to **execute as little as possible**."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def and_like(arg1, arg2):\n",
      "    \"\"\"An and test with a short circuit. Similar to how python does it.\"\"\"\n",
      "    if arg1:\n",
      "        return arg2  # no truth test is done on this\n",
      "    else:\n",
      "        return False"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 19
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "EAFP\n",
      "----\n",
      "\n",
      "Depending on the situation, our philosophy on dealing with errors can have impacts on the speed."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class Thing(object):\n",
      "    \"\"\"Makeshift object with a trivial getter to add inefficiency.\"\"\"\n",
      "    def __init__(self, number):\n",
      "        self._number = number\n",
      "    @property\n",
      "    def number(self):\n",
      "        return self._number\n",
      "\n",
      "few_zeros = [Thing(0) for _thing in range(3)] + [Thing(1) for _thing in range(1000)]\n",
      "many_zeros = [Thing(0) for _thing in range(1000)] + [Thing(1) for _thing in range(3)]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 20
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%timeit\n",
      "for thing in few_zeros:\n",
      "    try:\n",
      "        17/thing.number\n",
      "    except ZeroDivisionError:\n",
      "        pass"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1000 loops, best of 3: 400 \u00b5s per loop\n"
       ]
      }
     ],
     "prompt_number": 21
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%timeit\n",
      "for thing in few_zeros:\n",
      "    if thing.number == 0:\n",
      "        pass\n",
      "    else:\n",
      "        17/thing.number"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1000 loops, best of 3: 696 \u00b5s per loop\n"
       ]
      }
     ],
     "prompt_number": 22
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%timeit\n",
      "for thing in many_zeros:\n",
      "    try:\n",
      "        17/thing.number\n",
      "    except ZeroDivisionError:\n",
      "        pass"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1000 loops, best of 3: 1.84 ms per loop\n"
       ]
      }
     ],
     "prompt_number": 23
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%timeit\n",
      "for thing in many_zeros:\n",
      "    if thing.number == 0:\n",
      "        pass\n",
      "    else:\n",
      "        17/thing.number"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1000 loops, best of 3: 346 \u00b5s per loop\n"
       ]
      }
     ],
     "prompt_number": 24
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The prefernce of `try` and `except` to an `if` can depend strongly on the data you need to process and the cost of the testing condition (in this example I needed to slow down the test condition). Here the `try` is cheaper than the `if`. However, in the case where the exception is raised frequently it becomes very expensive. So try-except fits best where the exception is the rare case."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "Writing files\n",
      "-------------"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import tempfile\n",
      "\n",
      "file_object = tempfile.TemporaryFile()  # asume we are unbuffered here"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 25
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%timeit\n",
      "for i in range(5000):\n",
      "    file_object.write(\"%s\\n\" % i)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "100 loops, best of 3: 4.53 ms per loop\n"
       ]
      }
     ],
     "prompt_number": 26
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%timeit\n",
      "# buffer in a list\n",
      "file_lines = []\n",
      "for i in range(5000):\n",
      "    file_lines.append(\"%s\\n\" % i)\n",
      "file_object.writelines(file_lines)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "100 loops, best of 3: 2.14 ms per loop\n"
       ]
      }
     ],
     "prompt_number": 27
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Often, file input and output can be a huge bottleneck, since disks are orders of magnitude slower than RAM or CPU, so they will slow down your code however fast your CPU is. You can be smart about how your code handles files to minimise the impact. \n",
      "\n",
      "One of the biggest issues can be having many small reads or writes.\n",
      "\n",
      "Always try to **buffer** your output in some way this reduces the calls to file writes. The `write` method tends to not buffer on linux but does on windows, but it is probably best to implement a buffer of some kind that periodically writesto disk. You will have to do some testing to see what is the best perfomance vs memory tradeoff."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "Reading files\n",
      "-------------"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Reading can also be slow if not done well. The `read()` and `readines()` methods in Python read the complete file and put it in memory, this is the fastest way to interact with the whole file and especailly useful if you need to access several parts of a file randomly. Calling `readline()` repeatedly on your file will be very slow as it just reads one line at a time. Using the idiomatic construct `for line in file` will do some internal buffering so that it will read chunks of lines that it can iterate over much more quickly."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%timeit\n",
      "# smart buffered iteration\n",
      "fileobj = open('12_Optimising_1.ipynb')\n",
      "for line in fileobj:\n",
      "    pass"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "10000 loops, best of 3: 130 \u00b5s per loop\n"
       ]
      }
     ],
     "prompt_number": 28
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%timeit\n",
      "# whole file buffering\n",
      "filelines = open('12_Optimising_1.ipynb').readlines()\n",
      "for line in filelines:\n",
      "    pass"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "10000 loops, best of 3: 157 \u00b5s per loop\n"
       ]
      }
     ],
     "prompt_number": 29
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%timeit\n",
      "# line-by-line, no buffering\n",
      "fileobj = open('12_Optimising_1.ipynb')\n",
      "while fileobj.readline():\n",
      "    pass"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1000 loops, best of 3: 592 \u00b5s per loop\n"
       ]
      }
     ],
     "prompt_number": 30
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "Loops and functions\n",
      "-------------------\n",
      "\n",
      "Loops of functions can be expensive; sometimes it can help to bring your loop inside your function. This might make things less clear as your function ends up doing more than one thing so be sure to keep your documentation up to date and clear. Remember to test as this is not always useful."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def square_positives(number):\n",
      "    if number > 0:\n",
      "        return number*number\n",
      "    else:\n",
      "        return number"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 31
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%timeit\n",
      "output = []\n",
      "for i in range(1000):\n",
      "    output.append(square_positives(1000))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1000 loops, best of 3: 338 \u00b5s per loop\n"
       ]
      }
     ],
     "prompt_number": 32
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# bring the loop inside the function\n",
      "def square_positives_list(iterable):\n",
      "    output = []\n",
      "    for item in iterable:\n",
      "        if item > 0:\n",
      "            output.append(item*item)\n",
      "        else:\n",
      "            output.append(item)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 33
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%timeit\n",
      "square_positives_list(range(1000))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1000 loops, best of 3: 214 \u00b5s per loop\n"
       ]
      }
     ],
     "prompt_number": 34
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "Caching results\n",
      "---------------\n",
      "\n",
      "**Caching** or **memoizing** is a way of storing expensive resuls so they don't need to be calculated every time you ask for a value, this is an example of using memory in a tradeoff for speed. Cache *only works if the value never changes* or you have an implementation that will clear the cache when it does."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import time\n",
      "\n",
      "class FunctionalGroup(object):\n",
      "    \"\"\"A functional group with an energy.\"\"\"\n",
      "\n",
      "    @property\n",
      "    def energy(self):\n",
      "        # maybe this is an expensive calculation\n",
      "        # emulate it with a sleep\n",
      "        time.sleep(0.01)\n",
      "        return 7.5\n",
      "\n",
      "    @property\n",
      "    def energy_with_cache(self):\n",
      "        try:\n",
      "            # retrieve from cache\n",
      "            return self._energy\n",
      "        except AttributeError:  # not found in cache!\n",
      "            # calculate the energy once and store it\n",
      "            time.sleep(0.01)\n",
      "            self._energy = 7.5\n",
      "            return self._energy\n",
      "\n",
      "my_functional_group = FunctionalGroup()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 35
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit my_functional_group.energy"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "100 loops, best of 3: 10.1 ms per loop\n"
       ]
      }
     ],
     "prompt_number": 36
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit my_functional_group.energy_with_cache"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1000000 loops, best of 3: 345 ns per loop\n"
       ]
      }
     ],
     "prompt_number": 37
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "Cached parameters\n",
      "-----------------\n",
      "\n",
      "More complex examples can cache parameters for functions and use techniques to store a subset of common values that are used frequently (look at the `functools.lru_cache` decorator for more information). Bear in mind that this probably works best with a limited set discrete of inputs or where exactly the same inputs occur many times."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class FunctionalGroup(object):\n",
      "    def __init__(self):\n",
      "        # this is where we store cached values\n",
      "        self.__property_cache = {}\n",
      "    def some_property(self, param, condition):\n",
      "        if (param, condition) in self.__property_cache:\n",
      "            return self.__property_cache[(param, condition)]\n",
      "        else:\n",
      "            # expensive calculation\n",
      "            time.sleep(0.01)\n",
      "            my_property = param*condition\n",
      "            # store the value with the inputs\n",
      "            self.__property_cache[(param, condition)] = my_property\n",
      "            return my_property\n",
      "\n",
      "my_functional_group = FunctionalGroup()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 38
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# using random integers gives a limited number of combinations\n",
      "# average time is less than 10ms as some values are repeated\n",
      "%timeit my_functional_group.some_property(random.randint(0, 1000), 3)"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "100 loops, best of 3: 6.75 ms per loop\n"
       ]
      }
     ],
     "prompt_number": 39
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# a number of values in the cache\n",
      "len(my_functional_group._FunctionalGroup__property_cache)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 40,
       "text": [
        "341"
       ]
      }
     ],
     "prompt_number": 40
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# running again there are many more repeated values and the speed increases\n",
      "%timeit my_functional_group.some_property(random.randint(0, 1000), 3)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "100 loops, best of 3: 5.24 ms per loop\n"
       ]
      }
     ],
     "prompt_number": 41
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# size of the cache still grows, but less so\n",
      "len(my_functional_group._FunctionalGroup__property_cache)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 42,
       "text": [
        "575"
       ]
      }
     ],
     "prompt_number": 42
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# using floats, you are unlikely to ever get the same values twice\n",
      "# no speedup\n",
      "%timeit my_functional_group.some_property(random.random(), 3)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "100 loops, best of 3: 10.1 ms per loop\n"
       ]
      }
     ],
     "prompt_number": 43
    }
   ],
   "metadata": {}
  }
 ]
}