python_reference/timeit_test.ipynb

{
 "metadata": {
  "name": "",
  "signature": "sha256:629f08ba90badbccee0e3581db0e76c716d0b93abc92869d2dc5176ac6b02854"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# Python benchmarks via `timeit`"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# Sections\n",
      "- [String formatting](#string_formatting)\n",
      "    - [String formatting - .format() vs. binary operator %s](#str_format_bin)\n",
      "    - [String Reversing - [::-1] vs. `''.join(reversed())`](#str_reverse)\n",
      "- [List Operations](#list_operations)\n",
      "    - [List Reversing - [::-1] vs. reverse() vs. reversed()](#list_reverse)\n",
      "- [Dictionary Operations](#dict_ops) \n",
      "    - [Adding elements to a dictionary](#adding_dict_elements)"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "<a name='string_formatting'></a>\n",
      "\n",
      "# String formatting"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "<a name='str_format_bin'></a>\n",
      "### String formatting - `.format()` vs. binary operator `%s`"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import timeit\n",
      "\n",
      "def test_format():\n",
      "    return ['{}'.format(i) for i in range(1000000)]\n",
      "\n",
      "def test_binaryop():\n",
      "    return ['%s' %i for i in range(1000000)]\n",
      "\n",
      "%timeit test_format()\n",
      "%timeit test_binaryop()\n",
      "\n",
      "#print('{}: {}\\n{}: {}'.format('format()', format_res, '%s', binaryop_res))\n",
      "\n",
      "################################\n",
      "# On my machine\n",
      "################################\n",
      "#\n",
      "# Python 3.4.0\n",
      "# MacOS X 10.9.2\n",
      "# 2.5 GHz Intel Core i5\n",
      "# 4 GB 1600 Mhz DDR3\n",
      "#"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1 loops, best of 3: 400 ms per loop\n",
        "1 loops, best of 3: 241 ms per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n"
       ]
      }
     ],
     "prompt_number": 3
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "<a name='str_reverse'></a>\n",
      "### String Reversing - `[::-1]` vs. `''.join(reversed())`"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import timeit\n",
      "\n",
      "def reverse_join(my_str):\n",
      "    return ''.join(reversed(my_str))\n",
      "    \n",
      "def reverse_slizing(my_str):\n",
      "    return my_str[::-1]\n",
      "\n",
      "\n",
      "# Test to show that both work\n",
      "a = reverse_join('abcd')\n",
      "b = reverse_slizing('abcd')\n",
      "assert(a == b and a == 'dcba')\n",
      "\n",
      "%timeit reverse_join('abcd')\n",
      "%timeit reverse_slizing('abcd')\n",
      "\n",
      "# Python 3.4.0\n",
      "# MacOS X 10.9.2\n",
      "# 2.4 GHz Intel Core Duo\n",
      "# 8 GB 1067 Mhz DDR3\n",
      "#"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1000000 loops, best of 3: 1.28 \u00b5s per loop\n",
        "1000000 loops, best of 3: 337 ns per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n"
       ]
      }
     ],
     "prompt_number": 13
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "<a name='list_operations'></a>\n",
      "# List Operations"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "<a name='list_reverse'></a>\n",
      "### List Reversing - `[::-1]` vs. `reverse()` vs. `reversed()`"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import timeit\n",
      "\n",
      "def reverse_func(my_list):\n",
      "    new_list = my_list[:]\n",
      "    new_list.reverse()\n",
      "    return new_list\n",
      "    \n",
      "def reversed_func(my_list):\n",
      "    return list(reversed(my_list))\n",
      "\n",
      "def reverse_slizing(my_list):\n",
      "    return my_list[::-1]\n",
      "\n",
      "%timeit reverse_func([1,2,3,4,5])\n",
      "%timeit reversed_func([1,2,3,4,5])\n",
      "%timeit reverse_slizing([1,2,3,4,5])\n",
      "\n",
      "# Python 3.4.0\n",
      "# MacOS X 10.9.2\n",
      "# 2.4 GHz Intel Core Duo\n",
      "# 8 GB 1067 Mhz DDR3\n",
      "#"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1000000 loops, best of 3: 930 ns per loop\n",
        "1000000 loops, best of 3: 1.89 \u00b5s per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "1000000 loops, best of 3: 775 ns per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "<a name='dict_ops'></a>\n",
      "# Dictionary Operations "
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "<a name='adding_dict_elements'></a>\n",
      "## Adding elements to a Dictionary\n",
      "\n",
      "All three functions below count how often different elements (values) occur in a list.  \n",
      "E.g., for the list ['a', 'b', 'a', 'c'], the dictionary would look like this:  \n",
      "`my_dict = {'a': 2, 'b': 1, 'c': 1}`"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import random\n",
      "import copy\n",
      "import timeit\n",
      "\n",
      "\n",
      "\n",
      "def add_element_check1(my_dict, elements):\n",
      "    for e in elements:\n",
      "        if e not in my_dict:\n",
      "            my_dict[e] = 1\n",
      "        else:\n",
      "            my_dict[e] += 1\n",
      "            \n",
      "def add_element_check2(my_dict, elements):\n",
      "    for e in elements:\n",
      "        if e not in my_dict:\n",
      "            my_dict[e] = 0\n",
      "        my_dict[e] += 1            \n",
      "\n",
      "def add_element_except(my_dict, elements):\n",
      "    for e in elements:\n",
      "        try:\n",
      "            my_dict[e] += 1\n",
      "        except KeyError:\n",
      "            my_dict[e] = 1\n",
      "            \n",
      "\n",
      "random.seed(123)\n",
      "rand_ints = [randrange(1, 10) for i in range(100)]\n",
      "empty_dict = {}\n",
      "\n",
      "print('Results for 100 integers in range 1-10') \n",
      "%timeit add_element_check1(copy.deepcopy(empty_dict), rand_ints)\n",
      "%timeit add_element_check2(copy.deepcopy(empty_dict), rand_ints)\n",
      "%timeit add_element_except(copy.deepcopy(empty_dict), rand_ints)\n",
      "            \n",
      "print('\\nResults for 1000 integers in range 1-10')            \n",
      "rand_ints = [randrange(1, 10) for i in range(1000)]\n",
      "empty_dict = {}\n",
      "\n",
      "%timeit add_element_check1(copy.deepcopy(empty_dict), rand_ints)\n",
      "%timeit add_element_check2(copy.deepcopy(empty_dict), rand_ints)\n",
      "%timeit add_element_except(copy.deepcopy(empty_dict), rand_ints)\n",
      "\n",
      "print('\\nResults for 1000 integers in range 1-1000')            \n",
      "rand_ints = [randrange(1, 10) for i in range(1000)]\n",
      "empty_dict = {}\n",
      "\n",
      "%timeit add_element_check1(copy.deepcopy(empty_dict), rand_ints)\n",
      "%timeit add_element_check2(copy.deepcopy(empty_dict), rand_ints)\n",
      "%timeit add_element_except(copy.deepcopy(empty_dict), rand_ints)\n",
      "\n",
      "# Python 3.4.0\n",
      "# MacOS X 10.9.2\n",
      "# 2.4 GHz Intel Core Duo\n",
      "# 8 GB 1067 Mhz DDR3\n",
      "#"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Results for 100 integers in range 1-10\n",
        "10000 loops, best of 3: 30.5 \u00b5s per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "10000 loops, best of 3: 32.4 \u00b5s per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "10000 loops, best of 3: 31.7 \u00b5s per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "\n",
        "Results for 1000 integers in range 1-10\n",
        "1000 loops, best of 3: 241 \u00b5s per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "1000 loops, best of 3: 247 \u00b5s per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "1000 loops, best of 3: 209 \u00b5s per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "\n",
        "Results for 1000 integers in range 1-1000\n",
        "1000 loops, best of 3: 241 \u00b5s per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "1000 loops, best of 3: 247 \u00b5s per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "1000 loops, best of 3: 206 \u00b5s per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n"
       ]
      }
     ],
     "prompt_number": 25
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Conclusion\n",
      "Interestingly, the `try-except` loop pays off if we have more elements (here: 1000 integers instead of 100) as dictionary keys to check. Also, it doesn't matter much whether the elements exist or do not exist in the dictionary, yet."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": []
    }
   ],
   "metadata": {}
  }
 ]
}