Chapter6_Looping_and_Iteration.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "adult-bidder",
   "metadata": {},
   "source": [
    "# Chapter 6 - Looping & Iteration\n",
    "___\n",
    "## 6.1 Writing Pythonic Loops\n",
    "\n",
    "## Summary \n",
    "* Writing C-style loops in Python is considered unpythonic.\n",
    "Avoid managing loop indexes and stop conditions manually if\n",
    "possible.\n",
    "* Python’s for-loops are really “for-each” loops that can iterate\n",
    "directly over items from a container or sequence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "alike-plaintiff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "c\n"
     ]
    }
   ],
   "source": [
    "# C or Java loops\n",
    "\n",
    "my_items = ['a', 'b', 'c']\n",
    "\n",
    "i = 0\n",
    "while i < len(my_items):\n",
    "    print(my_items[i])\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "canadian-reconstruction",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "c\n"
     ]
    }
   ],
   "source": [
    "# Java loops\n",
    "for i in range(len(my_items)):\n",
    "    print(my_items[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "opening-montgomery",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "c\n"
     ]
    }
   ],
   "source": [
    "# for each python loop  \n",
    "for item in my_items:\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "alpha-swing",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 : a\n",
      "1 : b\n",
      "2 : c\n"
     ]
    }
   ],
   "source": [
    "# enumerate \n",
    "for i, item in enumerate(my_items):\n",
    "    print(f'{i} : {item}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "attempted-token",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bob -> bob@example.com\n",
      "Alice -> alice@example.com\n"
     ]
    }
   ],
   "source": [
    "# pythonic looping through dictionary \n",
    "emails = {\n",
    "    'Bob' : 'bob@example.com',\n",
    "    'Alice' : 'alice@example.com', \n",
    "}\n",
    "\n",
    "for name, email in emails.items():\n",
    "    print(f'{name} -> {email}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "quick-windsor",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "5\n",
      "7\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "# C-style loop \n",
    "# for (int i = a; i < n; i += s) {\n",
    "#      ...\n",
    "# }\n",
    "\n",
    "for i in range(1, 10, 2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "deluxe-marsh",
   "metadata": {},
   "source": [
    "___\n",
    "## 6.2 Comprehending Comprehensions\n",
    "\n",
    "*Synactic sugar* for looping in a pythonic manner. One level of\n",
    "nesting for comprehensions is the limit. After that, in most cases it’s better (as in “more readable” and “easier to maintain”) to use for-loops.\n",
    "\n",
    "```Python\n",
    "values = [expression for item in collection]\n",
    "\n",
    "values = []\n",
    "for item in collection:\n",
    "    values.append(expression)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "imposed-newfoundland",
   "metadata": {},
   "source": [
    "### Equivalence with conventional syntax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "molecular-great",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squares = [x*x for x in range(10)]\n",
    "squares"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "functioning-kidney",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squares = []\n",
    "\n",
    "for x in range(10):\n",
    "    squares.append(x*x)\n",
    "\n",
    "squares"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "combined-approval",
   "metadata": {},
   "source": [
    "### conditional logic "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "exclusive-calcium",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 4, 16, 36, 64]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "even_squares = [x*x for x in range(10) if x % 2 == 0]\n",
    "even_squares"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "ecological-remedy",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 4, 16, 36, 64]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "even_squares = []\n",
    "for x in range(10):\n",
    "    if x % 2 == 0:\n",
    "        even_squares.append(x * x)\n",
    "even_squares"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "outstanding-insert",
   "metadata": {},
   "source": [
    "### Set and dictionary comprehensions\n",
    "\n",
    "It should be noted that sets are an unordered collection type. So you get **random** order when you add items to a ```set``` container"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "welcome-syndication",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 1, 4, 9, 16, 25, 36, 49, 64, 81}"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# sets are unordered\n",
    "{x*x for x in range(-9,10)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "noted-links",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# dictionary\n",
    "{x: x*x for x in range(5)}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "composite-duration",
   "metadata": {},
   "source": [
    "___\n",
    "## 6.3 List Slicing Tricks and the sushi operator \n",
    "\n",
    "```Python\n",
    "lst[start:end:stop]\n",
    "```\n",
    "### Summary\n",
    "* The ```:``` “sushi operator” is not only useful for selecting sublists\n",
    "of elements within a list. It can also be used to clear, reverse,\n",
    "and copy lists.\n",
    "* But be careful—this functionality borders on the arcane for\n",
    "many Python developers. Using it might make your code less\n",
    "maintainable for everyone else on your team."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "governing-advance",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst = [x for x in range(6)]\n",
    "lst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "soviet-national",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# start end and step\n",
    "lst[1:3:1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "approximate-section",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# default step size is 1\n",
    "lst[1:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "diverse-remainder",
   "metadata": {},
   "source": [
    "#### Sushi operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "engaged-truth",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 4]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# sushi operator\n",
    "lst[::2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "intermediate-lottery",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 4, 3, 2, 1, 0]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# reversing the list order\n",
    "lst[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "automated-desert",
   "metadata": {},
   "source": [
    "#### clearning contents"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "widespread-action",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# deleting the contents of a list but not the object\n",
    "lst = [1,2,3,4,5]\n",
    "del lst[:]\n",
    "lst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "crucial-mechanism",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# equivalent\n",
    "lst = [1,2,3,4,5]\n",
    "lst.clear()\n",
    "lst"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "written-queue",
   "metadata": {},
   "source": [
    "#### replacing elements without deleting the object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "marked-workstation",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[7, 8, 9]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# replace all elements without creating a new list object\n",
    "original_lst = lst\n",
    "lst[:] = [7, 8, 9]\n",
    "lst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "dependent-caribbean",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[7, 8, 9]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "original_lst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "improving-teaching",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "original_lst is lst"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "leading-profession",
   "metadata": {},
   "source": [
    "#### Shallow copies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "japanese-disposal",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "copied_lst = lst[:]\n",
    "copied_lst is lst"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "suspected-consideration",
   "metadata": {},
   "source": [
    "___\n",
    "## 6.4 Beautiful Iterators\n",
    "\n",
    "### Summary \n",
    "\n",
    "* Iterators provide a sequence interface to Python objects that’s **memory efficient and considered Pythonic**. \n",
    "* To support iteration an object needs to implement the iterator protocol by providing the ```__iter__``` and ```__next__``` dunder\n",
    "methods.\n",
    "* Class-based iterators are only one way to write iterable objects\n",
    "in Python. Also consider generators and generator expressions\n",
    "\n",
    "Python's elegant loop constructs work by making use of the **iterator protocol**. This protocol makes use of the:\n",
    "\n",
    "* ```__iter__``` and ```__next__``` dunder methods in objects"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dried-bibliography",
   "metadata": {},
   "source": [
    "### How do ```for-in``` loops work in python?\n",
    "\n",
    "```Python\n",
    "# syntactic sugar\n",
    "repeater = Repeater('Hello')\n",
    "for item in repeater:\n",
    "    print(item)\n",
    "\n",
    "# equivalent\n",
    "repeater = Repeater('Hello')\n",
    "iterator = repeater.__iter__()\n",
    "while True:\n",
    "    item = iterator.__next__()\n",
    "    print(item)       \n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "subjective-bachelor",
   "metadata": {},
   "source": [
    "### Pythonic for loops under the hood"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "painted-visiting",
   "metadata": {},
   "outputs": [],
   "source": [
    "class BoundedRepeater:\n",
    "    def __init__(self, value, max_repeats):\n",
    "        self.value = value\n",
    "        self.max_repeats = max_repeats\n",
    "        self.count = 0\n",
    "    def __iter__(self):\n",
    "        return self\n",
    "    def __next__(self):\n",
    "        if self.count >= self.max_repeats:\n",
    "            raise StopIteration\n",
    "        self.count += 1\n",
    "        return self.value\n",
    "    \n",
    "    # Python 2 compatibility:\n",
    "    def next(self):\n",
    "        return self.__next__()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "juvenile-stage",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "Hello\n",
      "Hello\n"
     ]
    }
   ],
   "source": [
    "repeater = BoundedRepeater('Hello', 3)\n",
    "for item in repeater:\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "direct-navigation",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "Hello\n",
      "Hello\n"
     ]
    }
   ],
   "source": [
    "# take away the syntactic sugar\n",
    "repeater = BoundedRepeater('Hello', 3)\n",
    "iterator = iter(repeater)\n",
    "\n",
    "while True:\n",
    "    try:\n",
    "        item = next(iterator)\n",
    "    except StopIteration:\n",
    "        break\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "authentic-screening",
   "metadata": {},
   "source": [
    "### Iterator protocol broken down\n",
    "\n",
    "1. In the ```__init__``` method, we link each ```RepeaterIterator``` instance to the ```Repeater``` object that created it. That way we can\n",
    "hold onto the “source” object that’s being iterated over.\n",
    "2. In ```RepeaterIterator.__next__```, we reach back into the\n",
    "“source” ```Repeater``` instance and return the value associated\n",
    "with it.\n",
    "\n",
    "If you’ve ever worked with database cursors, this mental model will\n",
    "seem familiar: We first initialize the cursor and prepare it for reading,\n",
    "and then we can fetch data from it into local variables as needed, one\n",
    "element at a time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "happy-prompt",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Repeater:\n",
    "    def __init__(self, value):\n",
    "        self.value = value\n",
    "    # iter()\n",
    "    def __iter__(self):\n",
    "        return RepeaterIterator(self)\n",
    "    \n",
    "class RepeaterIterator:\n",
    "    def __init__(self, source):\n",
    "        self.source = source\n",
    "    # next()\n",
    "    def __next__(self):\n",
    "        return self.source.value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "global-setup",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "Hello\n",
      "Hello\n",
      "Hello\n",
      "Hello\n",
      "Hello\n",
      "Hello\n",
      "Hello\n",
      "Hello\n",
      "Hello\n"
     ]
    }
   ],
   "source": [
    "repeater = Repeater('Hello')\n",
    "i = 0 \n",
    "\n",
    "while i < 10:\n",
    "    print(next(iter(repeater)))\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "electric-primary",
   "metadata": {},
   "source": [
    "#### Equivalence between dunder methods and facade methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "loose-round",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "repeater = Repeater('Hello')\n",
    "iterator = repeater.__iter__()\n",
    "iterator.__next__()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "imposed-poster",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello'"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(iterator)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "excessive-simple",
   "metadata": {},
   "source": [
    "#### Simpler repeater class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "afraid-novel",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Repeater:\n",
    "    def __init__(self, value):\n",
    "        self.value = value\n",
    "    def __iter__(self):\n",
    "        return self\n",
    "    def __next__(self):\n",
    "        return self.value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "apparent-alarm",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "repeater = Repeater('Hello')\n",
    "repeater.__next__()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "liked-catch",
   "metadata": {},
   "source": [
    "### Iterating with termination conditions\n",
    "\n",
    "Iterators use **exceptions to structure control flow**. To signal the end of iteration, an iterator raises a ```StopIteration``` exception"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "hungry-panama",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list = [1,2,3]\n",
    "iterator = iter(my_list)\n",
    "next(iterator)\n",
    "next(iterator)\n",
    "next(iterator)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "photographic-istanbul",
   "metadata": {},
   "outputs": [
    {
     "ename": "StopIteration",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-37-4ce711c44abc>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mnext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0miterator\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mStopIteration\u001b[0m: "
     ]
    }
   ],
   "source": [
    "next(iterator)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "homeless-michigan",
   "metadata": {},
   "source": [
    "___\n",
    "## 6.5 Generators are simplified iterators\n",
    "\n",
    "Writing class-based iterators requires a lot of boilerplate code. There is a **more efficient** way using ```generators``` and the ```yield``` keyword.\n",
    "\n",
    "You see, when a ```return``` statement is invoked inside a function, it permanently passes control back to the caller of the function. When a ```yield``` is invoked, it also passes control back to the caller of the function—but it only does so temporarily.\n",
    "\n",
    "Whereas a ```return``` statement disposes of a function’s local state, a\n",
    "```yield``` statement **suspends the function and retains its local state**. In practical terms, this means **local variables and the execution state** of\n",
    "the generator function are only **stashed away temporarily** and not thrown out completely. \n",
    "\n",
    "### Summary\n",
    "* Generator functions are syntactic sugar for writing objects that\n",
    "support the iterator protocol. Generators abstract away much\n",
    "of the boilerplate code needed when writing class-based iterators.\n",
    "* The ```yield``` statement allows you to temporarily suspend execution of a generator function and to pass back values from it.\n",
    "* Generators start raising ```StopIteration``` exceptions after control flow leaves the generator function by **any means other than\n",
    "a yield statement.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "olympic-genetics",
   "metadata": {},
   "outputs": [],
   "source": [
    "# classed based approach\n",
    "class Repeater:\n",
    "    def __init__(self, value):\n",
    "        self.value = value\n",
    "    def __iter__(self):\n",
    "        return self\n",
    "    def __next__(self):\n",
    "        return self.value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "resident-syracuse",
   "metadata": {},
   "outputs": [],
   "source": [
    "# pythonic way\n",
    "def repeater(value):\n",
    "    while True:\n",
    "        yield value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "spatial-combination",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hi'"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "re = repeater('hi')\n",
    "next(re)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "comic-donor",
   "metadata": {},
   "source": [
    "Calling a generator function doesn't even run the function. It merely creates and returns a **generator object**. The code in the function only exectues when ```next()``` is called on the object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "collective-proxy",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<generator object repeater at 0x000001EF116E74A0>"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "repeater('Hey')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "combined-diana",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hey'"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "generator_obj = repeater('Hey')\n",
    "next(generator_obj)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "novel-worker",
   "metadata": {},
   "source": [
    "### generators that stop generating "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "addressed-southwest",
   "metadata": {},
   "outputs": [],
   "source": [
    "def repeat_three_times(value):\n",
    "    yield value \n",
    "    yield value \n",
    "    yield value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "intended-helping",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hi\n",
      "hi\n",
      "hi\n"
     ]
    }
   ],
   "source": [
    "rtt = repeat_three_times('hi')\n",
    "for _ in repeat_three_times('hi'):\n",
    "    print(next(rtt))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "seeing-evanescence",
   "metadata": {},
   "outputs": [
    {
     "ename": "StopIteration",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-45-d0c7f5780c20>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mnext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrtt\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mStopIteration\u001b[0m: "
     ]
    }
   ],
   "source": [
    "next(rtt)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "baking-order",
   "metadata": {},
   "source": [
    "### Bounded repeater with generators and yield"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "coated-reasoning",
   "metadata": {},
   "outputs": [],
   "source": [
    "# verbose class based approach\n",
    "class BoundedRepeater:\n",
    "    def __init__(self, value, max_repeats):\n",
    "        self.value = value\n",
    "        self.max_repeats = max_repeats\n",
    "        self.count = 0\n",
    "    def __iter__(self):\n",
    "        return self\n",
    "    def __next__(self):\n",
    "        if self.count >= self.max_repeats:\n",
    "            raise StopIteration\n",
    "        self.count += 1\n",
    "        return self.value\n",
    "    \n",
    "    # Python 2 compatibility:\n",
    "    def next(self):\n",
    "        return self.__next__()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "loving-syndication",
   "metadata": {},
   "outputs": [],
   "source": [
    "# this is a much slimmed down version of the class based approach \n",
    "def bounded_repeater(value, max_repeats):\n",
    "    count = 0\n",
    "    while True:\n",
    "        if count >= max_repeats:\n",
    "            return\n",
    "        count += 1\n",
    "        yield value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "handed-parish",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi\n",
      "Hi\n",
      "Hi\n",
      "Hi\n"
     ]
    }
   ],
   "source": [
    "for x in bounded_repeater('Hi', 4):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "interracial-guidance",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3 lines of code compared to 14\n",
    "def bounded_repeater(value, max_repeats):\n",
    "    for i in range(max_repeats):\n",
    "        yield value"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "reflected-saturn",
   "metadata": {},
   "source": [
    "___\n",
    "## 6.6 Generator expressions\n",
    "\n",
    "Generator functions give you a **shortcut for supporting the iterator protocol** in your own code. Generator expressions give you an even more effective shortcut for writing iterators. With a simple and concise syntax that looks like a list comprehension, you’ll be able to define iterators in a single line of code.\n",
    "\n",
    "```Python\n",
    "genexpr = (expression for item in collection)\n",
    "\n",
    "# equivalent code\n",
    "def generator():\n",
    "    for item in collection:\n",
    "        yield expression\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "elegant-wholesale",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1 line of code vs 3\n",
    "iterator = ('Hello' for i in range(3)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "local-actress",
   "metadata": {},
   "outputs": [],
   "source": [
    "def bounded_repeater(value, max_repeats):\n",
    "    for i in range(max_repeats):\n",
    "        yield value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "nervous-zealand",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "Hello\n",
      "Hello\n"
     ]
    }
   ],
   "source": [
    "for i in iterator:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "russian-generation",
   "metadata": {},
   "source": [
    "### list comprehensions vs generator expressions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "interracial-desktop",
   "metadata": {},
   "outputs": [],
   "source": [
    "listcomp = ['Hello' for i in range(3)]\n",
    "genexpr = ('Hello' for i in range(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "historical-recall",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Hello', 'Hello', 'Hello']"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "listcomp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "social-disaster",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<generator object <genexpr> at 0x000001EF116E79E0>"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "genexpr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "european-nomination",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Hello', 'Hello', 'Hello']"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(genexpr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eleven-deposit",
   "metadata": {},
   "source": [
    "### filtering values \n",
    "\n",
    "```Python \n",
    "def generator():\n",
    "    for item in collection:\n",
    "        if condition:\n",
    "            yield expression\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "consistent-tokyo",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "4\n",
      "16\n",
      "36\n",
      "64\n"
     ]
    }
   ],
   "source": [
    "even_squares = (x*x for x in range(10) if x % 2 == 0)\n",
    "\n",
    "for x in even_squares:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "limited-prague",
   "metadata": {},
   "source": [
    "### In-line Generator Expressions\n",
    "\n",
    "You can create an iterator and consume it straight away"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "short-sight",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bom dia\n",
      "Bom dia\n",
      "Bom dia\n"
     ]
    }
   ],
   "source": [
    "for x in ('Bom dia' for i in range(3)):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "french-knitting",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "90"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum((x*2 for x in range(10)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "diagnostic-egyptian",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "90"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# if the generator is a single argument to a function we can drop the parenthesis\n",
    "sum(x * 2 for x in range(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "secret-dublin",
   "metadata": {},
   "source": [
    "### Generalizing generator expressions\n",
    "We can chain expressions and filtering clauses.\n",
    "**Please don’t write deeply nested generator expressions like that. They\n",
    "can be very difficult to maintain in the long run**\n",
    "\n",
    "```Python \n",
    "(expr for x in xs if cond1\n",
    "      for y in ys if cond2\n",
    "      ...\n",
    "      for z in zs if condN)\n",
    "\n",
    "# equivalent\n",
    "for x in xs:\n",
    "    if cond1:\n",
    "        for y in ys:\n",
    "            if cond2:\n",
    "                ...\n",
    "                    for z in zs:\n",
    "                        if condN:\n",
    "                            yield expr\n",
    "\n",
    "```\n",
    "\n",
    "If you need to use nested generators and complex filtering conditions,\n",
    "it’s usually better to factor out sub-generators (so you can name them)\n",
    "and then to chain them together again at the top level."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "manual-settlement",
   "metadata": {},
   "source": [
    "___\n",
    "## 6.7 Iterator Chains\n",
    "\n",
    "### Summary\n",
    "* Generators can be **chained together** to form highly efficient and\n",
    "maintainable data processing pipelines.\n",
    "* Chained generators **process each element going through the\n",
    "chain individually**.\n",
    "* **Generator expressions** can be used to write concise **pipeline definitions**, but this can **impact readability**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "whole-favor",
   "metadata": {},
   "outputs": [],
   "source": [
    "def integers():\n",
    "    for i in range(1,9):\n",
    "        yield i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "seeing-collection",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8]"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chain = integers()\n",
    "list(chain)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "quiet-brisbane",
   "metadata": {},
   "source": [
    "### Chaining Iterators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "adjacent-appraisal",
   "metadata": {},
   "outputs": [],
   "source": [
    "def squared(seq):\n",
    "    for i in seq:\n",
    "        yield i*i\n",
    "        \n",
    "def negated(seq):\n",
    "    for i in seq:\n",
    "        yield -i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "protective-border",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-1, -4, -9, -16, -25, -36, -49, -64]"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chain = negated(squared(integers()))\n",
    "list(chain)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "consolidated-muscle",
   "metadata": {},
   "source": [
    "The only downside to using generator expressions is that they can’t\n",
    "be configured with function arguments, and you can’t reuse the same\n",
    "generator expression multiple times in the same processing pipeline."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "executed-third",
   "metadata": {},
   "outputs": [],
   "source": [
    "# equivalent expression\n",
    "integers = range(8)\n",
    "squared = (i * i for i in integers)\n",
    "negated = (-i for i in squared)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "planned-cooperation",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<generator object <genexpr> at 0x000001EF116FD9E0>"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "negated"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "official-garden",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, -1, -4, -9, -16, -25, -36, -49]"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(negated)"
   ]
  }
 ],
 "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}