Exploring Python - Questions of optimization.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Questions of Optimization\n",
    "## Experiments in optimization in Python\n",
    "\n",
    "### Naomi Ceder\n",
    "#### 2020-05-9 2 PM CDT, via https://www.twitch.tv/nceder/\n",
    "\n",
    "**https://naomiceder.tech, @naomiceder**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Before we start \n",
    "\n",
    "This notebook can (will) be found at https://github.com/nceder/exploring_python\n",
    "\n",
    "*The Quick Python Book* - http://bit.ly/quick-python\n",
    "\n",
    "PyCon 2020 Online! - https://www.youtube.com/channel/UCMjMBMGt0WJQLeluw6qNJuA\n",
    "\n",
    "PSF Board elections - https://www.python.org/nominations/elections/\n",
    "\n",
    "Nominations - https://www.python.org/nominations/2020-python-software-foundation-board/ \n",
    "\n",
    "Nominees will be visible once they have closed (i.e., once they all are in)\n",
    "\n",
    "How to become a PSF member - (PT-BR) https://carolinedantas.com/tutorial/2020/05/21/psf_ptbr.html\n",
    "\n",
    "(English) https://carolinedantas.com/tutorial/2020/05/21/psf_en.html\n",
    "\n",
    "(Español) https://carolinedantas.com/tutorial/2020/05/21/psf_es.html\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Do try this at home... just NOT in production. ;-)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Optimization\n",
    "\n",
    "“The real problem is that programmers have spent far too much time worrying about efficiency in the wrong places and at the wrong times; **premature optimization is the root of all evil (or at least most of it) in programming.**” \n",
    "\n",
    "-- Donald Knuth"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you look, you can always find things optimize "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Questions of  optimization (not answers)\n",
    "\n",
    "* 3 factors - processor time, memory footprint, disk access\n",
    "* You can improve up to two"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Which factor do we care most about\n",
    "\n",
    "* time (usually) - faster is better, \n",
    "* memory - saving memory costs time and requires using disk, but with large amounts of data, we can fill membory\n",
    "* disk - the more we go to and from disk, the more memory we save and more time we take.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Testing optimizations\n",
    "\n",
    "* consider external factors - use of CPU, RAM, i/o, etc by other processes\n",
    "* order of data can affect sorting, etc\n",
    "* measure and test\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strategies for saving disk access\n",
    "\n",
    "* read/write files in blocks\n",
    "* group operations that access disk\n",
    "* cache\n",
    "* do as much as possible in RAM\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Measuring disk access\n",
    "\n",
    "Use top or similar tool"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strategies for saving memory\n",
    "\n",
    "* Python 3 over Python 2 - generators and other lazy tricks\n",
    "* Encouraging garbage collection - reference count, scope, etc\n",
    "* -OO to removed built doc strings\n",
    "* see MicroPython for ideas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Measuring memory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "\n",
    "def size(obj):\n",
    "    return sys.getsizeof(obj)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9024"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 0\n",
    "b= 1000\n",
    "a_list = [str(x) for x in range(a, b)]\n",
    "size(a_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['990', '991', '992', '993', '994', '995', '996', '997', '998', '999']"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_list[-10:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9024"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b_list  = [str(x*x) for x in range(a,b)]\n",
    "size(b_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['980100',\n",
       " '982081',\n",
       " '984064',\n",
       " '986049',\n",
       " '988036',\n",
       " '990025',\n",
       " '992016',\n",
       " '994009',\n",
       " '996004',\n",
       " '998001']"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b_list[-10:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "c_list = []\n",
    "for a in range(1000):\n",
    "    c_list.append([str(x*x) for x in range(a,b+1000)])\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['3960100',\n",
       " '3964081',\n",
       " '3968064',\n",
       " '3972049',\n",
       " '3976036',\n",
       " '3980025',\n",
       " '3984016',\n",
       " '3988009',\n",
       " '3992004',\n",
       " '3996001']"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c_list[-1][-10:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9024"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "size(c_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "# a hack based on a stack overflow answer... no guarantees\n",
    "\n",
    "import sys\n",
    "\n",
    "def get_size(obj, seen=None):\n",
    "    \"\"\"Recursively finds size of objects\"\"\"\n",
    "    size = sys.getsizeof(obj)\n",
    "    if seen is None:\n",
    "        seen = set()\n",
    "    obj_id = id(obj)\n",
    "    if obj_id in seen:\n",
    "        return 0\n",
    "    # Important mark as seen *before* entering recursion to gracefully handle\n",
    "    # self-referential objects\n",
    "    seen.add(obj_id)\n",
    "    if isinstance(obj, dict):\n",
    "        size += sum([get_size(v, seen) for v in obj.values()])\n",
    "        size += sum([get_size(k, seen) for k in obj.keys()])\n",
    "    elif hasattr(obj, \"__dict__\"):\n",
    "        size += get_size(obj.__dict__, seen)\n",
    "    elif hasattr(obj, \"__iter__\") and not isinstance(obj, (str, bytes, bytearray)):\n",
    "        size += sum([get_size(i, seen) for i in obj])\n",
    "    return size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "60914"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_size(a_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "63561"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_size(b_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "96316046"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_size(c_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Stragegies for saving time\n",
    "\n",
    "* Use memory and avoid disk\n",
    "   * lru_cache\n",
    "* pre sort\n",
    "* Use sets and dicitonaries\n",
    "* Use comprehensions (even map())\n",
    "* Use C(ython)\n",
    "* experiment\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Debug flag\n",
    "\n",
    "* running interpreter with -O sets debug to true, removes asserts, etc\n",
    "* -OO also strips out  comments\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "# fibonacci with recursion\n",
    "\n",
    "def fib_recursive(number):\n",
    "    \"\"\" this is a recursive fibonacci number generator\"\"\"\n",
    "\n",
    "    assert number > 0\n",
    "    \n",
    "    if __debug__:\n",
    "        print(number)\n",
    "        \n",
    "    \n",
    "    if number in [1, 2]:\n",
    "        result = 1\n",
    "    else:\n",
    "        result =  fib_recursive(number - 1) + fib_recursive(number -  2)\n",
    "    \n",
    "    return result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lessons\n",
    "\n",
    "* This is why you NEVER should use asserts as an essential part of the code\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Measuring time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### timeit module\n",
    "\n",
    "* commandline  - `python -m timeit \"expression\"`\n",
    "* callable interface - `import timeit`\n",
    "* Timer class"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### timeit commandline\n",
    "\n",
    "`python -m timeit -n <number> -r <repetitions of timer> -s <setup expression> <expression to time>`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"-\".join(str(n) for n in range(100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "def join_digits_100():\n",
    "    result = \"-\".join(str(n) for n in range(100))\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0-1-2-3-4-5-6-7-8-9-10-11-12-13-14-15-16-17-18-19-20-21-22-23-24-25-26-27-28-29-30-31-32-33-34-35-36-37-38-39-40-41-42-43-44-45-46-47-48-49-50-51-52-53-54-55-56-57-58-59-60-61-62-63-64-65-66-67-68-69-70-71-72-73-74-75-76-77-78-79-80-81-82-83-84-85-86-87-88-89-90-91-92-93-94-95-96-97-98-99'"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def concat_str(n):\n",
    "    result = \"\"\n",
    "    for x in range(n-1):\n",
    "        result += str(x) + \"-\"\n",
    "    result += str(n-1)\n",
    "    return result\n",
    "\n",
    "concat_str(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Note that from commandline 10000 runs and 3 repetitions is used by default\n",
    "\n",
    "$ python -m timeit '\"-\".join(str(n) for n in range(100))'\n",
    "100000 loops, best of 3: 18.2 usec per loop\n",
    "$ python -m timeit '\"-\".join([str(n) for n in range(100)])'\n",
    "100000 loops, best of 3: 16.5 usec per loop\n",
    "$ python -m timeit '\"-\".join(map(str, range(100)))'\n",
    "100000 loops, best of 3: 10.8 usec per loop\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import timeit\n",
    "\n",
    "# using timeit(), the number of runs needs to be specified or 1000000 is used. Can't repeat\n",
    "a = timeit.timeit('\"-\".join(str(n) for n in range(100000))', number=100)\n",
    "print(a)\n",
    "\n",
    "b = timeit.timeit('\"-\".join([str(n) for n in range(100000)])', number=100)\n",
    "print(b)\n",
    "\n",
    "c = timeit.timeit('\"-\".join(map(str, range(100000)))', number=100)\n",
    "print(c)\n",
    "\n",
    "d = timeit.timeit('concat_str(100000)', setup=\"from __main__ import concat_str\", \n",
    "                number=100)\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import timeit\n",
    " \n",
    "# using repeat, the number of runs needs to be specified or 1000000 is used. repeats defaults to 3\n",
    "a = timeit.repeat('\"-\".join(str(n) for n in range(100))', number=10000, repeat=3)\n",
    "print(a)\n",
    "\n",
    "b = timeit.repeat('\"-\".join([str(n) for n in range(100)])', number=10000, repeat=3)\n",
    "print(b)\n",
    "\n",
    "c = timeit.repeat('\"-\".join(map(str, range(100)))', number=10000, repeat=3)\n",
    "print(c)\n",
    "\n",
    "d = timeit.repeat('concat_str(100)', setup=\"from __main__ import concat_str\", number=10000, repeat=3)\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "45.6 µs ± 1.68 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "38.6 µs ± 1.47 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit concat_str(100)\n",
    "%timeit join_digits_100()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What about exceptions?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Are exceptions slow?\n",
    "\n",
    "* yes, kinda, but... there's a balance\n",
    "* if there will be a lot of exceptions, it may be better to LYBL\n",
    "* if exceptions will be... uh... the exception, then they can make code more readable\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_while_loop():\n",
    "    i = 0\n",
    "    length = 1000\n",
    "    while i < length:\n",
    "        x = i * i\n",
    "        i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Count:\n",
    "    def __init__(self, count):\n",
    "        self.count = count\n",
    "\n",
    "    def __getitem__(self, key):\n",
    "        if 0 < key < self.count:\n",
    "            return key\n",
    "        else:\n",
    "            # IndexError raised to iterator\n",
    "            raise IndexError\n",
    "\n",
    "\n",
    "def test_count():\n",
    "    counter = Count(1000)\n",
    "    # iterator raises StopIteration to end interation\n",
    "    for i in counter:\n",
    "        x = i * i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "509 µs ± 106 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n",
      "5.78 µs ± 1.14 µs per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit test_while_loop()\n",
    "%timeit test_count()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using the right tool...."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import deque\n",
    "\n",
    "a_list = []\n",
    "a_deque = deque()\n",
    "\n",
    "def test_list_queue():\n",
    "    for x in range(10000):\n",
    "        a_list.insert(x, 0)\n",
    "    \n",
    "    for x in range(10000):\n",
    "        a_list.pop(0)\n",
    "\n",
    "def test_deque():\n",
    "    for x in range(10000):\n",
    "        a_deque.appendleft(x)\n",
    "    \n",
    "    for x in range(10000):\n",
    "        a_deque.popleft()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "62 ms ± 8.59 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n",
      "13.9 ms ± 4.69 ms per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit test_list_queue()\n",
    "\n",
    "%timeit test_deque()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## caching\n",
    "\n",
    "* functools - lrucache\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import lru_cache\n",
    "\n",
    "def fib(number):\n",
    "    if number < 2:\n",
    "        return number\n",
    "    return fib(number-1)+fib(number-2) \n",
    "\n",
    "@lru_cache(maxsize=None)\n",
    "def fib_recursive_cache(number):\n",
    "    if number in [1, 2]:\n",
    "        result = 1\n",
    "    else:\n",
    "        result =  fib_recursive_cache(number - 1) + fib_recursive_cache(number - 2)\n",
    "    \n",
    "    return result\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "123 µs ± 20.7 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "586 ns ± 189 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit fib(10) \n",
    "%timeit fib_recursive_cache(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cython"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "`$ pip install cython`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Cython extension is already loaded. To reload it, use:\n",
      "  %reload_ext Cython\n"
     ]
    }
   ],
   "source": [
    "%load_ext Cython"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fib(number):\n",
    "    if number < 2:\n",
    "        return number\n",
    "    return fib(number-1)+fib(number-2) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%cython\n",
    "def fib_cython(number):\n",
    "    if number < 2:\n",
    "        return number\n",
    "    return fib_cython(number-1)+fib_cython(number-2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%cython\n",
    "cpdef long fib_cython_typed(long number):\n",
    "    if number < 2:\n",
    "        return number\n",
    "    return fib_cython_typed(number-1)+fib_cython_typed(number-2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "# fibonacci via looping\n",
    "\n",
    "def fib_loop(number):\n",
    "    cur_fib,next_fib = 1,1\n",
    "    for i in range(number - 1):\n",
    "        cur_fib,  next_fib = next_fib, cur_fib + next_fib\n",
    "    return cur_fib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%cython\n",
    "\n",
    "# fibonacci via looping, cython, typed\n",
    "\n",
    "\n",
    "cpdef long fib_loop_cython_typed(long number):\n",
    "    cdef long cur_fib, next_fib\n",
    "    cur_fib, next_fib = 1,1\n",
    "    for i in range(number - 1):\n",
    "        cur_fib,next_fib = next_fib,cur_fib+next_fib\n",
    "    return cur_fib\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "170 µs ± 29.5 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "39.8 µs ± 9.45 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "2.66 µs ± 666 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n",
      "7.56 µs ± 1.9 µs per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n",
      "524 ns ± 177 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit fib(10)\n",
    "\n",
    "%timeit fib_cython(10)\n",
    " \n",
    "%timeit fib_cython_typed(10)\n",
    "\n",
    "%timeit fib_loop(10)\n",
    "\n",
    "%timeit fib_loop_cython_typed(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "File fib.pyx\n",
    "```\n",
    "def fib(number):\n",
    "    if number < 2:\n",
    "        return number\n",
    "    return fib(number-1)+fib(number-2)\n",
    "```\n",
    "File setup.py\n",
    "```\n",
    "from distutils.core import setup\n",
    "from Cython.Build import cythonize\n",
    "\n",
    "setup(\n",
    "    ext_modules = cythonize(\"fib.pyx\")\n",
    "    )\n",
    "```\n",
    "Build with:\n",
    "`$ python setup.py build_ext --inplace`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Questions?\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Thanks\n",
    "\n",
    "### Final Notes\n",
    "\n",
    "[Feedback and suggestions](https://docs.google.com/forms/d/e/1FAIpQLScO28mEaxsHZKFDsPYoctjCMjndgVw2lUNFKvlrqodNNN4uCw/viewform?usp=pp_url&entry.1081536003=Objects+All+the+Way+Down+-+Apr+24,+2020)\n",
    "\n",
    "This notebook - https://github.com/nceder/exploring_python\n",
    "\n",
    "*The Quick Python Book*, 3rd ed - http://bit.ly/quick-python\n",
    "\n",
    "Me - https://naomiceder.tech, @naomiceder\n",
    "\n",
    "PyCon 2020 Online! - https://www.youtube.com/channel/UCMjMBMGt0WJQLeluw6qNJuA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  },
  "livereveal": {
   "scroll": true,
   "start_slideshow_at": "selected",
   "theme": "white",
   "transition": "none"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}