Python_Essential_Part_1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Advance Python By Example Part - 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Welcome to the Python: More to the Basics series Part - 1. \n",
    "In this series, I am going to talk about Python Advance concepts which are very important to understand. Without understanding these concept, it's very difficult to use this in Real world more importantly in the Data Science world."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hence, let's start with the first cocept => Iterators, Generators and Decorators in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Iterators are simply python objects which can be iterated upon and can be used to get element one by one from any collection. Iterators are everywhere in python for example for loop, generators and comprehensions etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you create a simple for loop in python then during execution that get converted into itertators."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can implement iterators using 2 special methods in python\n",
    "1. _ _iter _ _ or iter()\n",
    "2. _ _next_ _ or next()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### How to create an iterator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "list = [1,2,3,4]\n",
    "my_iter = iter(list)    # THIS WILL CREATE my_iter AS AN ITERATOR OBJECT WHICH WE CAN ITERATE UPON\n",
    "\n",
    "print(next(my_iter))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get the next element from the iterator, use next() function again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "print(next(my_iter))\n",
    "print(next(my_iter))\n",
    "print(next(my_iter))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What happens if you exxecute next() again but there is no next element. You guess it right, it will throw an exception."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "ename": "StopIteration",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-9-94a4229f6542>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmy_iter\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mStopIteration\u001b[0m: "
     ]
    }
   ],
   "source": [
    "next(my_iter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To handle the exception internally, python creates iterator with try except block."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Implementation of for loop with Iterators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "for loop completed\n"
     ]
    }
   ],
   "source": [
    "my_list = [1,2,3,4]\n",
    "for element in my_list:\n",
    "    pass\n",
    "print(\"for loop completed\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "for loop implementation completed with iterators\n"
     ]
    }
   ],
   "source": [
    "#Implementaion using Iterators\n",
    "my_list=[1,2,3,4]\n",
    "iter_obj = iter(my_list)\n",
    "while True:\n",
    "    try:\n",
    "        element = next(iter_obj)\n",
    "        pass        \n",
    "    except StopIteration:\n",
    "        break\n",
    "            \n",
    "print(\"for loop implementation completed with iterators\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above example we saw that how a for loop gets converted into iterators and how iterators work internally."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generators\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we have seen in Itertaors, there is a lot of overhead to create an Iterator - implement iter() and next () functions and then handle StopIternation exception. To overcome this problem, python has provided another powerful and useful soution i.e. Generators."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generators are like a normal function in Python however there are 2 differences between normal function and Generators.\n",
    "1. Generators uses yield keyword to return any value.\n",
    "2. There can be more than 1 yield keyword in a Generator unlike normal Python Function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's understand Genertaor using one exmaple for revering a String."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generator created\n"
     ]
    }
   ],
   "source": [
    "#Create a Generator\n",
    "def my_generator(input_str):\n",
    "    length_of_string = len(input_str)\n",
    "    for i in range(length_of_string-1,-1,-1): # This will take index as 5, 4, 3, 2, 1, 0 for the input string \"Python\"\n",
    "        yield input_str[i]\n",
    "print(\"Generator created\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "N\n"
     ]
    }
   ],
   "source": [
    "a = my_generator(\"PYTHON\")\n",
    "print(next(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O\n"
     ]
    }
   ],
   "source": [
    "print(next(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H\n",
      "T\n",
      "Y\n",
      "P\n"
     ]
    }
   ],
   "source": [
    "print(next(a))\n",
    "print(next(a))\n",
    "print(next(a))\n",
    "print(next(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we have seen in this example, Generators also returns element one by one on demand. This is useful when you need to keep track of index as well as the actual element from any collection.\n",
    "\n",
    "Now Let's see what is Generator Expression."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Generator Expression"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generator expression is similar to List Comrehension. We can create a Generator Expression as below"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Displaying first element 1\n",
      "Displaying second element 9\n",
      "Displaying third element 25\n",
      "Displaying fourth element 49\n"
     ]
    }
   ],
   "source": [
    "#Create a Generator Expression\n",
    "my_generator_expr = (item ** 2 for item in {1,3,5,7})\n",
    "\n",
    "#Dispaly first element of the Generator Expression\n",
    "print(\"Displaying first element {}\".format(next(my_generator_expr)))\n",
    "\n",
    "#Dispaly next elements of the Generator Expression\n",
    "\n",
    "print(\"Displaying second element {}\".format(next(my_generator_expr)))\n",
    "print(\"Displaying third element {}\".format(next(my_generator_expr)))\n",
    "print(\"Displaying fourth element {}\".format(next(my_generator_expr)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generator Expression will also throw an exception if you are try to get next element but it doesn't exist."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "ename": "StopIteration",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-33-d21af03a7f1b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Displaying fourth element {}\"\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmy_generator_expr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mStopIteration\u001b[0m: "
     ]
    }
   ],
   "source": [
    "print(\"Displaying fourth element {}\".format(next(my_generator_expr)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Decorators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has an interesting feature called Decoratos to add functionality to an existing code. It takes function as an input, add some functionality and then returns it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's understand Decorators using one example. You know that when a number is divided by zero, it throws an error DivisionByZero as this is not possible. One way to handle this using try catch exception, another way can be Decorators."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "ename": "ZeroDivisionError",
     "evalue": "division by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-39-228a187cdc96>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      2\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mdivide\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mZeroDivisionError\u001b[0m: division by zero"
     ]
    }
   ],
   "source": [
    "def divide(a,b):\n",
    "    return a/b\n",
    "    \n",
    "divide(3/0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You want to handle this gracefully and don't want your program to fail abruptly. Let's solve this using Decorators."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Performing smart divide opertaion 3 by 0\n",
      "DivisionByZero not possible. Hence will not perform divide operation\n"
     ]
    }
   ],
   "source": [
    "# Create a Decorator function which will take funxtion as an Input.\n",
    "\n",
    "def smart_divide(func):\n",
    "    def inner(a,b):\n",
    "        print(\"Performing smart divide opertaion {} by {}\".format(a,b))\n",
    "        if (b==0):\n",
    "            print(\"DivisionByZero not possible. Hence will not perform divide operation\")\n",
    "            return\n",
    "        return func(a,b)           \n",
    "    return inner\n",
    "\n",
    "@smart_divide\n",
    "def divide(a,b):\n",
    "    return a/b\n",
    "\n",
    "divide(3, 0)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see that program ended gracefully and performed smart divide opertaion.\n",
    "Using @ annonation followed by decorator function you make sure that you are applying decorator function on another function. There is another way of doing that without using annotation @ -"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Performing smart divide opertaion 3 by 0\n",
      "DivisionByZero not possible. Hence will not perform divide operation\n"
     ]
    }
   ],
   "source": [
    "def divide_2(a,b):\n",
    "    return a/b\n",
    "\n",
    "div = smart_divide(divide_2)\n",
    "div(3,0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### This concludes the first part of the series. In the next part we'll look into more advance concepts in python using examples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}