PythonTools.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import sys\n",
    "import time\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A little about iterators\n",
    "\n",
    "A neat Python hack we can discuss later"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 1, 2), (3, 4, 5), (6, 7, 8)]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(zip(*[iter(np.arange(9))]*3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterables\n",
    "\n",
    "Iterables are anything that defines the `__iter__` method.  The `__iter__` method is called whenever an iterable is iterated over at the beginning of a for loop.  The `__iter__` method can also be called using the `iter` builtin function.  The `__iter__` method must return an *iterator*.  In general, anything you can iterate over in a for loop is an iterable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Lists are iterables\n",
    "hasattr([1,2,3], '__iter__')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Strings are iterables\n",
    "hasattr(\"Hello World\", '__iter__')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Range objects are iterables\n",
    "hasattr(range(5), '__iter__')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterators\n",
    "\n",
    "Iterators are a special type of iterable that define the `__next__` method.  The `__next__` method is a method that returns the next element in the object you are iterating over.  The `__next__` method is called at each loop in a for loop to get the next element.  The `__next__` method can also be called using the `next` builtin function.\n",
    "\n",
    "Iterators only have knowledge of their next state.  This means that you only have access to the next element to be iterated over.  This means that iterators cannot be sliced or indexed.  Iterators tend to compute their next value only when the value is requested.  This can be used to avoid the overhead of unnecessary caching."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Lists are not iterators\n",
    "hasattr([1,2,3], '__next__')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Calling iter on an iterable makes it an iterator\n",
    "hasattr(iter([1,2,3]), '__next__')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H\n",
      "i\n"
     ]
    }
   ],
   "source": [
    "# Getting elements from an iterator\n",
    "iterator = iter(\"Hi\")\n",
    "print(next(iterator))\n",
    "print(next(iterator))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bounis: `range` objects\n",
    "\n",
    "Are `range` objects iterators?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'range' object is not an iterator",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-9-fd811275ae80>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'range' object is not an iterator"
     ]
    }
   ],
   "source": [
    "next(range(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Writing a custom iterator\n",
    "\n",
    "We can write an interator as a class.  To do so, we must define the `__iter__` and `__next__` methods.  Since the `__iter__` method must return an iterator and the instance itself is an iterator, we can just return the instance from the `__iter__` method.\n",
    "\n",
    "The `__next__` method must return the next item in the iterator.  Once there are no more items to be returned, the `__next__` method must raise a `StopIteration` error.  This is a special type of error that Python for loops are aware of.  Once the `StopIteration` error is raised by an iterator, the for loop knows there are no more elements left and stops iterating."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyIterator:\n",
    "    \"\"\"An iterator that returns sequential positive \n",
    "    integers less than or equal to 10\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self):\n",
    "        \n",
    "        # Set some initial value for the iterator\n",
    "        self.state = 0\n",
    "    \n",
    "    def __iter__(self):\n",
    "        \n",
    "        # Since `self` is an iterator, we can just return it\n",
    "        return self\n",
    "    \n",
    "    def __next__(self):\n",
    "\n",
    "        self.state += 1 # Do something to update the object\n",
    "        if self.state > 10: # Must have some end condition\n",
    "            raise StopIteration # This causes to iteration to end\n",
    "        return self.state # This is the next value of the iterator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 6 7 8 9 10 "
     ]
    }
   ],
   "source": [
    "iterator = MyIterator()\n",
    "\n",
    "for item in iterator:\n",
    "    print(item, end=' ')\n",
    "    \n",
    "# Notice how we're out of values\n",
    "for item in iterator:\n",
    "    print(item, end=' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-9 -8 -7 -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6 7 8 9 10 "
     ]
    }
   ],
   "source": [
    "# With this iterator, we can reset the state ourselves\n",
    "iterator.state = -10\n",
    "for item in iterator:\n",
    "    print(item, end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functools"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Partial"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import partial"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function print in module builtins:\n",
      "\n",
      "print(...)\n",
      "    print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)\n",
      "    \n",
      "    Prints the values to a stream, or to sys.stdout by default.\n",
      "    Optional keyword arguments:\n",
      "    file:  a file-like object (stream); defaults to the current sys.stdout.\n",
      "    sep:   string inserted between values, default a space.\n",
      "    end:   string appended after the last value, default a newline.\n",
      "    flush: whether to forcibly flush the stream.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(print)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Print to stderr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Warning: You've got an Error\n"
     ]
    }
   ],
   "source": [
    "print_err = partial(print, file=sys.stderr, flush=True)\n",
    "print_err(\"Warning: You've got an Error\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading Icon"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20/20|####################|#################|##############|##################\r"
     ]
    }
   ],
   "source": [
    "loading_msg = partial(print, end='\\r', sep='|', flush=True)\n",
    "\n",
    "loading_msg(' '*26,'')\n",
    "for i in range(20):\n",
    "    loading_msg(f'{i+1:>2d}/20', '#'*(i+1))\n",
    "    time.sleep(0.2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CSV File Writer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "csv_file = open('test_table.csv', 'w')\n",
    "\n",
    "csv_writer = partial(print, file=csv_file, sep=',', flush=True)\n",
    "for _ in range(10):\n",
    "    csv_writer(*np.random.random(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.2829549470966546,0.7913389840116397,0.9327735926214271\r\n",
      "0.025995044684231083,0.8458335342823904,0.8257285015214271\r\n",
      "0.4382653241524628,0.5119143454745039,0.054630762707368885\r\n",
      "0.925851683514305,0.11178112685958819,0.7007718678869173\r\n",
      "0.1263171467639731,0.08789358250139334,0.19147322222376773\r\n",
      "0.8443474866221021,0.4826804558680925,0.1884564193992142\r\n",
      "0.9146874700964528,0.13988642448065725,0.6712016632214027\r\n",
      "0.7130497724257293,0.09589953063071732,0.8543023732366555\r\n",
      "0.39159779585303356,0.0396706530075559,0.8666067811137689\r\n",
      "0.20506839227241225,0.13147170114508122,0.41241509045106983\r\n"
     ]
    }
   ],
   "source": [
    "!cat test_table.csv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Log File Writer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Warning: Failed to write to file\n",
      "Warning: Failed to write to file\n",
      "Warning: Failed to write to file\n",
      "Warning: Failed to write to file\n",
      "Warning: Failed to write to file\n",
      "Warning: Failed to write to file\n",
      "Warning: Failed to write to file\n"
     ]
    }
   ],
   "source": [
    "logfile = open('my_log.log', 'w')\n",
    "logger = partial(print, file=logfile, flush=True)\n",
    "\n",
    "\n",
    "for i in range(20):\n",
    "    t = time.strftime(\"%H:%M:%S\", time.localtime())\n",
    "    if not (i % 3):\n",
    "        logger(t, 'Skipping Iteration: i=', i)\n",
    "        print_err(\"Warning: Failed to write to file\")\n",
    "    else:\n",
    "        logger(t, 'Writing to CSV file')\n",
    "        csv_writer(*np.arange(3))\n",
    "    time.sleep(0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10:44:34 Skipping Iteration: i= 0\r\n",
      "10:44:34 Writing to CSV file\r\n",
      "10:44:35 Writing to CSV file\r\n",
      "10:44:35 Skipping Iteration: i= 3\r\n",
      "10:44:35 Writing to CSV file\r\n",
      "10:44:35 Writing to CSV file\r\n",
      "10:44:35 Skipping Iteration: i= 6\r\n",
      "10:44:36 Writing to CSV file\r\n",
      "10:44:36 Writing to CSV file\r\n",
      "10:44:36 Skipping Iteration: i= 9\r\n",
      "10:44:36 Writing to CSV file\r\n",
      "10:44:36 Writing to CSV file\r\n",
      "10:44:37 Skipping Iteration: i= 12\r\n",
      "10:44:37 Writing to CSV file\r\n",
      "10:44:37 Writing to CSV file\r\n",
      "10:44:37 Skipping Iteration: i= 15\r\n",
      "10:44:37 Writing to CSV file\r\n",
      "10:44:38 Writing to CSV file\r\n",
      "10:44:38 Skipping Iteration: i= 18\r\n",
      "10:44:38 Writing to CSV file\r\n"
     ]
    }
   ],
   "source": [
    "!cat my_log.log"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A trick with wrappers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 5)\n",
      "[[ 9 10]\n",
      " [13 14]]\n"
     ]
    }
   ],
   "source": [
    "@partial(partial, z=5)\n",
    "def f(x, y, z=4):\n",
    "    return x, y, z\n",
    "    \n",
    "@partial(np.vectorize, signature='(m),(),()->(m)')\n",
    "def g(x, y, z):\n",
    "    return x + y * z\n",
    "\n",
    "print(f(1, 2))\n",
    "print(g([1, 2], [2, 3], 4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Reduce"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import reduce"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function reduce in module _functools:\n",
      "\n",
      "reduce(...)\n",
      "    reduce(function, sequence[, initial]) -> value\n",
      "    \n",
      "    Apply a function of two arguments cumulatively to the items of a sequence,\n",
      "    from left to right, so as to reduce the sequence to a single value.\n",
      "    For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates\n",
      "    ((((1+2)+3)+4)+5).  If initial is present, it is placed before the items\n",
      "    of the sequence in the calculation, and serves as a default when the\n",
      "    sequence is empty.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(reduce)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reduce(add, [1,2,3,4])\n",
    "add(add(1, 2), 3)\n",
    "add(add(add(1, 2), 3), 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "45\n",
      "24\n"
     ]
    }
   ],
   "source": [
    "def add(x, y):\n",
    "    return x+y\n",
    "\n",
    "def mul(x, y):\n",
    "    return x*y\n",
    "\n",
    "print(reduce(add, range(10))) # same as sum\n",
    "print(reduce(mul, range(1,5))) # same as factorial"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 0\n",
      "2 1\n",
      "3 3\n",
      "4 6\n",
      "5 10\n",
      "6 15\n",
      "7 21\n",
      "8 28\n",
      "9 36\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def print_args(x, y):\n",
    "    print(y, x)\n",
    "    return x+y\n",
    "\n",
    "reduce(print_args, range(10)) # prints the triangular numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Remove All Instances of Many Words"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python ###### method replace() \n",
      "returns a copy of the ###### in which the \n",
      "occurrences of ### have been replaced with \n",
      "###, optionally restricting the number of \n",
      "############ to ###.\n"
     ]
    }
   ],
   "source": [
    "def remove_word(sentence, word):\n",
    "    return sentence.replace(word, '#'*len(word))\n",
    "\n",
    "sentence = \"\"\"Python string method replace() \n",
    "returns a copy of the string in which the \n",
    "occurrences of old have been replaced with \n",
    "new, optionally restricting the number of \n",
    "replacements to max.\"\"\"\n",
    "\n",
    "print(reduce(remove_word, ['new', 'string', 'replacements', 'old', 'max'], sentence))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Itertools"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x: 1\n",
      "args: (2, 3)\n",
      "kwargs {'a': 7, 'b': 8}\n"
     ]
    }
   ],
   "source": [
    "def f(x, *args, **kwargs):\n",
    "    print('x:', x)\n",
    "    print('args:',args)\n",
    "    print('kwargs',kwargs)\n",
    "    \n",
    "f(1,2,3, a=7, b=8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([1, 2], 3)"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "*a, b = [1,2,3]\n",
    "a, b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3, 5, 6, 7)"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(*[1,2,3], 5, 6, 7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3)"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a,b, c = [1,2,3]\n",
    "a,b,c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chain"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import chain"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']\n",
      "Hello world"
     ]
    }
   ],
   "source": [
    "items = ['Hello', ' ', 'world']\n",
    "print(list(chain(*items)))\n",
    "for i in chain(*items):\n",
    "    print(i, end='')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cycle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import cycle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "r g b r g b r g b r "
     ]
    }
   ],
   "source": [
    "color_cycle = cycle('rgb')\n",
    "for _ in range(10):\n",
    "    print(next(color_cycle), end=' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "colors = 'rgb'\n",
    "heights = np.arange(9)\n",
    "for color, height in zip(cycle(colors), heights):\n",
    "    plt.plot(np.random.random(25)+height, color=color)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Repeat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import repeat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 10, 10, 10, 10, 10, 10, 10, 10, 10]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(repeat(10, 10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['-', '-', '-', ':', ':', ':', '--', '--', '--']\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "line_styles = list(chain(*(repeat(style, 3) for style in ('-',':','--'))))\n",
    "print(line_styles)\n",
    "for color, height, style in zip(cycle(colors), heights, line_styles):\n",
    "    plt.plot(np.random.random(25)+height, color=color, ls=style)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Generators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "storage = []\n",
    "for i in [1,2,3]:\n",
    "    storage.append(i)\n",
    "    \n",
    "#storage = [i for i in [1,2,3] if not i%2 for j in range(5)]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "storage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mu = 1\n",
    "sigma = 0.5\n",
    "zscore = [(x-mu)/sigma for x in np.random.randn(10)*sigma+mu]\n",
    "print(zscore)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zscore_gen = ((x-mu)/sigma for x in np.random.randn(10)*sigma+mu)\n",
    "print(zscore_gen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(next(zscore_gen))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for z in zscore_gen:\n",
    "    print(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for z in zscore_gen:\n",
    "    print(zscore_gen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(next(zscore_gen))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## yield"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic Generator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def range_squared(N):\n",
    "    for i in range(N):\n",
    "        yield i**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rs = range_squared(3)\n",
    "print(next(rs))\n",
    "print(next(rs))\n",
    "print(next(rs))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(next(rs))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range_squared(5):\n",
    "    print(i, end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Speeding up high memory operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_data(N):\n",
    "    data_array = []\n",
    "    for _ in range(N):\n",
    "        data_array.append(np.random.random(100000))\n",
    "    return data_array\n",
    "\n",
    "def generate_data(N):\n",
    "    for _ in range(N):\n",
    "        yield np.random.random(100000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%timeit\n",
    "\n",
    "for data in create_data(1000):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%timeit\n",
    "\n",
    "for data in generate_data(1000):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Making IO operations more efficient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "\n",
    "def get_text(path):\n",
    "    lines = []\n",
    "    for root, dirs, files in os.walk(path):\n",
    "        for filename in files:\n",
    "            if filename.endswith('.py'):\n",
    "                with open(os.path.join(root, filename), 'r') as f:\n",
    "                    for line in f:\n",
    "                        lines.append(line)\n",
    "    return lines\n",
    "                        \n",
    "def gen_text(path):\n",
    "    for root, dirs, files in os.walk(path):\n",
    "        for filename in files:\n",
    "            if filename.endswith('.py'):\n",
    "                with open(os.path.join(root, filename)) as f:\n",
    "                    yield from f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%timeit\n",
    "\n",
    "comment_count = 0\n",
    "for line in get_text(np.__path__[0]):\n",
    "    if '#' in line:\n",
    "        comment_count += 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%timeit\n",
    "\n",
    "comment_count = 0\n",
    "for line in gen_text(np.__path__[0]):\n",
    "    if '#' in line:\n",
    "        comment_count += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Concatentation Tricks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "*def hstack(A, B):\n",
    "    for a in A:\n",
    "        yield a\n",
    "    for b in B:\n",
    "        yield b\n",
    "        \n",
    "print(list(hstack('Hello', ' world')))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Flattening Tricks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def flatten_1d(A):\n",
    "    for a in A:\n",
    "        yield from a\n",
    "\n",
    "print(list(flatten_1d(np.arange(9).reshape(3,3))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Messing with Memory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def editable_data(N):\n",
    "    cache = np.random.random(5)\n",
    "    for _ in range(N):\n",
    "        cache += 1\n",
    "        yield cache"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_generator = editable_data(5)\n",
    "\n",
    "current_data = next(data_generator)\n",
    "print(current_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "current_data -= 10\n",
    "print(next(data_generator))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "series = np.empty((20, 5))\n",
    "\n",
    "for i, data in enumerate(editable_data(20)):\n",
    "    data *= 0.5\n",
    "    series[i] = data[::]\n",
    "    \n",
    "plt.plot(series);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cleaner Integrators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def F(x):\n",
    "    # What's the solution?\n",
    "    return -5*x\n",
    "\n",
    "def euler_integrator(x0, v0, dt, T):\n",
    "    \n",
    "    times = np.arange(0, T, dt)\n",
    "    x = np.empty_like(times)\n",
    "    v = np.empty_like(times)\n",
    "    a = np.empty_like(times)\n",
    "    \n",
    "    x[0], v[0], a[0] = x0, v0, F(x0)\n",
    " \n",
    "    for i, t in enumerate(times[1:]):\n",
    "        x[i+1] = x[i] + v[i] * dt + 0.5*a[i] * dt**2\n",
    "        v[i+1] = v[i] + a[i] * dt\n",
    "        a[i+1] = F(x[i+1])\n",
    "        \n",
    "    return x, v, a, times\n",
    "\n",
    "def euler_generator(x0, v0, dt, T):\n",
    "    \n",
    "    t, x, v = 0, x0, v0\n",
    "    \n",
    "    while t < T:\n",
    "        a = F(x)\n",
    "        t += dt\n",
    "        x += v * dt + 0.5 * a * dt**2\n",
    "        v += a * dt\n",
    "        yield x, v, a, t\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "result = euler_integrator(5, 2, 0.001, 4)\n",
    "plt.plot(result[3], result[0], label='original')\n",
    "\n",
    "\n",
    "result = np.array(list(zip(*euler_generator(5, 2, 0.001, 4))))\n",
    "plt.plot(result[3], result[0], ls='--', label='generator')\n",
    "\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Say you only want the last result or want to use a callback"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%timeit\n",
    "\n",
    "result = np.array(euler_integrator(5, 2, 0.001, 4))[:, -1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "%%timeit\n",
    "\n",
    "for i in euler_generator(5, 2, 0.001, 4):\n",
    "    result = i"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Drinking Games!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    " def fizzbuzz_round(i):\n",
    "    if (i % 3) and (i % 5):\n",
    "        yield str(i)\n",
    "    if not (i % 3):\n",
    "        yield 'fizz'\n",
    "    if not (i % 5):\n",
    "        yield 'buzz'\n",
    "\n",
    "def fizzbuzz(N):\n",
    "    for i in range(1, N+1):\n",
    "        yield ''.join(fizzbuzz_round(i))\n",
    "            \n",
    "for item in fizzbuzz(20):\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Monte Carlo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = np.linspace(-10, 10, 100)*5+2\n",
    "sigma = np.sqrt(data.mean())\n",
    "noise = np.random.randn(100)*sigma\n",
    "data += noise\n",
    "\n",
    "\n",
    "def F(x, y):\n",
    "    \n",
    "    return np.linspace(-10, 10, 100)*x+y\n",
    "\n",
    "def compute_chi2(x0, mu, sigma, N):\n",
    "    \n",
    "    x = x0.copy()\n",
    "    for _ in range(N):\n",
    "        yield x, np.sum((F(*x)-mu)**2)/sigma**2\n",
    "\n",
    "def metropolis_iterator(x0, N, n_burn):\n",
    "    \n",
    "    chi2_0, x0 = np.inf, np.array(x0)\n",
    "    for i, (x, chi2) in enumerate(compute_chi2(x0, data, sigma, N)):\n",
    "        \n",
    "        if i > n_burn:\n",
    "            yield x.copy()\n",
    "        \n",
    "        if chi2 - chi2_0 < np.log(np.random.random()):\n",
    "            chi2_0, x0[:] = chi2, x\n",
    "        \n",
    "        x[:] = x0 + np.random.randn(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "walkers = np.array(list(metropolis_iterator([10.0, 0.0], 10000, 1000)))\n",
    "mean = walkers.mean(axis=0)\n",
    "std = walkers.std(axis=0)\n",
    "\n",
    "plt.scatter(walkers[:, 0], walkers[:, 1], s=10, alpha=0.25, edgecolor='None', color='k');\n",
    "\n",
    "plt.figure()\n",
    "\n",
    "plt.scatter(np.arange(100), data, s=10, edgecolor='None', color='k')\n",
    "plt.plot(F(*walkers.mean(axis=0)), ls='--')\n",
    "plt.fill_between(np.arange(100), F(*(mean+std)), F(*(mean-std)), color='gray', alpha=0.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Concurrency!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_procs_concurrent(*procs):\n",
    "    results = {proc:[] for proc in procs}\n",
    "    flags = {proc: 1 for proc in procs}\n",
    "    while any(flags.values()):\n",
    "        for proc in procs:\n",
    "            if flags[proc]:\n",
    "                try:\n",
    "                    results[proc].append(next(proc))\n",
    "                except StopIteration:\n",
    "                    yield results[proc]\n",
    "                    flags[proc] = 0\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "runners = (metropolis_iterator([10.0-i, 0.0+i], 10000, 9000) for i in range(10))\n",
    "results = run_procs_concurrent(*runners)\n",
    "results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "walkers = reduce(hstack, results)\n",
    "all_walkers = np.array(list(walkers))\n",
    "plt.scatter(all_walkers[:, 0], all_walkers[:, 1], s=10, alpha=0.25, edgecolor='None', color='k');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# What Should I Do Next Time? \n",
    "\n",
    "* Extend this notebook with Coroutines and AsyncIO\n",
    "\n",
    "* Generating Colors using matplotlib, palettable, and elbow grease\n",
    "\n",
    "* Python debugging with `breakpoint`"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "tardis",
   "language": "python",
   "name": "tardis"
  },
  "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}