Python_Iterable_Iterator.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "40b69f69",
   "metadata": {},
   "source": [
    "# Iterable & Iterator\n",
    "- An iterable is an object that can be iterated upon. It can return an iterator object with the purpose of traversing         through all the elements of an iterable.\n",
    "- An iterable object implements __iter()__ which is expected to return an iterator object. The iterator object uses the       __next()__ method. Every time next() is called next element in the iterator stream is returned. \n",
    "- When there are no more elements available StopIteration exception is encountered. So any object that has a __next()__       method is called an iterator.\n",
    "- **Python lists, tuples, dictionaries and sets are all examples of iterable objects**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "f35d3d46",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sunil\n",
      "Santosh\n",
      "Ram\n",
      "Ravi\n"
     ]
    },
    {
     "ename": "StopIteration",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[1], line 7\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;28mnext\u001b[39m(list_iter))\n\u001b[0;32m      6\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;28mnext\u001b[39m(list_iter))\n\u001b[1;32m----> 7\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;28;43mnext\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mlist_iter\u001b[49m\u001b[43m)\u001b[49m)\n",
      "\u001b[1;31mStopIteration\u001b[0m: "
     ]
    }
   ],
   "source": [
    "mylist = ['Sunil' , 'Santosh' , 'Ram' , 'Ravi']\n",
    "list_iter = iter(mylist) # Create an iterator object using iter()\n",
    "print(next(list_iter)) # return first element in the iterator stream\n",
    "print(next(list_iter)) # return next element in the iterator stream\n",
    "print(next(list_iter))\n",
    "print(next(list_iter))\n",
    "print(next(list_iter))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "80bba60e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sunil\n",
      "Santosh\n",
      "Ram\n",
      "Ravi\n"
     ]
    }
   ],
   "source": [
    "mylist = ['Sunil' , 'Santosh' , 'Ram' , 'Ravi']\n",
    "list_iter = iter(mylist) # Create an iterator object using iter()\n",
    "print(list_iter.__next__()) # return first element in the iterator stream\n",
    "print(list_iter.__next__()) # return next element in the iterator stream\n",
    "print(list_iter.__next__())\n",
    "print(list_iter.__next__())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e785c346",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sunil\n",
      "Santosh\n",
      "Rahul\n",
      "Ravi\n",
      "Yogesh\n"
     ]
    }
   ],
   "source": [
    "# Looping Through an Iterable (List) using for loop\n",
    "mylist = ['Sunil' , 'Santosh' , 'Rahul' , 'Ravi','Yogesh']\n",
    "list_iter = iter(mylist) # Create an iterator object using iter()\n",
    "for i in list_iter:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "47ba0935",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sunil\n",
      "Santosh\n",
      "Rahul\n",
      "Ravi\n",
      "Yogesh\n"
     ]
    }
   ],
   "source": [
    "# Looping Through an Iterable (tuple) using for loop\n",
    "mytuple = ('Sunil' , 'Santosh' , 'Rahul' , 'Ravi','Yogesh')\n",
    "for i in mytuple:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6a43ff5f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H\n",
      "e\n",
      "l\n",
      "l\n",
      "o\n",
      " \n",
      "P\n",
      "y\n",
      "t\n",
      "h\n",
      "o\n",
      "n\n"
     ]
    }
   ],
   "source": [
    "# Looping Through an Iterable (string) using for loop\n",
    "mystr = \"Hello Python\"\n",
    "for i in mystr:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "ddfbfcbd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H e l l o   P y t h o n "
     ]
    }
   ],
   "source": [
    "# Looping Through an Iterable (string) using for loop\n",
    "mystr = \"Hello Python\"\n",
    "for i in mystr:\n",
    "    print(i,end=\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "630d2a8c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 6 7 8 9 10 "
     ]
    }
   ],
   "source": [
    " #This iterator produces all natural numbers from 1 to 10.\n",
    "class myiter:\n",
    "    def __init__(self):\n",
    "        self.num = 0\n",
    " \n",
    "    def __iter__(self):\n",
    "        self.num = 1\n",
    "        return self\n",
    "    def __next__(self):\n",
    "        if self.num <= 10:\n",
    "            val = self.num\n",
    "            self.num += 1\n",
    "            return val\n",
    "        else:\n",
    "            raise StopIteration\n",
    "mynum = myiter()\n",
    "iter1 = iter(mynum)\n",
    "for i in iter1:\n",
    "    print(i,end=\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "b690c4f3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 3 5 7 9 11 13 15 17 19 "
     ]
    }
   ],
   "source": [
    "# This iterator will produce odd numbers\n",
    "class myiter:\n",
    "    def __init__(self):\n",
    "        self.num = 0\n",
    "    def __iter__(self):\n",
    "        self.num = 1\n",
    "        return self\n",
    "    def __next__(self):\n",
    "        if self.num <= 20 :\n",
    "            val = self.num\n",
    "            self.num += 2\n",
    "            return val\n",
    "        else:\n",
    "            raise StopIteration\n",
    "myodd = myiter()\n",
    "iter1 = iter(myodd)\n",
    "for i in iter1:\n",
    "    print(i,end= \" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "ac7ae7a8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1 2 3 5 8 13 21 34 "
     ]
    }
   ],
   "source": [
    "# This iterator will produce fibonacci numbers\n",
    "class myfibonacci:\n",
    "    def __init__(self):\n",
    "        self.prev = 0\n",
    "        self.cur = 0\n",
    "\n",
    "    def __iter__(self):\n",
    "        self.prev = 0\n",
    "        self.cur = 1\n",
    "        return self\n",
    "    def __next__(self):\n",
    "            if self.cur <= 50:\n",
    "                val = self.cur\n",
    "                self.cur += self.prev\n",
    "                self.prev = val\n",
    "                return val\n",
    "            else:\n",
    "                raise StopIteration\n",
    "myfibo = myfibonacci()\n",
    "iter1 = iter(myfibo)\n",
    "for i in iter1:\n",
    "    print(i,end= \" \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37f7db09",
   "metadata": {},
   "source": [
    "## Generator"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38a0496e",
   "metadata": {},
   "source": [
    "- Python generators are easy way of creating iterators. It generates values one at a time from a given sequence instead of   returning the entire sequence at once.\n",
    "- It is a special type of function which returns an iterator object.\n",
    "- In a generator function, a yield statement is used rather than a return statement.\n",
    "- The generator function cannot include the return keyword. If we include it then it will terminat the execution of the       function.\n",
    "- The difference between yield and return is that once yield returns a value the function is paused and the control is       transferred to the caller.Local variables and their states are remembered between successive calls. In case of the return   statement value is returned and the execution of the function is terminated.\n",
    "- Methods like iter() and next() are implemented automatically in generator function.\n",
    "- Simple generators can be easily created using generator expressions. Generator expressions create anonymous generator       functions like lambda.\n",
    "- The syntax for generator expression is similar to that of a list comprehension but the only difference is square brackets   are replaced with round parentheses. Also list comprehension produces the entire list while the generator expression       produces one item at a time which is more memory efficient than list comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "8ead279a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    },
    {
     "ename": "StopIteration",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[16], line 24\u001b[0m\n\u001b[0;32m     22\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;28mnext\u001b[39m(mygen1))\n\u001b[0;32m     23\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;28mnext\u001b[39m(mygen1)) \u001b[38;5;66;03m#Function will terminate here as all 5 values have been returned\u001b[39;00m\n\u001b[1;32m---> 24\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;28;43mnext\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mmygen1\u001b[49m\u001b[43m)\u001b[49m)\n",
      "\u001b[1;31mStopIteration\u001b[0m: "
     ]
    }
   ],
   "source": [
    "# Simple generator function that will generate numbers from 1 to 5.\n",
    "def mygen():\n",
    "    n = 1\n",
    "    yield n\n",
    "    n += 1\n",
    " \n",
    "    yield n\n",
    "    n += 1\n",
    " \n",
    "    yield n\n",
    "    n += 1\n",
    " \n",
    "    yield n\n",
    "    n += 1\n",
    " \n",
    "    yield n\n",
    "\n",
    "mygen1 = mygen()\n",
    "print(next(mygen1))\n",
    "print(next(mygen1))\n",
    "print(next(mygen1))\n",
    "print(next(mygen1))\n",
    "print(next(mygen1)) #Function will terminate here as all 5 values have been returned\n",
    "print(next(mygen1)) # As function is already terminated, StopIteration is raised.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "9663be7f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 "
     ]
    }
   ],
   "source": [
    "# Simple generator function that will generate natural numbers from 1 to 20.\n",
    "def mygen():\n",
    "    for i in range(1,20):\n",
    "        yield i\n",
    "\n",
    "mygen1 = mygen()\n",
    "for i in mygen1:\n",
    "    print(i,end=' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "c9fc34d2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num = list(mygen()) # Store all values generated by generator function in a list\n",
    "num"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "4689f50d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 4 6 8 10 12 14 16 18 "
     ]
    }
   ],
   "source": [
    "# Simple generator function that will generate even numbers from 1 to 20.\n",
    "def mygen():\n",
    "    for i in range(1,20):\n",
    "        if i%2 == 0:\n",
    "            yield i\n",
    "\n",
    "mygen1 = mygen()\n",
    "for i in mygen1:\n",
    "    print(i,end=' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "7d3c1b3d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 1 2 3 5 8 13 21 34 "
     ]
    }
   ],
   "source": [
    "# This Generator function will generate ten numbers of fibonacci series.\n",
    "def myfibo():\n",
    "    num1 , num2 = 0,1\n",
    "    count = 0\n",
    "    while count < 10:\n",
    "        yield num1\n",
    "        num1,num2 = num2, num1+num2\n",
    "        count+=1\n",
    "fibo = myfibo()\n",
    "for i in fibo:\n",
    "    print(i,end=\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "5874af4d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1 = list(myfibo()) # Store the fibonacci series in a list\n",
    "list1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "77ef110a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list2 = [i**2 for i in range(10)] # List comprehension\n",
    "list2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "0abc24b4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<generator object <genexpr> at 0x00000214FDDA5D60>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gen2 = (i**2 for i in range(10)) # Generator expression\n",
    "gen2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "0860f3b2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "4\n",
      "9\n",
      "16\n"
     ]
    }
   ],
   "source": [
    "print(next(gen2))\n",
    "print(next(gen2))\n",
    "print(next(gen2))\n",
    "print(next(gen2))\n",
    "print(next(gen2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "70b29900",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 "
     ]
    }
   ],
   "source": [
    "gen2 = (i for i in range(40) if i%2 == 0) # Generator expression to generate even\n",
    "gen2\n",
    "for i in gen2:\n",
    "    print(i,end=\" \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d732c36a",
   "metadata": {},
   "source": [
    "# Decorator\n",
    "- Decorator is very powerful and useful tool in Python as it allows us to wrap another function in order to extend the       behavior of wrapped function without permanently modifying it.\n",
    "- In Decorators functions are taken as the argument into another function and then called inside the wrapper function.\n",
    "- Advantages -\n",
    "     - Logging & debugging\n",
    "     - Access control and authentication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "4786494a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Result is :  2\n",
      "Result is :  -2\n"
     ]
    }
   ],
   "source": [
    "def subtract(num1 , num2):\n",
    "    res = num1 - num2\n",
    "    print('Result is : ', res)\n",
    "\n",
    "subtract(4,2)\n",
    "subtract(2,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "95e13208",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Result is :  2\n"
     ]
    }
   ],
   "source": [
    "def sub_decorator(func):\n",
    "    def wrapper(num1,num2):\n",
    "        if num1 < num2:\n",
    "            num1,num2 = num2,num1\n",
    "            return func(num1,num2)\n",
    "    return wrapper\n",
    "\n",
    "sub = sub_decorator(subtract)\n",
    "sub(2,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "3934f542",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Result is :  2\n"
     ]
    }
   ],
   "source": [
    "@sub_decorator # we can use @ syntax for decorating a function in one step\n",
    "def subtract(num1 , num2):\n",
    "    res = num1 - num2\n",
    "    print('Result is : ', res)\n",
    "subtract(2,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "6818aa48",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Linux installation has started \n",
      "\n",
      "Windows installation has started \n",
      "\n",
      "Mac installation has started \n",
      "\n",
      "\n",
      "Please accept terms & conditions\n",
      "Linux installation has started \n",
      "\n",
      "Please accept terms & conditions\n",
      "Windows installation has started \n",
      " \n",
      "Please accept terms & conditions\n",
      "Mac installation has started \n",
      "\n"
     ]
    }
   ],
   "source": [
    "def InstallLinux():\n",
    "    print('Linux installation has started \\n')\n",
    "\n",
    "def InstallWindows():\n",
    "    print('Windows installation has started \\n')\n",
    "\n",
    "def InstallMac():\n",
    "    print('Mac installation has started \\n')\n",
    "\n",
    "InstallLinux()\n",
    "InstallWindows()\n",
    "InstallMac()\n",
    "\n",
    "print()\n",
    "''' Now suppose if we want to print message :- \"Please accept terms & conditions\"\n",
    " then easy way will be to create one decorator function which will present\" '''\n",
    "\n",
    "def InstallDecorator(func):\n",
    "    def wrapper():\n",
    "        print('Please accept terms & conditions')\n",
    "        return func()\n",
    "    return wrapper()\n",
    "@InstallDecorator # we can use @ syntax for decorating a function in one step\n",
    "def InstallLinux():\n",
    "    print('Linux installation has started \\n')\n",
    "\n",
    "@InstallDecorator\n",
    "def InstallWindows():\n",
    "    print('Windows installation has started \\n ')\n",
    "@InstallDecorator\n",
    "def InstallMac():\n",
    "    print('Mac installation has started \\n')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}