Iteration.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "# Iteration In Python\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "## `for` loop: A review"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task: create a list of all the words in lowercase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "words = open('/usr/share/dict/words').read().splitlines()\n",
    "    \n",
    "lower_case_words = []\n",
    "for word in words:\n",
    "    lower_case_words.append(word.lower())\n",
    "\n",
    "print(lower_case_words[:100])\n",
    "print(len(lower_case_words))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Need to remove the ones ending in `'s`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "lower_case_words = []\n",
    "for word in words:\n",
    "    if not word.endswith(\"'s\"):\n",
    "        lower_case_words.append(word.lower())\n",
    "\n",
    "print(lower_case_words[:100])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Comprehensions\n",
    "## A short hand method to get the results of a per element operation\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "lower_case_words = [word.lower() for word in words]\n",
    "print(lower_case_words[:100])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Apostrophes are back"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "lower_case_words = tuple(word.lower() for word in words if not word.endswith(\"'s\"))\n",
    "print(lower_case_words[:100])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#dict example\n",
    "matrix = [\n",
    "    [1, 2, 3],\n",
    "    [4, 5, 6],\n",
    "    [7, 8, 9]\n",
    "]\n",
    "first_elems = {idx: row[0] for idx, row in enumerate(matrix)}\n",
    "print(first_elems)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# What else can we loop over?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# tuples\n",
    "loop_tuple = ('a', 'b', 'c')\n",
    "for letter in loop_tuple:\n",
    "    print(repr(letter))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# strings\n",
    "loop_str = 'abc'\n",
    "for letter in loop_str:\n",
    "    print(repr(letter))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# a range of numbers\n",
    "for num in range(1, 4):\n",
    "    print(num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# dictionaries\n",
    "loop_dict = {'a': 1, 'b': 2, 'c': 3}\n",
    "for letter in loop_dict:\n",
    "    print(repr(letter))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#sets\n",
    "loop_set = {'a', 'b', 'c'}\n",
    "for letter in loop_set:\n",
    "    print(repr(letter))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# files\n",
    "loop_file = open('./file_example.txt')\n",
    "for line in loop_file:\n",
    "    print(repr(line))\n",
    "    \n",
    "print(repr(open('./file_example.txt').read()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# custom objects\n",
    "class FibonacciIterator(object):\n",
    "    def __init__(self):\n",
    "        self.prev_num1 = 0\n",
    "        self.prev_num2 = 1\n",
    "    def __next__(self):\n",
    "        next_num = self.prev_num1 + self.prev_num2\n",
    "        self.prev_num2 = self.prev_num1\n",
    "        self.prev_num1 = next_num\n",
    "        return next_num\n",
    "        \n",
    "class FibonacciIterable(object):\n",
    "    def __iter__(self):\n",
    "        return FibonacciIterator()\n",
    "    \n",
    "# print all fibonacci numbers < 100\n",
    "for num in FibonacciIterable():\n",
    "    if num > 100:\n",
    "        break\n",
    "    print(num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define some terms\n",
    "### Iterable:\n",
    "* Anything that has a `__iter__` method\n",
    "* Object used for the `in` part of a `for` loop\n",
    "* `__iter__` must return an iterator object\n",
    "\n",
    "### Iterator:\n",
    "* Anything that has a `__next__` method\n",
    "* `__next__` should return the next element in the sequence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "fib_iterable = FibonacciIterable()\n",
    "print(repr(fib_iterable))\n",
    "\n",
    "# iter() will call fib_iterable.__iter__() for us\n",
    "fib_iterator = iter(fib_iterable)\n",
    "print(repr(fib_iterator))\n",
    "\n",
    "# next() calls fib_iterator.__next__() for us\n",
    "print(next(fib_iterator))\n",
    "print(next(fib_iterator))\n",
    "print(next(fib_iterator))\n",
    "print(next(fib_iterator))\n",
    "print(next(fib_iterator))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### How do we make it stop?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class FibonacciIterator(object):\n",
    "    def __init__(self, max_count):\n",
    "        self.prev_num1 = 0\n",
    "        self.prev_num2 = 1\n",
    "        self.count = 0\n",
    "        self.max_count = max_count\n",
    "    def __next__(self):\n",
    "        self.count += 1\n",
    "        if self.count > self.max_count:\n",
    "            # signal to python we reached the end\n",
    "            raise StopIteration\n",
    "        next_num = self.prev_num1 + self.prev_num2\n",
    "        self.prev_num2 = self.prev_num1\n",
    "        self.prev_num1 = next_num\n",
    "        return next_num\n",
    "        \n",
    "class FibonacciIterable(object):\n",
    "    def __init__(self, max_count):\n",
    "        self.max_count = max_count\n",
    "    def __iter__(self):\n",
    "        return FibonacciIterator(self.max_count)\n",
    "    \n",
    "for num in FibonacciIterable(20):\n",
    "    print(num)\n",
    "for num in FibonacciIterable(10):\n",
    "    print(num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Iterable and Iterator can be the same object\n",
    "class Fibonacci(object):\n",
    "    def __init__(self, max_count):\n",
    "        self.prev_num1 = 0\n",
    "        self.prev_num2 = 1\n",
    "        self.count = 0\n",
    "        self.max_count = max_count\n",
    "    def __iter__(self):\n",
    "        return self\n",
    "    def __next__(self):\n",
    "        self.count += 1\n",
    "        if self.count > self.max_count:\n",
    "            raise StopIteration\n",
    "        next_num = self.prev_num1 + self.prev_num2\n",
    "        self.prev_num2 = self.prev_num1\n",
    "        self.prev_num1 = next_num\n",
    "        return next_num\n",
    "    \n",
    "for num in Fibonacci(10):\n",
    "    print(num)\n",
    "    \n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# if the they are the same object, you can't iterate over the iterable more than once\n",
    "class List(object):\n",
    "    def __init__(self):\n",
    "        self.cur_index = 0\n",
    "        self.data = [1, 2, 3]\n",
    "        \n",
    "    def __iter__(self):\n",
    "        return self\n",
    "    def __next__(self):\n",
    "        if self.cur_index >= len(self.data):\n",
    "            raise StopIteration\n",
    "        value = self.data[self.cur_index]\n",
    "        self.cur_index += 1\n",
    "        return value\n",
    "    \n",
    "lst = List()\n",
    "i1 = iter(lst)\n",
    "i2 = iter(lst)\n",
    "print(i1.cur_index)\n",
    "print(i2.cur_index)\n",
    "\n",
    "next(i1)\n",
    "print(i1.cur_index)\n",
    "print(i2.cur_index)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Generators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def fibonacci(count):\n",
    "    prev1 = 0\n",
    "    prev2 = 1\n",
    "    for i in range(count):\n",
    "        next_num = prev1 + prev2\n",
    "        prev2 = prev1\n",
    "        prev1 = next_num\n",
    "        yield next_num\n",
    "\n",
    "for num in fibonacci(10):\n",
    "    print(num)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "fib = fibonacci(10)\n",
    "print(fib)\n",
    "print(fib.__iter__)\n",
    "print(iter(fib).__next__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `__next__` will return the value yielded\n",
    "### Generators pause execution between calls to `__next__`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def my_generator():\n",
    "    for x in [1, 2, 3]:\n",
    "        print('yielding {}'.format(x))\n",
    "        yield x\n",
    "        print('resume')\n",
    "\n",
    "gen = my_generator()\n",
    "iterator = iter(gen)\n",
    "next(iterator)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "next(iterator)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "next(iterator)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generators raise StopIteration exeption exactly like other iterators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "next(iterator)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Will only read one line at a time, saving memory\n",
    "def lower_words():\n",
    "    for word in open('/usr/share/dict/words'):\n",
    "        if not word.endswith(\"'s\\n\"):\n",
    "            yield word.lower()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Iterables can be infinite"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def fibonacci():\n",
    "    prev1 = 0\n",
    "    prev2 = 1\n",
    "    while True:\n",
    "        next_num = prev1 + prev2\n",
    "        prev2 = prev1\n",
    "        prev1 = next_num\n",
    "        yield next_num\n",
    "        \n",
    "# will never terminate!\n",
    "# for num in fibonacci():\n",
    "#     print(num)\n",
    "\n",
    "import itertools\n",
    "for num in itertools.islice(fibonacci(), 5, 10):\n",
    "    print(num)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# What other useful things can we do with iterables?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# unpacking\n",
    "a, b, c = itertools.islice(fibonacci(), 5, 8)\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# python 3 only\n",
    "a, b, *c = itertools.islice(fibonacci(), 10)\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# passing as *args\n",
    "def print_iter(*a):\n",
    "    print(a)\n",
    "print_iter('1', '3', '5')\n",
    "print_iter(*itertools.islice(fibonacci(), 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# loop over multiple iterables\n",
    "for x in zip(range(1, 10), 'abc', [3, 2, 1]):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# unpack in for loop\n",
    "for x, y in zip(range(10), 'abcdef'):\n",
    "    print('x={} y={}'.format(x, y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.4.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}