OOP.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "OOP.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "### Object-oriented Concepts\n",
        "Everything in Python is an object. For example, int, str, float, list, tuple, dictionary etc. are all objects. Let's try to understand what objects are."
      ],
      "metadata": {
        "id": "idTidm7glHV-"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Class and objects\n",
        "\n",
        "A Class is like a blueprint for building objects. Once you have a blueprint, you can make any number of copies of the blueprint. The 'copies' of the blueprint are called objects.\n",
        "\n",
        "Let's create a class called `Student`"
      ],
      "metadata": {
        "id": "mbomzv4KldVW"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FPnSexMklBnK"
      },
      "outputs": [],
      "source": [
        "class Student:\n",
        "  pass # pass means do nothing"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now, lets create 'copies' known as objects or instances of the class `Student`."
      ],
      "metadata": {
        "id": "Kv1xGKolllSt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "student1 = Student() # instance of the class Student\n",
        "student2 = Student() # another instance of the class Student\n",
        "print(type(student1)) # the type of student1 is Class Student"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jlcxWihElhPN",
        "outputId": "87e97282-a598-4c4a-9e43-c91ae648d527"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class '__main__.Student'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Let us see the location in memory where the object instances are created. We use the function `id()` for that."
      ],
      "metadata": {
        "id": "iUG_3_Kalt7t"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(id(student1))\n",
        "print(id(student2))\n",
        "student1 is student2"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kspzPYg0lqbF",
        "outputId": "b50fc959-687f-4ea9-9f7c-0a423d178e5e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "140508500160784\n",
            "140508500160720\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "student3 = student1\n",
        "student3 is student1"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JEHXAyaJlydV",
        "outputId": "0f4f6810-52dc-4760-dd6d-0c0024a2e997"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "As you can see above, the location in memory of the two instances are different, meaning that they are two different objects. This is verified by the keyword `is`. Please note that is keyword returns True if the variables on the left and the right side of the is operator are pointing to the same object. If they are pointing to different objects, then it returns `False`.\n",
        "\n",
        "In the code below, we are assigning the object instance `student1` to the variable `student3`. In this case, we see that the location in memory of both `student1` and `student3` are the same, as verified by the `is` keyword.\n",
        "\n",
        "This means that when we assign an object to a variable, the variable points to the object."
      ],
      "metadata": {
        "id": "PBDqYY9sl3P9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "student3 = student1\n",
        "print(id(student1))\n",
        "print(id(student3))\n",
        "student1 is student3"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6zW4arG8l0rN",
        "outputId": "428e9c40-59c2-48f2-d572-b5432671bac3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "140508500160784\n",
            "140508500160784\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Class/instance variables and methods\n",
        "A `class` can have properties and methods. Properties hold data values and methods do some action. Normally, properties are nouns and methods are verbs.\n",
        "\n",
        "Python class properties can be in the form of\n",
        "\n",
        "* class variables\n",
        "* instance variables\n",
        "\n",
        "Class variables are common to all the instances, that is they are accessible from any instance of the class. Class variables are created when the class is defined.\n",
        "\n",
        "Instance variables, on the other hand, are specific to instances. The values of instance variables may differ from instance to instance.\n",
        "\n",
        "Here is an example of a class variable."
      ],
      "metadata": {
        "id": "8yvSLmV_mrUG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Student:\n",
        "  # class variable\n",
        "  school = \"School of Data Science\""
      ],
      "metadata": {
        "id": "w-hnFCaOmoxW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Below, we create two instances of `Student` class, and we print the value of `school` variable on both instances. We find that both print statements give us the same result, since we are printing the class variable."
      ],
      "metadata": {
        "id": "-umcm5PbnKZN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "student1 = Student()\n",
        "student2 = Student()\n",
        "print(student1.school)\n",
        "print(student2.school)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "K80Un7WXnI0u",
        "outputId": "602c5269-d1b6-48fd-a846-331ece166b03"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "School of Data Science\n",
            "School of Data Science\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Let's now look at examples of instance variables.\n",
        "\n",
        "Instance variables are normally defined inside the `__init__` method.\n",
        "\n",
        "Let's first understand what 'methods' are. Basically, 'methods' in object-oriented programming are functions defined witnin a class. Just like a normal function, they normally take in some input in the form of arguments, do some processing on the inputs and return the result.\n",
        "\n",
        "The `__init__` method in Python is a special method, also called a 'constructor', which gets invoked (called) automatically when an instance of that class in created (instantiated).\n",
        "\n",
        "There are 3 types of methods in Python.\n",
        "\n",
        "* instance methods\n",
        "* class methods\n",
        "* static methods\n",
        "\n",
        "The most widely used methods are instance methods. Instance methods are defined with self as the first parameter.\n",
        "\n",
        "In the code below, we have defined the `__init__` method with 3 parameters. Inside the`__init__` method, we have defined two instance variables - `self.name` and `self.level`. Instance variables start with self.\n",
        "\n",
        "Please note that instance variables `self.nam`e and `self.level` may have different values depending on the instance they are invoked on, unlike class variables which have the same value regardless of the instance they are invoked on.\n",
        "\n",
        "Below, we define the `Student` class with the constructor defined."
      ],
      "metadata": {
        "id": "UtyUQKOnnUzW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Student:\n",
        "  #constructor\n",
        "  def __init__(self, name, level):\n",
        "    # instance variables\n",
        "    self.name = name\n",
        "    self.level = level"
      ],
      "metadata": {
        "id": "8necRi74nROG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now, we instantiate two instances of the class. Please note that we are passing two arguments, which are passed to the constructor (`__init__` method). Those two values passed as arguments are what the instance variables inside the constructor are initialized to when creating the instance."
      ],
      "metadata": {
        "id": "b6ZeeQyenx9v"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "student1 = Student(\"Katie Holmes\", 1)\n",
        "student2 = Student(\"Mike Tyson\", 3)"
      ],
      "metadata": {
        "id": "6wCZa2qyn2WF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Let's verify!"
      ],
      "metadata": {
        "id": "c66eDfuBn4w3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(student1.name)\n",
        "print(student1.level)\n",
        "print(student2.name)\n",
        "print(student2.level)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "apHpqCsFn2-N",
        "outputId": "264f0881-a3ca-42fe-d307-77d4a132e148"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Katie Holmes\n",
            "1\n",
            "Mike Tyson\n",
            "3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We see that when we printed the instance variables we got the values unique to the instances. Also, we see that the instance variables were initialized with the values passed during the instantiation."
      ],
      "metadata": {
        "id": "6x0uX1dqn-je"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### `__str__ method`\n",
        "The `__str__` method is a special method in Python which gets invoked when the object is printed."
      ],
      "metadata": {
        "id": "MPaxuGQkoCIW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Student:\n",
        "  #constructor\n",
        "  def __init__(self, name, level):\n",
        "    self.name = name\n",
        "    self.level = level\n",
        "  \n",
        "  # __str__ method\n",
        "  def __str__(self):\n",
        "    return '{} studies in level {}'.format(self.name, self.level)"
      ],
      "metadata": {
        "id": "uP6qdgnOn7t3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "student1 = Student(\"Katie Holmes\", 1)\n",
        "student2 = Student(\"Mike Tyson\", 2)\n",
        "\n",
        "print(student1)\n",
        "print(student2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yFeSAbjDoLG_",
        "outputId": "fd389013-7766-4b9f-a06b-a2d06b130c04"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Katie Holmes studies in level 1\n",
            "Mike Tyson studies in level 2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Example of method\n",
        "Let's look at one example of a regular method (not special method)."
      ],
      "metadata": {
        "id": "pRAkkXyToNS2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Student:\n",
        "  #constructor\n",
        "  def __init__(self, name, level):\n",
        "    self.name = name\n",
        "    self.level = level\n",
        "\n",
        "  def __str__(self):\n",
        "    return '{} studies at level {}'.format(self.name, self.level)\n",
        "\n",
        "  # regular method\n",
        "  def level_up(self):\n",
        "    self.level += 1"
      ],
      "metadata": {
        "id": "2cmPB5-_oO12"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "sam = Student(\"Sam Smith\", 1)\n",
        "tom = Student(\"Tom Cruise\", 3)\n",
        "print(sam)\n",
        "print(tom)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lhhUpGnDoR-1",
        "outputId": "2eecc961-a588-4556-bdc3-03a4ee4c2fee"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Sam Smith studies at level 1\n",
            "Tom Cruise studies at level 3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now, when we call the `level_up()` method on the instance `sam`, we see that the level increased by 1. Since we did not call the `level_up()` method on `tom`his level does not change"
      ],
      "metadata": {
        "id": "otlSGexHoUte"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# invoking method\n",
        "sam.level_up()\n",
        "print(sam)\n",
        "print(tom)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ljf_WRGwoSct",
        "outputId": "f338852e-cbe0-4a5b-d0d2-3e76865505d9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Sam Smith studies at level 2\n",
            "Tom Cruise studies at level 3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Comprehensions\n",
        "There are 3 types of comprehensions in Python.\n",
        "\n",
        "* List Comprehension\n",
        "* Set Comprehension\n",
        "* Dictionary Comprehension\n",
        "\n",
        "#### List Comprehension\n",
        "The syntax for List Comprehension is as follows:\n",
        "\n",
        "[expression `for` item `in` iterable]"
      ],
      "metadata": {
        "id": "38fHAniZoeYH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Examples of List Comprehension\n",
        "squares_list = [i*i for i in range(1,10)] # square of numbers from 1 to 9\n",
        "squares_odd_list = [x*x for x in range(1,20) if x%2!=0] # squares of odd numbers from 1 to 19\n",
        "print(squares_list)\n",
        "print(squares_odd_list)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jRzzJzniocaG",
        "outputId": "49b28ddd-06aa-43dd-fea9-b3da0d5d4cbe"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 4, 9, 16, 25, 36, 49, 64, 81]\n",
            "[1, 9, 25, 49, 81, 121, 169, 225, 289, 361]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**List comprehension with if-else**\n",
        "\n",
        "The syntax `for` List Comprehension with `if-else` is:\n",
        "\n",
        "[expression1 `if` conditional `else` expression2 `for` item `in` iterable]\n",
        "\n",
        "An example is shown below."
      ],
      "metadata": {
        "id": "yr2K5YxEo2QO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# square a number if it is even; leave it alone if it is odd\n",
        "lst = [i*i if i%2==0 else i for i in range(10)]\n",
        "lst"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Irh06Udooz8l",
        "outputId": "ae44eb45-30ed-4ad8-ab2b-989c95314b40"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0, 1, 4, 3, 16, 5, 36, 7, 64, 9]"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Multiple if conditions in List Comprehension**\n",
        "\n",
        "Suppose, if you want to get a list of numbers that are multiples of both 2 and 3, then you would normally use a for loop with 2 if statements as follows."
      ],
      "metadata": {
        "id": "MxlCn94_pFS_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lst = []\n",
        "for i in range(20):\n",
        "  if i%2==0:\n",
        "    if i%3==0:\n",
        "      lst.append(i)\n",
        "print(lst)"
      ],
      "metadata": {
        "id": "tjyGGVbdpCmu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "You can do the same thing with just one line of code using list comprehension, as shown below."
      ],
      "metadata": {
        "id": "S82CorhupLmd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lst = [i for i in range(20) if i%2==0 if i%3==0]\n",
        "print(lst)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bcoUhprCpN1H",
        "outputId": "be904ac7-95a2-4a04-9ae5-15f3fbaf4d80"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0, 6, 12, 18]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "Gl3ge6MVpRnd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Call a method on each element using List Comprehension**\n",
        "\n",
        "You can call a method on each element of an iterable using the list comprehension. Example follows"
      ],
      "metadata": {
        "id": "rX13YbevpSTI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lst = [name.capitalize() for name in ['STEVE', 'KaRa', 'SAIF']]\n",
        "print(lst)"
      ],
      "metadata": {
        "id": "a02_DYVBpWnF",
        "outputId": "94d5a6e5-83f2-4dc7-ea88-80100c9d8111",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['Steve', 'Kara', 'Saif']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# for loop equivalent \n",
        "lst = []\n",
        "for name in ['STEVE', 'KaRa', 'SAIF']:\n",
        "  lst.append(name.capitalize())\n",
        "\n",
        "print(lst)"
      ],
      "metadata": {
        "id": "n5-K5h1wpXQ3",
        "outputId": "098c231a-8692-4577-d72b-078624c9647e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['Steve', 'Kara', 'Saif']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Set Comprehension\n",
        "Set Comprehension is very much like the List Comprehension, with the exception that we use the curly braces `{}` instead of square brackets `[]`, and comprehension returns a set, which do not allow duplicates.\n",
        "\n",
        "Let's look at an example of a set comprehension to come up with a set of Pythagorean Triplets. Pythagorean Triplets are tuples of the form (x, y, z) where x squared plus y squared is equal to z squared."
      ],
      "metadata": {
        "id": "tQ9f4cJ--v48"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "pythagorean_triplets = {(x, y, z) for x in range(1,20) for y in range(1,20) for z in range(1,20) if (x**2 + y**2) == z**2}\n",
        "print(pythagorean_triplets) # no duplicates since it is a set"
      ],
      "metadata": {
        "id": "FoHgoNz-pZLu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "322f832a-6045-4085-9125-35baa6cc3ec7"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{(5, 12, 13), (4, 3, 5), (8, 15, 17), (15, 8, 17), (9, 12, 15), (12, 5, 13), (12, 9, 15), (3, 4, 5), (8, 6, 10), (6, 8, 10)}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Dictionary Comprehension\n",
        "Dictionary comprehensions are enclosed by curly braces `{}`.\n",
        "\n",
        "The basic syntax for dictionary comprehension is: {key:value `for` var `in` iterable}\n",
        "\n",
        "For example, you want to create a dictionary of numbers in the range 1 to 5 and their corresponding square roots.\n",
        "\n",
        "You can create a dictionary comprehension as follows for the purpose."
      ],
      "metadata": {
        "id": "3Yf2ThgS_DrO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# dict of numbers from 1 to 5 and their corresponding square roots\n",
        "square_roots_dict = {num: num**0.5 for num in range(1,6)} # range(1,6)=>[1,2,3,4,5]\n",
        "print(square_roots_dict)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qEvvuKlW_LQ3",
        "outputId": "9054b51e-e6b3-4603-ce4c-e89f074e6166"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{1: 1.0, 2: 1.4142135623730951, 3: 1.7320508075688772, 4: 2.0, 5: 2.23606797749979}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Another example:** Suppose, you want to provide a 10% discount for items with amount more than $10. You can do that using the dictionary comprehension in the following way."
      ],
      "metadata": {
        "id": "K5lbs1VY_QIB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "bill = {\"Apple\":12, \"Orange\":7, \"Kiwi\":25, \"Banana\":6}\n",
        "discounted_bill = {k:(v*0.9 if v>10 else v)  for k,v in bill.items()} # 10% discount for amount greater than $10\n",
        "discounted_bill"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RDnDOIhR_O0G",
        "outputId": "6f50f124-a679-4ba0-dc4e-43a21bbbcc66"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'Apple': 10.8, 'Banana': 6, 'Kiwi': 22.5, 'Orange': 7}"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Iterators\n",
        "Iterators in Python are objects that can be iterated upon (i.e. all the values can be traversed through one at a time). Iterator object returns data one element at a time.\n",
        "\n",
        "Iterator object implements two special methods: `__iter__()` and `__next__()`\n",
        "\n",
        "An object from which we can get an iterator is called an iterable. Examples of built-in iterables are: List, Tuple, String, Set etc.\n",
        "\n",
        "The `iter()` function, which calls the `__iter__()` method of the iterable, returns an iterator from the iterable passed as argument."
      ],
      "metadata": {
        "id": "-EmZC27s_ZBm"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Iterating through an Iterator**\n",
        "\n",
        "The `next()` function is used to manually iterate through the items of an iterator. When the end is reached, and there is not any more data to be returned, an `StopIteration` exception is raised."
      ],
      "metadata": {
        "id": "pdHtCKI9_lWV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lst = [\"hello\", \"how\", \"are\", \"you\"] # lst is an iterable\n",
        "# build an iterator (my_iterator) using the iter() function\n",
        "my_iterator = iter(lst) # equivalent to lst.__iter__()\n",
        "# my_iterator = lst.__iter__()\n",
        "\n",
        "# iterate through the iterator using the next() method\n",
        "print(next(my_iterator)) # output \"hello\"\n",
        "print(next(my_iterator)) # output \"how\"\n",
        "print(next(my_iterator)) # output \"are\"\n",
        "print(next(my_iterator)) # output \"you\"\n",
        "print(my_iterator)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "d8jJdCFz_U-v",
        "outputId": "3966b482-ab19-4186-ce53-94acaff09c41"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "hello\n",
            "how\n",
            "are\n",
            "you\n",
            "<list_iterator object at 0x7efecc6f53d0>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(next(my_iterator)) # raises StopIteration exception (no more data)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 165
        },
        "id": "CeDKABUs_xdF",
        "outputId": "56455a63-af04-42c1-b96d-8e2f6963bbfc"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "error",
          "ename": "StopIteration",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-5-1d6b77208b9b>\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[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmy_iterator\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# raises StopIteration exception (no more data)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mStopIteration\u001b[0m: "
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Generators\n",
        "Python generators are a simple way to create iterators. A generator is a function which returns an iterator object. The iterator object can then be iterated over one item at a time.\n",
        "\n",
        "We can create generator function in Python using the `yield` keyword. A generator function can contain one or more `yield` statements, and it may contain return statement as well.\n",
        "\n",
        "The difference between `return` and `yield` is as follows.\n",
        "\n",
        "`return` : returns the value and terminates the function.\n",
        "\n",
        "`yield` : pauses the function saving all its states and continues on from there on subsequent calls. Does not terminate the function."
      ],
      "metadata": {
        "id": "FTSKbnGF_6D5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# generator function definition\n",
        "def my_gen():\n",
        "    yield 2  \n",
        "    yield 3  \n",
        "    yield 4"
      ],
      "metadata": {
        "id": "kZh1k7IH_zOd"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# creating generator object\n",
        "my_gen_obj = my_gen()"
      ],
      "metadata": {
        "id": "il9XbRpHAOUX"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(type(my_gen_obj)) # my_gen is a generator object"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uyD0v7W0ATNt",
        "outputId": "40801101-1ff0-4b8b-ecf1-b5bd92948f09"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'generator'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(next(my_gen_obj)) # output 2\n",
        "print(next(my_gen_obj)) # output 3\n",
        "print(next(my_gen_obj)) # output 4"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XjIeqrhFAV1d",
        "outputId": "7be4c591-f264-48a3-a9b5-200667d7e3d1"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n",
            "3\n",
            "4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(next(my_gen)) # raises StopIteration (no more values to return)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 165
        },
        "id": "Fq06mJsbAaTW",
        "outputId": "961dc541-6046-42ef-c172-6aeff0b8d404"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-10-8297e7aea314>\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[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmy_gen\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# raises StopIteration (no more values to return)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: 'function' object is not an iterator"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Let's see how we can use generator to reverse a string."
      ],
      "metadata": {
        "id": "E5hSKsuZAjYO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def rev_str(input_str):\n",
        "  length = len(input_str) # get the length of the string\n",
        "  for i in range(length-1, -1, -1): # for example, if the string has 4 characters, then i goes from 3 to 0 \n",
        "    yield  input_str[i] # return one character at a time, starting from the end of the string\n",
        "\n",
        "for i in rev_str(\"generator\"):\n",
        "  print(i)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bfc5yZkfAdyF",
        "outputId": "beef2f90-68a7-467f-ccd6-91051bcc7f38"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "r\n",
            "o\n",
            "t\n",
            "a\n",
            "r\n",
            "e\n",
            "n\n",
            "e\n",
            "g\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Generator Expression\n",
        "Simple generator objects can be created using generator expressions. Generator expressions create anonymous generator functions, much like lambda functions create anonymous functions.\n",
        "\n",
        "Generator expresssions are very similar to list comprehension. Generator expressions use parentheses whereas list comprehensions use square brackets. Also, generator expressions return the data one at a time, whereas list comprehension returns all the data at once."
      ],
      "metadata": {
        "id": "7uCxB_HmAoe-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# creating a generator expression\n",
        "my_gen = (2**i for i in range(10)) # returns 2 to the power i, i going from 0 to 9, one value at a time\n",
        "print(my_gen)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "saHPKCGvAlre",
        "outputId": "40ccd9c8-84c5-4f8d-a8fb-a7e7e3f8f4bb"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<generator object <genexpr> at 0x7efece16d6d0>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "next(my_gen)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YI7nCtSiAtc1",
        "outputId": "08e07dd8-5abc-4d0c-ed62-1d9b86847a9d"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "for i in my_gen:\n",
        "  print(i)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yX-_EQB8AvXM",
        "outputId": "5d07c783-3ed2-47b7-dc94-e190bf952f54"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n",
            "4\n",
            "8\n",
            "16\n",
            "32\n",
            "64\n",
            "128\n",
            "256\n",
            "512\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "next(my_gen)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 165
        },
        "id": "f8f9foMxAxAN",
        "outputId": "f1ec93af-c392-4239-dcad-bd7caadd4fae"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "error",
          "ename": "StopIteration",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-15-78dc05d55b31>\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_gen\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: "
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Decorators\n",
        "A decorator in Python takes in a function, adds some functionality to it and returns it.\n",
        "\n",
        "Functions are first-class citizens in Python, which means that functions can be treated just like any other regular variables, i.e. functions can be\n",
        "\n",
        "* passed as arguments to a another function\n",
        "* returned from a function\n",
        "* modified\n",
        "* assigned to a variable\n",
        "This concept is fundamental to understanding Python decorators."
      ],
      "metadata": {
        "id": "WMAN68WWA2Sm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Assigning functions to variables\n",
        "def increment_one(num):\n",
        "  return num+1\n",
        "\n",
        "add_one = increment_one # function increment_one assigned to variable add_one\n",
        "print(add_one(7))\n",
        "print(increment_one(7))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YvQI0lVeAyiO",
        "outputId": "b6ed2fc1-cb28-478f-9e75-1d643f61b33f"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "8\n",
            "8\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Functions passed as arguments to another function\n",
        "def increment_one(num):\n",
        "  return num+1\n",
        "\n",
        "def decrement_one(num):\n",
        "  return num-1\n",
        "\n",
        "def my_function(func, num): # here the first argument is a function\n",
        "  return func(num)\n",
        "\n",
        "print(my_function(increment_one, 5)) # increment_one function being passed as argument\n",
        "print(my_function(decrement_one, 5))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sF1a4npXA_pY",
        "outputId": "2cdf8c8e-2229-41bf-d544-1fa4a41c80e6"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "6\n",
            "4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Function being returned from a function\n",
        "def double():\n",
        "  def mult_by_2(num):\n",
        "    return 2*num\n",
        "  return mult_by_2 # function being returned\n",
        "\n",
        "num2 = double() # num2 is a function => returned by double()\n",
        "result = num2(3)\n",
        "print(result)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DLeaZbqIBBte",
        "outputId": "670ecbe3-69f8-442b-ab5f-7b41cf862618"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "6\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now, let's look at decorators."
      ],
      "metadata": {
        "id": "drqTBfFIBFlZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Decorator takes in a function, adds some functionality and returns it\n",
        "\n",
        "# The decorate() function will decorate the function given to it as argument. \n",
        "# So, it can be considered a decorator.\n",
        "def decorate(func):\n",
        "  def inner_func():\n",
        "    print(\"function has been decorated\")\n",
        "    return func()\n",
        "  return inner_func\n",
        "\n",
        "# we will decorate this function\n",
        "def regular_func():\n",
        "  return \"Just a regular function\" "
      ],
      "metadata": {
        "id": "y2zrNqkcBFHx"
      },
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# regular_func() being invoked (called)\n",
        "regular_func()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "Sbbm31gHBDeS",
        "outputId": "0d739f48-5397-4700-b0ff-e253c90e17cd"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Just a regular function'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# decorating the regular_func() function\n",
        "decorated = decorate(regular_func)\n",
        "print(decorated())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gxjSt4kJBJnT",
        "outputId": "2f047582-a885-4ec6-dbe2-4d76f1ef9a3a"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "function has been decorated\n",
            "Just a regular function\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "As you can see above, the decorator function added some functionality (printing the statement \"function has been decorated\") to the `regular_func` function.\n",
        "\n",
        "In Python, we have an easier way of decorating a function by using the @ symbol and the name of the decorator just above the function to be decorated as shown below."
      ],
      "metadata": {
        "id": "Uj08gSEMBOgh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "@decorate\n",
        "def regular_func():\n",
        "  return \"Just a regular function\""
      ],
      "metadata": {
        "id": "9sTdSDB3BLuu"
      },
      "execution_count": 22,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "regular_func()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 53
        },
        "id": "k8SDcXhPBT0u",
        "outputId": "7baf38b1-0b9a-4478-9046-1694245b1c96"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "function has been decorated\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Just a regular function'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now, let's see another useful example of decorator.\n",
        "\n",
        "Supppose, you have the following function."
      ],
      "metadata": {
        "id": "AvnuWKPWBXHl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def div(x, y):\n",
        "  return x/y"
      ],
      "metadata": {
        "id": "pq2XBelDBVPu"
      },
      "execution_count": 24,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "div(2,0) # throws division by zero error"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 235
        },
        "id": "6qInhSr2BZsW",
        "outputId": "25d66950-9b31-4110-9789-4b1c56fa1b3b"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "error",
          "ename": "ZeroDivisionError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-25-27db689169b7>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mdiv\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# throws division by zero error\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m<ipython-input-24-4d1ad4367829>\u001b[0m in \u001b[0;36mdiv\u001b[0;34m(x, y)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mdiv\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\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[0;32m----> 2\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0my\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"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The above function call resulted in a division by zero error.\n",
        "\n",
        "We can avoid such errors by using a decorator to the `div()` function."
      ],
      "metadata": {
        "id": "P2TFDBe6BezX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# decorator function\n",
        "def validate_div(func):\n",
        "  def inner_func(x, y):\n",
        "    print(\"Dividing {} by {} ...\".format(x, y))\n",
        "    if y == 0:\n",
        "      print(\"Sorry! Can't divide by zero!\")\n",
        "      return\n",
        "    return func(x, y)\n",
        "  return inner_func\n",
        "\n",
        "@validate_div   # decorating the div function\n",
        "def div(x, y):\n",
        "  return x/y"
      ],
      "metadata": {
        "id": "rKCduUayBbL2"
      },
      "execution_count": 26,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "div(2,0)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RwHZ_ZymBjcG",
        "outputId": "140e4e6f-5ef5-4ce4-e001-affa28e6724f"
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Dividing 2 by 0 ...\n",
            "Sorry! Can't divide by zero!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "As you saw above, the division by zero error was averted by the use of a decorator function - `validate_div()`."
      ],
      "metadata": {
        "id": "fFSPIJvYBnlA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "div(3,2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sYckhT-iBlg3",
        "outputId": "243f9392-7613-4619-8006-d10798e65fab"
      },
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Dividing 3 by 2 ...\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1.5"
            ]
          },
          "metadata": {},
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Closure\n",
        "When we define a function inside another function, the inner function is called a nested function. Nested functions are able to access variables defined in the enclosing (outer) function."
      ],
      "metadata": {
        "id": "D5qXBxONBtap"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def greet(): # outer (enclosing) function\n",
        "  msg = \"Welcome to Python world!\" # variable defined in the outer (enclosing) function\n",
        "  def print_msg(): # inner (nested) function\n",
        "    print(msg) # trying to access a variable defined in the scope of outer function\n",
        "  print_msg() # calling the inner() function\n",
        "\n",
        "# invoke outer() function\n",
        "greet()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4TP4genXBrLI",
        "outputId": "11080f6e-d238-4ea9-81e5-24c059a2b0b2"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Welcome to Python world!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "As you can see above, nested functions can access variables defined in the enclosing function's scope.\n",
        "\n",
        "Now let's return the `print_msg` function above instead of calling it."
      ],
      "metadata": {
        "id": "qvOAusqpB4Wo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def greet(): # outer (enclosing) function\n",
        "  msg = \"Welcome to Python world!\" # variable defined in the outer (enclosing) function\n",
        "  def print_msg(): # inner (nested) function\n",
        "    print(msg) # trying to access a variable defined in the scope of outer function\n",
        "  return print_msg # returning the inner() function\n",
        "\n",
        "# invoke outer() function\n",
        "greet_func = greet() # greet() returns a function which is being assigned to greet_func variable\n",
        "greet_func()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ROH1jYPEB2G3",
        "outputId": "33a18e55-4e3e-48df-a50d-fc7eead5e75e"
      },
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Welcome to Python world!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "This is a bit unusual. The `greet()` function was called and the returned function was assigned to the variable `greet_func`. This means that the function execution completed after the execution of that line, still the variable (`msg`) defined in the function was accessible when `greet_func()` is called.\n",
        "\n",
        "Now, let's delete the `greet()` function."
      ],
      "metadata": {
        "id": "EVwOqKdrB-iB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "del greet"
      ],
      "metadata": {
        "id": "f4XKxUnAB8ru"
      },
      "execution_count": 31,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "greet_func()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8l3wSfhpCJOO",
        "outputId": "a303dd19-dcc3-4f94-d4e5-0726202c3e3b"
      },
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Welcome to Python world!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Even if we deleted the original function (`greet()`), the msg variable defined in the original function was still availble.\n",
        "\n",
        "This is called Closure.\n",
        "\n",
        "As seen above, the properties of closure are:\n",
        "\n",
        "* There must be a nested function (function inside a function)\n",
        "* The nested function should refer to a variable defined in the scope of enclosing function\n",
        "* The enclosing function should return the nested function"
      ],
      "metadata": {
        "id": "dF31UpK6CN5F"
      }
    }
  ]
}