iterators-and-iterables.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ac258a4d-5ac8-4f0a-a1e9-c8cc87edc3c4",
   "metadata": {},
   "source": [
    "# Understanding Iterators & Iterables concepts\n",
    "**Course**: _https://app.pluralsight.com/library/courses/core-python-implementing-iterators-iterables-collections/table-of-contents_"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd148cdf-7094-4dc6-9a88-07a51c7f99dc",
   "metadata": {},
   "source": [
    "> **Clip #01**: _https://app.pluralsight.com/course-player?clipId=5ef740cd-8dab-4b24-8c7a-fc0f405de3b0_"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec62b550-9d4a-4293-9372-c19196c6f2b5",
   "metadata": {},
   "source": [
    "## Concepts\n",
    "\n",
    "### Iterable\n",
    "An Iterable is an object which can be traversed to retrieve successive values.\n",
    "\n",
    "### Iterator\n",
    "Iterators are the objects that encapsulates the current position in the Iterable, and provides an interface to retrieve successive values.\n",
    "\n",
    "Iterators decouple how the items are managed and how they are retrieved. \n",
    "\n",
    "Items in the Iterable can be part of a Collection like List, Or they can be generated using a Generator, Or they can be read from a file Or, they can be produced in real time by a sensor."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5c12fd2-9b44-4fbf-91ea-52911673af6f",
   "metadata": {},
   "source": [
    "## Python Interface\n",
    "\n",
    "### `iter()`\n",
    "`iter()` accepts the Iterable object as argument and creates and returns an Iterator.\n",
    "\n",
    "### `next()`\n",
    "`next()` when called on the Iterator returned by `iter()` returns the next value in the Iterable.\n",
    "\n",
    "### `exception StopIteration`\n",
    "`next()` raises an `StopIteration` exception when there no element to read in the Iterable.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "440f8a58-ebcf-4b94-99e6-d53aa214dc8c",
   "metadata": {},
   "source": [
    "## Python Implementation\n",
    "\n",
    "### Iterable protocol\n",
    "Iterables in python are those objects which define the `__iter__()` function. \n",
    "\n",
    "When the Iterable is passed to the `iter()`, the `iter()` actually calls the Iterable's `__iter__()` function.\n",
    "\n",
    "The `__iter__()` must return an Iterator object.\n",
    "\n",
    "### Iterator protocol\n",
    "Iterators, like Iterables implement `__iter__()` method. This means all Iterators are Iterables too. \n",
    "\n",
    "Most Iterators return `self` from the `__iter__()`.\n",
    "\n",
    "Iterators are also required to implement `__next__()` method. This method is called when `next()` is called on the Iterator.\n",
    "\n",
    "The `__next__()` should return the next value from the Iterable traversed by the Iterator. Also the `__next__()` shall raise an exception `StopIteration` if the Iterable is empty."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbde9a7a-6ba1-4908-afad-db6f1fb9aad8",
   "metadata": {},
   "source": [
    "### Examples\n",
    "\n",
    "```\n",
    "_list = ['a', 'zebra', 69.0, math.pi, 42]\n",
    "_dict = {'a': 1, 'h': 8, 'z': 26}\n",
    "_tuple = ('A', 'quick', 'brown', 'fox')\n",
    "```\n",
    "By default, all the collection objects in python viz. Lists, Dicts, Tuples are Iterables."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "180de816-2130-43f0-9eef-c3c5872bac25",
   "metadata": {},
   "source": [
    "\n",
    "---\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96ba0873-c9ae-4052-82e6-aee987b1f737",
   "metadata": {},
   "source": [
    "# Practice"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad31ce07-9110-43b4-928f-cd457081c98b",
   "metadata": {},
   "source": [
    "> **Clip #02**: _https://app.pluralsight.com/course-player?clipId=e9b537ab-b9a3-40df-b535-98b00f8086e1_"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68df32f6-b806-4e07-8b91-fdd2c5118f1c",
   "metadata": {},
   "source": [
    "## Example #1: Creating basic Iterator "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "18d05047-038b-472a-b4f7-cde5d439db87",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Let an infix expression: (x - y) / (w + z)\n",
    "# This expression can be represented as a parser binary tree.\n",
    "# The binary tree can be represented as a python list:\n",
    "\n",
    "expr_tree = ['/', '-', '+', 'x', 'y', 'w', 'z']\n",
    "\n",
    "# Creating Iterator\n",
    "iterator = iter(expr_tree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ff790205-ee9b-4ab3-b3ac-4a6dad33dc1b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Iterating using next()\n",
    "next(iterator)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "b973efac-ead4-4f49-b419-d8c66397291a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'-'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(iterator)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "2ded2cf5-ad78-41a4-8ef1-4f65c3f86e2a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'+'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(iterator)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "064e9622-3819-4f8d-9ef6-f3252d7b5464",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'x'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(iterator)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6c048b12-ab03-4bec-bccf-a98e0c6d7b97",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'y'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(iterator)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "3a7e60c2-307f-4ffd-a564-f4ae249a4f9c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'w'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(iterator)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "6e83066e-3dbc-4e00-aadb-3fde6560284b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'z'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(iterator)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "c7ab86d0-d852-4777-9445-ba4a26e97241",
   "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-9-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": "adfef4b8-4aca-48ef-accc-68115195c0a7",
   "metadata": {},
   "source": [
    "## Example #2: Using the iterator in a Python expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "a34e0a24-9c84-40a9-a7e4-9e0d2339b2b0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/\n",
      "-\n",
      "+\n",
      "x\n",
      "y\n",
      "w\n",
      "z\n"
     ]
    }
   ],
   "source": [
    "# Using the iterator in a Python expression which relies on Iteration Protocol, like 'for' loop\n",
    "iterator = iter(expr_tree)\n",
    "for item in iterator:\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2f04087-0832-4625-b5a0-8920e6ef2b5f",
   "metadata": {},
   "source": [
    "\n",
    "---\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d03f1b4-a364-4f18-a3d1-5c140c28a36b",
   "metadata": {},
   "source": [
    "## Example #3: Creating our own Iterator for LevelOrder Binary Tree Traversal"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a7112c6-50a9-4f0c-8799-87fddb2cbb26",
   "metadata": {},
   "source": [
    "> **Clip #03**: _https://app.pluralsight.com/course-player?clipId=e126f0c5-7bff-4ceb-9eab-08cfcb93c146_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "840b12a6-9a5c-46d3-bcb4-d24cc0eb2ce9",
   "metadata": {},
   "outputs": [],
   "source": [
    "class LevelOrderIterator:\n",
    "    \n",
    "    def __init__(self, seq):\n",
    "\n",
    "        # Local copy of initial sequence\n",
    "        self._sequence = seq\n",
    "        \n",
    "        # Index to keep track/state of current position in Iterable/Sequence\n",
    "        self._idx = 0\n",
    "        \n",
    "    def __iter__(self):\n",
    "        \n",
    "        # By default, Iterators return 'self' from __iter__()\n",
    "        return self\n",
    "        \n",
    "    def __next__(self):\n",
    "        \n",
    "        # If all the elements of Iterable are exhausted, __next__() shall raise 'StopIteration'\n",
    "        if self._idx >= len(self._sequence):\n",
    "            raise StopIteration\n",
    "        \n",
    "        # Get the item at current pos\n",
    "        item = self._sequence[self._idx]\n",
    "        \n",
    "        # Increment the cur pos tracker\n",
    "        self._idx += 1\n",
    "        \n",
    "        return item"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "1a816b70-ba0b-4195-90c7-4483cb65d4f2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prefix Notation of expression: / - + x y w z\n",
      "\n"
     ]
    }
   ],
   "source": [
    "expr_iter = LevelOrderIterator(expr_tree)\n",
    "\n",
    "print(f\"Prefix Notation of expression: {' '.join(expr_iter)}\\n\")    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "b210f061-026a-44f0-bbbb-81fccd7b96bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add a check for perfect binary tree to our class\n",
    "def _is_perfect_binary_tree(seq):\n",
    "    \"\"\"\n",
    "    Check if the length of the seq is 2^n - 1\n",
    "    \"\"\"\n",
    "    \n",
    "    l = len(seq)\n",
    "    return l != 0 and not l & (l + 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "d76b1c43-51b9-4192-a0df-ef7d9949ca0c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0: False,\n",
      " 1: True,\n",
      " 2: False,\n",
      " 3: True,\n",
      " 4: False,\n",
      " 5: False,\n",
      " 6: False,\n",
      " 7: True,\n",
      " 8: False,\n",
      " 9: False,\n",
      " 10: False,\n",
      " 11: False,\n",
      " 12: False,\n",
      " 13: False,\n",
      " 14: False,\n",
      " 15: True,\n",
      " 16: False,\n",
      " 17: False,\n",
      " 18: False,\n",
      " 19: False,\n",
      " 20: False,\n",
      " 21: False,\n",
      " 22: False,\n",
      " 23: False,\n",
      " 24: False,\n",
      " 25: False,\n",
      " 26: False,\n",
      " 27: False,\n",
      " 28: False,\n",
      " 29: False,\n",
      " 30: False,\n",
      " 31: True}\n"
     ]
    }
   ],
   "source": [
    "from pprint import pp\n",
    "\n",
    "pp({i: _is_perfect_binary_tree([j for j in range(i)]) for i in range(32)})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "cfe9b7f2-c8c1-4a97-91df-b1fc0a4fbe85",
   "metadata": {},
   "outputs": [],
   "source": [
    "class LevelOrderIterator:\n",
    "    \n",
    "    def __init__(self, seq):\n",
    "        \n",
    "        # Check if input sequence is perfect binary tree\n",
    "        if not _is_perfect_binary_tree(seq):\n",
    "            raise ValueError(f\"Given sequence is not a perfect binary tree with length 2^n - 1\")\n",
    "\n",
    "        # Local copy of initial sequence\n",
    "        self._sequence = seq\n",
    "        \n",
    "        # Index to keep track/state of current position in Iterable/Sequence\n",
    "        self._idx = 0\n",
    "        \n",
    "    def __iter__(self):\n",
    "        \n",
    "        # By default, Iterators return 'self' from __iter__()\n",
    "        return self\n",
    "        \n",
    "    def __next__(self):\n",
    "        \n",
    "        # If all the elements of Iterable are exhausted, __next__() shall raise 'StopIteration'\n",
    "        if self._idx >= len(self._sequence):\n",
    "            raise StopIteration\n",
    "        \n",
    "        # Get the item at current pos\n",
    "        item = self._sequence[self._idx]\n",
    "        \n",
    "        # Increment the cur pos tracker\n",
    "        self._idx += 1\n",
    "        \n",
    "        return item"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "0adf3caf-51b2-4c35-9aa7-1f36ae1abf8e",
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "Given sequence is not a perfect binary tree with length 2^n - 1",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-16-164c1bca3e9b>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0mimperfect_expr_tree\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;34m'*'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'a'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'+'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'b'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'c'\u001b[0m\u001b[1;33m]\u001b[0m    \u001b[1;31m# a * (b + c)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0mit\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mLevelOrderIterator\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mimperfect_expr_tree\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<ipython-input-15-22fc1408045e>\u001b[0m in \u001b[0;36m__init__\u001b[1;34m(self, seq)\u001b[0m\n\u001b[0;32m      5\u001b[0m         \u001b[1;31m# Check if input sequence is perfect binary tree\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[0m_is_perfect_binary_tree\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mseq\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 7\u001b[1;33m             \u001b[1;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"Given sequence is not a perfect binary tree with length 2^n - 1\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      8\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      9\u001b[0m         \u001b[1;31m# Local copy of initial sequence\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mValueError\u001b[0m: Given sequence is not a perfect binary tree with length 2^n - 1"
     ]
    }
   ],
   "source": [
    "# Test our modified class\n",
    "imperfect_expr_tree = ['*', 'a', '+', 'b', 'c']    # a * (b + c)\n",
    "\n",
    "it = LevelOrderIterator(imperfect_expr_tree)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf8acca4-d5f7-4651-8cdf-4dba67cec82e",
   "metadata": {},
   "source": [
    "\n",
    "---\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79485fc8-f0fe-4eb1-be73-b3a2f801b9a7",
   "metadata": {},
   "source": [
    "## Example #4: Creating Iterator for PreOrderTraversal"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e1c7bde-46ca-4271-b8e2-f57817fdfccd",
   "metadata": {},
   "source": [
    "> **Clip #04**: _https://app.pluralsight.com/course-player?clipId=50cada57-0c03-4a99-a7bf-38066c4cb960_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "5f5b7abd-68f7-40c1-9b6e-27d9bed53df2",
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Optional\n",
    "\n",
    "def _left_child(idx: int) -> int:\n",
    "    return 2 * idx + 1\n",
    "\n",
    "def _right_child(idx: int) -> int:\n",
    "    return 2 * idx + 2\n",
    "\n",
    "def _get_child(seq: list, idx_root: int, *, side: str) -> Optional[int]:\n",
    "    \n",
    "    if side == 'left':\n",
    "        child_idx = _left_child(idx_root)\n",
    "    elif side == 'right':\n",
    "        child_idx = _right_child(idx_root)\n",
    "    \n",
    "    return child_idx if len(seq) > child_idx else None\n",
    "\n",
    "class PreOrderIterator:\n",
    "    \"\"\"\n",
    "    PreOrder Constraints:\n",
    "        - Visit Parent before Child\n",
    "        - Visit Left Child before Right Child\n",
    "    \n",
    "    Algo:\n",
    "        1. Start with a stack with root index as the only element\n",
    "        2. Visit the next node by Popping the stack\n",
    "        3. Push the Right child of the node to the stack (if exists)\n",
    "        4. Push the Left child of the node to the stack (if exists)\n",
    "        5. Repeat from (2) till stack is not empty...\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, seq):\n",
    "        \n",
    "        if not _is_perfect_binary_tree(seq):\n",
    "            raise ValueError(f\"Given sequence is not a perfect binary tree with length 2^n - 1\")            \n",
    "        \n",
    "        self._sequence = seq\n",
    "        self._idxstack = [0]\n",
    "        \n",
    "    def __iter__(self):\n",
    "        return self\n",
    "    \n",
    "    def __next__(self):\n",
    "        \n",
    "        if len(self._idxstack) == 0:\n",
    "            raise StopIteration\n",
    "\n",
    "        idx_item = self._idxstack.pop()\n",
    "\n",
    "        if (child_idx := _get_child(self._sequence, idx_item, side='right')):\n",
    "            self._idxstack.append(child_idx)\n",
    "            \n",
    "        if (child_idx := _get_child(self._sequence, idx_item, side='left')):\n",
    "            self._idxstack.append(child_idx)\n",
    "        \n",
    "        return self._sequence[idx_item]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "24402a4f-b707-4145-b6b3-762f3629f8ed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/ - x y + w z\n"
     ]
    }
   ],
   "source": [
    "# Test Example 1\n",
    "iter_preorder = PreOrderIterator(expr_tree)\n",
    "\n",
    "preorder = \" \".join(iter_preorder)\n",
    "print(preorder)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d416877f-76a6-4cd2-8703-009c343a7fe1",
   "metadata": {
    "tags": []
   },
   "source": [
    "\n",
    "---\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4ecad0a-4dab-43de-8490-07b66ba2e426",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Example #5: Creating Iterator for InOrderTraversal"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fcaac8b8-cd01-4de0-8e47-fae0eee3702a",
   "metadata": {},
   "source": [
    "> **Clip #05**: _https://app.pluralsight.com/course-player?clipId=5707121b-874d-4145-977e-d658010f1632_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "ff6c4779-77d8-4184-befe-54a3d596ae53",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "class InOrderIterator:\n",
    "    \"\"\"\n",
    "    InOrder Constraints:\n",
    "        - Visit Left Child before Parent\n",
    "        - Visit Right Child after Parent\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, seq):\n",
    "        \n",
    "        if not _is_perfect_binary_tree(seq):\n",
    "            raise ValueError(f\"Given sequence is not a perfect binary tree with length 2^n - 1\")            \n",
    "        \n",
    "        self._sequence = seq\n",
    "        self._idxstack = []\n",
    "        self._cur_idx = 0\n",
    "        \n",
    "    def __iter__(self):\n",
    "        return self\n",
    "    \n",
    "    def __next__(self):\n",
    "        \n",
    "        if len(self._idxstack) == 0 and self._cur_idx > len(self._sequence):\n",
    "            raise StopIteration\n",
    "        \n",
    "        while self._cur_idx < len(self._sequence):\n",
    "            self._idxstack.append(self._cur_idx)\n",
    "            self._cur_idx = _left_child(self._cur_idx)\n",
    "            \n",
    "        item_idx = self._idxstack.pop()\n",
    "        self._cur_idx = _right_child(item_idx)\n",
    "    \n",
    "        return self._sequence[item_idx]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "5186ff6f-9ab7-42ca-937a-00abb32da696",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x - y / w + z\n"
     ]
    }
   ],
   "source": [
    "# Test Example 1\n",
    "it_inorder = InOrderIterator(expr_tree)\n",
    "\n",
    "inorder = \" \".join(it_inorder)\n",
    "print(inorder)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a49d8b3a-8d22-4c99-9ddb-64d4ee074ae5",
   "metadata": {
    "tags": []
   },
   "source": [
    "\n",
    "---\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb069d75-2880-44ef-9974-e26b095bcb99",
   "metadata": {},
   "source": [
    "# Filtering Iterators"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6bb311a1-60d8-4a7e-9d0c-9281dc5c89a7",
   "metadata": {},
   "source": [
    "> **Clip #06**: _https://app.pluralsight.com/course-player?clipId=35bfe923-62f2-4099-b8c9-58290cc33d8b_"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bdffe63c-7d34-46cb-a679-bec2dc96f3e4",
   "metadata": {},
   "source": [
    "## Filtering\n",
    "The Iterators can be used/designed in such a way, that they filter out some values from the Iterable. Since Iterators are also Iterables, a Filtering Iterator can be chained with a normal Iterator to filter out some results of the normal Iterator."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40833f33-05d9-4a32-9057-316cc7d6926a",
   "metadata": {},
   "source": [
    "### Example Problem\n",
    "Convert an imperfect binary tree to a perfect binary tree by inserting 'sentinel' values. Then, do any Traversal. Then use a Filtering Iterator to filter out sentinel values from the result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "fb3663f3-fc13-4cbb-9bb2-d0a27621b8fe",
   "metadata": {},
   "outputs": [],
   "source": [
    "# The sentinel...\n",
    "missing = object()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "ce35b4c2-09fa-43d9-8ab1-1234fa8e16f4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# The Filtering Iterator\n",
    "class SkipMissingIterator:\n",
    "    \n",
    "    def __init__(self, seq):\n",
    "        self._iter = iter(seq)\n",
    "    \n",
    "    def __iter__(self):\n",
    "        return self\n",
    "    \n",
    "    def __next__(self):\n",
    "        \n",
    "        # To skip 'missing' values, we keep on looping over them\n",
    "        while True:\n",
    "            # When sequence is exhausted, the 'next' shall raise StopIteration which will be propagated\n",
    "            item = next(self._iter)\n",
    "            if item is not missing:\n",
    "                return item"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "ba21107f-a8cf-402c-a4f4-2698ec82738c",
   "metadata": {},
   "outputs": [],
   "source": [
    "imperfect_bin_tree_prefix_expr = '* a - b c'.split()    # Infix: a * b + c; Children for 'a' are missing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "d217f658-a345-4c40-bcc9-b4a7dd617543",
   "metadata": {},
   "outputs": [],
   "source": [
    "m = missing\n",
    "imperfect_bin_tree = [\n",
    "             '*', \n",
    "       'a',       '-', \n",
    "      m,  m,    'b', 'c'\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "d9fd459b-26f1-4f9f-82e9-2ce4a6cb802f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'* a - b c'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check our Filtering Iterator\n",
    "it = SkipMissingIterator(imperfect_bin_tree)\n",
    "\" \".join(it)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "72964e34-2414-477e-8430-6df43d970e33",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "sequence item 0: expected str instance, object found",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-26-e2395d860494>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0minorder_iter\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mInOrderIterator\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mimperfect_bin_tree\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[1;34m\" \"\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mjoin\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0minorder_iter\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: sequence item 0: expected str instance, object found"
     ]
    }
   ],
   "source": [
    "inorder_iter = InOrderIterator(imperfect_bin_tree)\n",
    "\" \".join(inorder_iter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "0f17751a-00ee-41ee-8d10-3abb7f768f49",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<object at 0x15745acbf80>, 'a', <object at 0x15745acbf80>, '*', 'b', '-', 'c']"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inorder_iter = InOrderIterator(imperfect_bin_tree)\n",
    "list(inorder_iter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "d3c253fa-be39-4950-9beb-2462d8a7d3df",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a * b - c'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Insert sentinel to imperfect bin tree. Do InOrder Traversal. Remove the sentinel using Filtering Iterator\n",
    "\" \".join(SkipMissingIterator(InOrderIterator(imperfect_bin_tree)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5be143f-0a91-4beb-ae91-7f529825344c",
   "metadata": {
    "tags": []
   },
   "source": [
    "\n",
    "---\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d64757ff-9da8-4beb-8777-5da27a94c95a",
   "metadata": {},
   "source": [
    "# Transforming Iterators"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7aa1fbbf-061c-4b6f-ae7e-a01eb0c32fec",
   "metadata": {},
   "source": [
    "> **Clip #07**: _https://app.pluralsight.com/course-player?clipId=895c2811-29b7-4cbd-9929-69e97aca63b5_"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "881e9728-9faf-4551-bb6a-2840363c895a",
   "metadata": {},
   "source": [
    "## Transformation\n",
    "The Iterators can change the read values before returning them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "bc3cb7bd-8dcb-4ef2-9adb-79154852ef90",
   "metadata": {},
   "outputs": [],
   "source": [
    "grades = {\n",
    "    90: 'A+',\n",
    "    80: 'A',\n",
    "    70: 'B',\n",
    "    60: 'C',\n",
    "    50: 'D',\n",
    "    33: 'E',\n",
    "    0: 'F'\n",
    "}\n",
    "\n",
    "class GradingIterator:\n",
    "    \n",
    "    def __init__(self, marks: list, *, grade_map: dict):\n",
    "        self._marks = marks\n",
    "        self._idx = 0\n",
    "        self._grade_map = grade_map\n",
    "        self._grade_limits = sorted(list(self._grade_map.keys()), reverse=True)\n",
    "        \n",
    "    def __iter__(self):\n",
    "        return self\n",
    "    \n",
    "    def __next__(self):\n",
    "        if self._idx >= len(self._marks):\n",
    "            raise StopIteration\n",
    "            \n",
    "        cur_marks = self._marks[self._idx]\n",
    "        self._idx += 1\n",
    "        \n",
    "        grade = '-'\n",
    "        for key in self._grade_limits:\n",
    "            if cur_marks >= key:\n",
    "                grade = self._grade_map[key]\n",
    "                break\n",
    "        \n",
    "        return grade"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "89d95f9e-e50a-4ca4-8233-66ce2c5495ce",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['F', 'A', 'D', 'E', 'F', 'F', 'A+', 'D', 'D', 'C']"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "marks = [25, 89, 56, 40, 21, 3, 96, 50, 58, 63]\n",
    "\n",
    "grader = GradingIterator(marks, grade_map=grades)\n",
    "\n",
    "list(grader)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c598fd9-6d08-4ebf-b959-177237518b78",
   "metadata": {},
   "source": [
    "## `itertools`\n",
    "The **[itertools](https://docs.python.org/3/library/itertools.html)** module of Python has inbuilt tools to generate basic iterators, like:\n",
    "\n",
    "1. `count(start, [step])` : Generates an infinite arithmetic progression starting at `start` and incrementing by `step`. \n",
    "2. `chain(*iterables)` : Generates elements from a concatenated sequence of all `iterables` in the order passed.\n",
    "\n",
    "... and more ...\n",
    "\n",
    "All `itertools` methods return an iterator, which can be used to generate the values."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2130e3c-2143-4cb3-9795-79e816e8b9f9",
   "metadata": {
    "tags": []
   },
   "source": [
    "\n",
    "---\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c69df97a-62b8-416f-8345-d65ca9d0c313",
   "metadata": {},
   "source": [
    "# `Iterables`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "869a1d6c-8a0b-4871-9435-7d5ebd0a9fa1",
   "metadata": {},
   "source": [
    "> **Clip #08**: _https://app.pluralsight.com/course-player?clipId=ba04e450-7031-4478-8d70-6ec7b9b46a1e_"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca9a8c4f-18c3-4f61-aca4-bcc355411471",
   "metadata": {},
   "source": [
    "Let's walk through some examples of Iterables now..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "c32a5f33-07a6-4417-bcaf-95118e752943",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create an Iterable which returns an Inorder Traversal of a perfect (binary tree) arithmetic expresssion provided in prefix-notation\n",
    "class PerfectBinaryTree:\n",
    "    \n",
    "    def __init__(self, expr):\n",
    "        self._expr = tuple(expr)\n",
    "        if not _is_perfect_binary_tree(self._expr):\n",
    "            raise ValueError(f\"Given sequence is not a perfect binary tree with length 2^n - 1\")\n",
    "            \n",
    "    def __iter__(self):\n",
    "        return SkipMissingIterator(InOrderIterator(self._expr))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "14eda403-15d0-4d58-a6fe-3ba6a6ed89c2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a / b - c + d * x - y % z * w'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example1 = \"* - % / + - * a b c d x y z w\".split()\n",
    "\" \".join(PerfectBinaryTree(example1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "3643f0e6-36ad-418e-a8f6-a0ce976bd958",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a / b + x % y * v - w'"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m = missing\n",
    "example2 = [\n",
    "                          \"*\",\n",
    "    \n",
    "               \"+\",                   \"-\",\n",
    "\n",
    "        \"/\",         \"%\",        \"v\",       \"w\",\n",
    "\n",
    "    \"a\",   \"b\",   \"x\",  \"y\",   m,    m,   m,    m\n",
    "]\n",
    "\" \".join(PerfectBinaryTree(example2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0f6ee28-ca4b-4fd5-8162-828aebb58412",
   "metadata": {
    "tags": []
   },
   "source": [
    "\n",
    "---\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9086a470-a4d6-4a27-bca7-2d1b144dbb6d",
   "metadata": {},
   "source": [
    "# Alternative `Iterable` Protocol"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c97aee46-6779-4fe5-a58a-086a9d988491",
   "metadata": {},
   "source": [
    "> **Clip #09**: _https://app.pluralsight.com/course-player?clipId=86969893-b8a8-4799-8779-09aae16fdb51_"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7eebd9c-7747-4660-821e-0f1d05300bfc",
   "metadata": {},
   "source": [
    "As we saw earlier, we need to define a special function `__iter__()` as an object method if we want to use it as an `Iterable`. There is an alternate to it !!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "705ecd0a-63da-4b21-a4f6-555407fcc5a6",
   "metadata": {},
   "source": [
    "## `__getitem__()`\n",
    "\n",
    "* Usually, `__getitem__()` is used to implement **indexing**, i.e. `__getitem__()` is called when we access a specific value by indexing it, e.g. `mylist[5]`, `mytuple[89]`, `myobject[-2]`\n",
    "* When we define `__getitem__()` and skip `__iter__()`, then the call to `iter()` with our `Iterable` object automatically defines the `Iterator` for us.\n",
    "* This `Iterator` can be used in `next()` to retrieve the values returned by `__getitem__()`.\n",
    "* The `__getitem__()` accepts an `int` argument **'index'**, which in the `Iterable` protocol need not be passed, as it is internally assumed, starting from `0` at first `next()` call to the Iterator. \n",
    "* This also means that our `__getitem__()` implementation must support integer index starting from `0`.\n",
    "* The `__getitem__()` needs to raise `IndexError` exception to indicate end of values in the `Iterable`. This `IndexError` is automatically handled by the `next()` call.\n",
    "\n",
    "NOTE: If both `__iter__()` and `__getitem__()` are implemented, then `__iter__()` shall be invoked by `iter()` to get the `Iterator` and the returned `Iterator` must implement `__next__()`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "447eed38-964b-4f77-a5e3-e3ee64ff2e93",
   "metadata": {},
   "source": [
    "### Example #1: \n",
    "\n",
    "#### Define a `RationalRange` Iterable which can return a list of rational numbers between given `start` and `stop` numbers at the separation of `steps`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "80acbadb-c5a3-4e61-977f-bf7821843228",
   "metadata": {},
   "outputs": [],
   "source": [
    "from fractions import Fraction\n",
    "\n",
    "class RationalRange:\n",
    "    \n",
    "    def __init__(self, start, stop, /, steps=1):\n",
    "        assert steps == int(steps), \"ValueError: `steps` must be an integer\"\n",
    "        assert steps > 0, \"ValueError: `steps` must be a +ve integer\"\n",
    "        \n",
    "        self._start = Fraction(start)\n",
    "        self._n_steps = steps\n",
    "        self._step = Fraction(stop - start, steps)\n",
    "    \n",
    "    def __getitem__(self, idx):\n",
    "        if not 0 <= idx < self._n_steps :\n",
    "            raise IndexError\n",
    "            \n",
    "        return self._start + idx * self._step"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "9b6ce019-34fb-43a0-8d5e-ebe67b4e108f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_rational_iter():\n",
    "    from itertools import accumulate\n",
    "    \n",
    "    rational_obj = RationalRange(10, 20, 15)\n",
    "    rational_iter = iter(rational_obj)\n",
    "    \n",
    "    print(\"Test 1: Using 'next()' to iterate...\")\n",
    "    print(next(rational_iter))\n",
    "    print(next(rational_iter))\n",
    "    print(next(rational_iter))\n",
    "    print(\"...\")\n",
    "    print()\n",
    "    \n",
    "    print(\"Test 2: Using 'for' loop to get values\")\n",
    "    print(\"[\", end=\"\")\n",
    "    for i in iter(rational_obj):\n",
    "        print(i, end=\", \")\n",
    "    print(\"\\b\\b]\")\n",
    "    print()\n",
    "    \n",
    "    print(\"Test 3: Using list comprehension to get values\")\n",
    "    vals = [round(float(x), 2) for x in iter(rational_obj)]\n",
    "    print(vals)\n",
    "    print()\n",
    "    \n",
    "    print(\"Test 4: Using 'accumulate' to create some series\")\n",
    "    f = accumulate(iter(rational_obj), func=lambda total, x: total + x * x, initial=0)\n",
    "    print(f\"{accumulate(iter(rational_obj), func=lambda x: x * x) = }\")\n",
    "    print(list(f)) \n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "415aa47b-a2b8-40d2-a80f-29a711a9aa53",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test 1: Using 'next()' to iterate...\n",
      "10\n",
      "32/3\n",
      "34/3\n",
      "...\n",
      "\n",
      "Test 2: Using 'for' loop to get values\n",
      "[10, 32/3, 34/3, 12, 38/3, 40/3, 14, 44/3, 46/3, 16, 50/3, 52/3, 18, 56/3, 58/3]\n",
      "\n",
      "Test 3: Using list comprehension to get values\n",
      "[10.0, 10.67, 11.33, 12.0, 12.67, 13.33, 14.0, 14.67, 15.33, 16.0, 16.67, 17.33, 18.0, 18.67, 19.33]\n",
      "\n",
      "Test 4: Using 'accumulate' to create some series\n",
      "accumulate(iter(rational_obj), func=lambda x: x * x) = <itertools.accumulate object at 0x0000015746A213C0>\n",
      "[0, Fraction(100, 1), Fraction(1924, 9), Fraction(3080, 9), Fraction(4376, 9), Fraction(1940, 3), Fraction(7420, 9), Fraction(9184, 9), Fraction(11120, 9), Fraction(4412, 3), Fraction(5180, 3), Fraction(18040, 9), Fraction(20744, 9), Fraction(23660, 9), Fraction(8932, 3), Fraction(30160, 9)]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "test_rational_iter()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ef3e29c-7951-46ce-a7ed-40d3d58159aa",
   "metadata": {},
   "source": [
    "### Example #2: \n",
    "\n",
    "#### Define `__iter__()` and `__getitem__`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "fba57841-f781-4460-87f3-abf2a2e13d8a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import functools\n",
    "\n",
    "class AccumulatorIterator:\n",
    "    \n",
    "    def __init__(self, seq):\n",
    "        self._seq = seq\n",
    "        self._idx = 0\n",
    "        self._sum = 0\n",
    "    \n",
    "    def __iter__(self):\n",
    "        return self\n",
    "    \n",
    "    def __next__(self):\n",
    "        if self._idx >= len(self._seq):\n",
    "            raise StopIteration\n",
    "            \n",
    "        item = self._seq[self._idx]\n",
    "        self._idx += 1\n",
    "        self._sum += item\n",
    "        \n",
    "        return self._sum\n",
    "    \n",
    "class RangeIterable:\n",
    "    \n",
    "    def __init__(self, upto):\n",
    "        assert upto == int(upto) and upto >= 1, f\"ValueError: upto = {upto} must be a +ve integer\"\n",
    "        self._seq = list(range(1, upto + 1))\n",
    "        \n",
    "    def __iter__(self):\n",
    "        return AccumulatorIterator(self._seq)\n",
    "    \n",
    "    def __getitem__(self, idx):\n",
    "        if not 0 <= idx < len(self._seq):\n",
    "            raise IndexError\n",
    "            \n",
    "        return functools.reduce(lambda sum, x: sum + x, self._seq[:idx + 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "a29620fa-9939-45f0-8e13-e681bf3398c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "range_obj = RangeIterable(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "6c640dcd-0ded-43d9-8746-44f63dd9f708",
   "metadata": {},
   "outputs": [],
   "source": [
    "range_iter = iter(range_obj)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "e8b9833e-bab8-40fa-b89c-f8acb4765dd5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.AccumulatorIterator at 0x15746a30a60>"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# An object of type rturned by __iter__(), since it is defined...\n",
    "range_iter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "16b3c0bc-bea8-4a68-97d2-0eba0fb7b08d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Able to subscript.. due to __getitem__()\n",
    "range_obj[8]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a147e77-44ec-4c0c-bb10-76710c608876",
   "metadata": {
    "tags": []
   },
   "source": [
    "\n",
    "---\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a53aa13-b7d6-48dd-b294-eac2427a9333",
   "metadata": {},
   "source": [
    "# Extended form of `iter()`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1126a64-c9df-4bd1-b4b2-94eedebedd4c",
   "metadata": {},
   "source": [
    "> **Clip #10**: _https://app.pluralsight.com/course-player?clipId=18ebd633-cbdd-412d-be53-5b407b4dbd9b_"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f863babb-735b-48df-828f-fc6684020c5e",
   "metadata": {},
   "source": [
    "Usually, the `iter()` takes one argument, the `Iterable`. However, it has one more signature/form !!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79246e56-ff84-4ebb-b1db-80504bb618a0",
   "metadata": {},
   "source": [
    "## `iter(callable, sentinel)`\n",
    "This form of `iter()` accepts:\n",
    "\n",
    "* `callable`: Any callable object, which accepts zero aruments and returns some value.\n",
    "* `sentinel`: A value which when equals the value produced by `callable`, terminates the Iteration, i.e. raises `StopIteration`\n",
    "\n",
    "Using this form, the subsequent calls to `next()` call the `callable` until `sentinel` value is returned.\n",
    "\n",
    "This form is most desirable to produce infinite sequences, like simulating sensor data, printing current time, etc."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d6c2f97-4858-44db-bf3e-79693285ea86",
   "metadata": {},
   "source": [
    "### Example #1\n",
    "\n",
    "#### Read disk usage and print indefinitely"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "405edaf9-2e67-434a-881b-7797e5e5015e",
   "metadata": {},
   "outputs": [],
   "source": [
    "from shutil import disk_usage\n",
    "from os.path import curdir, abspath\n",
    "from datetime import datetime as dt\n",
    "from time import sleep\n",
    "\n",
    "def get_du():\n",
    "    cwd = abspath(curdir)\n",
    "    return disk_usage(cwd).free\n",
    "\n",
    "def display_disk_usage():\n",
    "    du_iter = iter(get_du, None)\n",
    "    time_iter = iter(dt.now, None)    \n",
    "    for du, t in zip(du_iter, time_iter):\n",
    "        print(f\"{t}: {du = }\")\n",
    "        sleep(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "d61074ad-992f-4236-a381-469f6cb32f44",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-06-20 21:04:16.869318: du = 46456463360\n",
      "2021-06-20 21:04:17.870977: du = 46456463360\n",
      "2021-06-20 21:04:18.876653: du = 46456463360\n",
      "2021-06-20 21:04:19.890002: du = 46456463360\n",
      "2021-06-20 21:04:20.891113: du = 46456463360\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-43-eb2f1a6c2926>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# NOTE: This will print indefinitely, use 'Interrupt Kernel', shortcut: I, I to stop it.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mdisplay_disk_usage\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<ipython-input-42-fe65424935dd>\u001b[0m in \u001b[0;36mdisplay_disk_usage\u001b[1;34m()\u001b[0m\n\u001b[0;32m     13\u001b[0m     \u001b[1;32mfor\u001b[0m \u001b[0mdu\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mt\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mzip\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdu_iter\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtime_iter\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     14\u001b[0m         \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"{t}: {du = }\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 15\u001b[1;33m         \u001b[0msleep\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "# NOTE: This will print indefinitely, use 'Interrupt Kernel', shortcut: I, I to stop it.\n",
    "display_disk_usage()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6be1e436-a761-4d85-80a6-851115e639ae",
   "metadata": {
    "tags": []
   },
   "source": [
    "\n",
    "---\n"
   ]
  }
 ],
 "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.9.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}