Global,_Local_and_Nonlocal_variables_in_Python.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Global, Local and Nonlocal variables in Python.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyMsVZ+qpGUyVK75j966lmyo",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Tanu-N-Prabhu/Python/blob/master/Global%2C_Local_and_Nonlocal_variables_in_Python.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m78LlfbmwQPi",
        "colab_type": "text"
      },
      "source": [
        "# **Global, Local and Nonlocal variables in Python**\n",
        "\n",
        "## **In this tutorial, let us learn the usage of Global, Local and Nonlocal variables in Python**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "re8T7880wzRR",
        "colab_type": "text"
      },
      "source": [
        "![alt text](https://miro.medium.com/max/1050/1*1AktzTtx2ZOH1kb8yv7Piw.jpeg)\n",
        "\n",
        "\n",
        "\n",
        "First of all, I’m not the one on that image above. I’m just a benevolent writer who is here to talk about one of the most confusing concepts in Python programming “***Global, Local and Nonlocal variables***”. I know after reading the title you will be like “***Why should I even worry about this***”. Well, the answer is sometimes not knowing these teeny tiny itsy bitsy would cost you a lot. So without further ado, let’s get started.\n",
        "\n",
        "\n",
        "In programming languages like C/C++, every time a variable is declared simultaneously a memory would be allocated this would allocation would completely depend on the variable type. Therefore, the programmers must specify the variable type while creating a variable. But luckily in Python, you don’t have to do that. Python doesn’t have a variable type declaration. Like pointers in C, variables in Python don’t store values legitimately; they work with references highlighting objects in memory.\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "# **Topics**\n",
        "\n",
        "The list of topics that would be covered in this article is given below:\n",
        "\n",
        "* **Variables** — A quick introduction\n",
        "* **Global Variables** — How to get rid of `UnboundLocalError`\n",
        "* **Local Variables** — How to get rid of `NameError`\n",
        "* **Nonlocal Variables** — When and how to use them\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "# **Variables**\n",
        "\n",
        "A variable is more likely a ***container*** to store the values. Now the values to be stored depends on the programmer whether to use integer, float, string or **[etc](https://www.w3schools.com/python/python_datatypes.asp)**.\n",
        "\n",
        "\n",
        "\n",
        "> ***A Variable is like a box in the computer’s memory where you can store a single value. — Al Sweigart***\n",
        "\n",
        "\n",
        "Unlike in other programming languages, in Python, you need not declare any variables or initialize them. Please read [this](https://stackoverflow.com/a/11008311/11646278).\n",
        "\n",
        "\n",
        "## **Syntax**\n",
        "\n",
        "\n",
        "The general syntax to create a variable in Python is as shown below:\n",
        "\n",
        "`variable_name = value`\n",
        "\n",
        "The `variable_name` in Python can be short as sweet as `a, b, x, y, ...` or can be very informative such as `age, height, name, student_name, covid, ...`\n",
        "\n",
        "\n",
        "> ***Although it is recommended keeping a very descriptive variable name to improve the readability.***\n",
        "\n",
        "\n",
        "\n",
        "## **Rules**\n",
        "\n",
        "**All set and done, there are some rules that you need to follow while naming a variable:**\n",
        "\n",
        "* A variable name must start with a ***letter*** or the ***underscore character***\n",
        "\n",
        "* A variable name cannot start with a ***number***\n",
        "\n",
        "* A variable name can only contain ***alpha-numeric characters*** and ***underscores***. For example, anything like this is valid: ***A-z, 0–9, and _***\n",
        "\n",
        "* Variable names are ***case-sensitive*** ***(height, Height***, and ***HEIGHT*** are three different variables names)\n",
        "\n",
        "## **Example**\n",
        "\n",
        "Below given is an example to properly initialize a value to a variable:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v2oHeqVt8H1y",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "e970083c-f3dc-4814-db02-540bc7c7db96"
      },
      "source": [
        "# This is a valid and good way to assign a value to a variable\n",
        "# For example you might want to assign values to variables to calculate the area of a circle\n",
        "\n",
        "pi = 3.142                                   # I could have also used \"math\" library (math.pi)\n",
        "radius = 5                                   # Interger value for radius\n",
        "area_of_circle = 0                           # Used to store the value of area of circle\n",
        "\n",
        "area_of_circle = pi * (radius) ** 2          # Area = (PI * R^2)\n",
        "\n",
        "print(\"The area of the circle based on the given data is: \", area_of_circle)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The area of the circle based on the given data is:  78.55\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SjOjTf3ujYFi",
        "colab_type": "text"
      },
      "source": [
        "## **Pictorial Example (Skim it quickly)**\n",
        "I#  believe just by seeing a picture or an image, the concepts can be understood more quickly. Below is the pictorial representation of a variable and it being stored in the memory.\n",
        "\n",
        "\n",
        "![alt text](https://miro.medium.com/max/1050/1*dvv6ffYSxqTtd9wTB3TeKw.png)\n",
        "\n",
        "\n",
        "\n",
        "![alt text](https://miro.medium.com/max/1050/1*TQPtYle_1fHLVXvbpJICBA.png)\n",
        "\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q_wlWlM3jwrO",
        "colab_type": "text"
      },
      "source": [
        "# **Global Variables**\n",
        "## **Same old definition**\n",
        "In Python or any other programming languages, the definition of global variables remains the same, which is “***A variable declared outside the function is called global function***”. We can access a global variable inside or outside the function.\n",
        "\n",
        "## **Creating a global variable and accessing it**\n",
        "Let’s use the same example from above to understand the concept of accessing the variable inside and outside the function."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aNob42Mk1WYR",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 87
        },
        "outputId": "5b0d3e97-7671-4b77-c9c1-287f21982c3f"
      },
      "source": [
        "pi = 3.142       # I could have also used \"math\" library (math.pi)\n",
        "radius = 5       # Interger value for radius\n",
        "\n",
        "#----------------------------------------------------------------------------#\n",
        "# Function:      Circle\n",
        "# Description:   This function calculates the area of circle which is Area = (PI * R^2) as simple as it is.\n",
        "# Parameters:    None\n",
        "# Author:        Tanu Nanda Prabhu\n",
        "#----------------------------------------------------------------------------#\n",
        "\n",
        "def circle():\n",
        "    area_of_circle = pi * (radius) ** 2\n",
        "    print(\"The area of the circle based on the given data is: \", area_of_circle)\n",
        "\n",
        "circumference_of_circle = 2 * pi * radius\n",
        "print(\"-------------------------------------------------------------------------------------\")\n",
        "print(\"The circumference of the circle based on the given data is: \", circumference_of_circle)        # Accessing the global variables outside the function\n",
        "print(\"-------------------------------------------------------------------------------------\")\n",
        "circle()     # Accessing the global variables inside the function\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "-------------------------------------------------------------------------------------\n",
            "The circumference of the circle based on the given data is:  31.419999999999998\n",
            "-------------------------------------------------------------------------------------\n",
            "The area of the circle based on the given data is:  78.55\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cdDpv1VWkAS7",
        "colab_type": "text"
      },
      "source": [
        "There you go this is the specialty of global variables. As seen in the above example I have used two common variables `pi` and `radius` to calculate the area of the circle which is declared inside a function and area of the circumference which is calculated outside the function. For both these calculations, we are using the same common variables.\n",
        "\n",
        "\n",
        "\n",
        "## **Understanding \"UnboundLocalError\" in detail and solving it**\n",
        "\n",
        "Now let’s take the same old example and try to update the radius by 2 (multiply by 2)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "McWx33k3cZkq",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 322
        },
        "outputId": "c80025e1-65ef-4519-eebb-2c069a664f56"
      },
      "source": [
        "pi = 3.142       # I could have also used \"math\" library (math.pi)\n",
        "radius = 5       # Interger value for radius\n",
        "\n",
        "#----------------------------------------------------------------------------#\n",
        "# Function:      Circle\n",
        "# Description:   This function calculates the area of circle which is Area = (PI * R^2) as simple as it is.\n",
        "# Parameters:    None\n",
        "# Author:        Tanu Nanda Prabhu\n",
        "#----------------------------------------------------------------------------#\n",
        "\n",
        "def circle():\n",
        "\n",
        "    radius = radius * 2         # Let us try to update the radius by multiplying with 2\n",
        "    area_of_circle = pi * (radius) ** 2\n",
        "    print(\"The area of the circle based on the given data is: \", area_of_circle)\n",
        "\n",
        "circle()     # Accessing the global variables inside the function\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "UnboundLocalError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mUnboundLocalError\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-15-687bc7e71493>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     15\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"The area of the circle based on the given data is: \"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0marea_of_circle\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     16\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 17\u001b[0;31m \u001b[0mcircle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m     \u001b[0;31m# Accessing the global variables inside the function\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m<ipython-input-15-687bc7e71493>\u001b[0m in \u001b[0;36mcircle\u001b[0;34m()\u001b[0m\n\u001b[1;32m     11\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mcircle\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[1;32m     12\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 13\u001b[0;31m     \u001b[0mradius\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mradius\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0;36m2\u001b[0m         \u001b[0;31m# Let us try to update the radius by multiplying with 2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     14\u001b[0m     \u001b[0marea_of_circle\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpi\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mradius\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m**\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     15\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"The area of the circle based on the given data is: \"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0marea_of_circle\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mUnboundLocalError\u001b[0m: local variable 'radius' referenced before assignment"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WLQqbL4YkY-r",
        "colab_type": "text"
      },
      "source": [
        "Now I know you might be like “***there is no necessity***” of this extra step `radius = radius * 2` we can directly do this in the initial step by assigning the value to the radius as 10 i.e. `radius = 10`. I know but I am trying to introduce a concept here. Please bear with me.\n",
        "\n",
        "As seen in the above code, if you try to update the radius and then execute this piece of code you will be surprised. Don’t be excited and say “***I did it***” because you didn’t, rather you will be prompted by an error called `UnboundLocalError`. More likely the error looks like as shown above."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wQ8REdE7kjUq",
        "colab_type": "text"
      },
      "source": [
        "The reason for this error is that the variable radius is local and it cannot be updated as above. Here, you can make it a global variable. Now how to do it. Please see the below code snippet."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "A3aH2OyUkrub",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "6a8d22c3-bd96-4bda-faef-63c6539d55c8"
      },
      "source": [
        "pi = 3.142       # I could have also used \"math\" library (math.pi)\n",
        "radius = 5       # Interger value for radius\n",
        "\n",
        "#----------------------------------------------------------------------------#\n",
        "# Function:      Circle\n",
        "# Description:   This function calculates the area of circle which is Area = (PI * R^2) as simple as it is.\n",
        "# Parameters:    None\n",
        "# Author:        Tanu Nanda Prabhu\n",
        "#----------------------------------------------------------------------------#\n",
        "\n",
        "def circle():\n",
        "\n",
        "    global radius\n",
        "    radius = radius * 2         # Let us try to update the radius by multiplying with 2\n",
        "    area_of_circle = pi * (radius) ** 2\n",
        "    print(\"The area of the circle based on the given data is: \", area_of_circle)\n",
        "\n",
        "circle()     # Accessing the global variables inside the function\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The area of the circle based on the given data is:  314.2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yB4CHwH0kxLq",
        "colab_type": "text"
      },
      "source": [
        "Now when you execute the code, it executes with no problem. Because now it explicitly declared as a global variable.\n",
        "\n",
        "Time to test your knowledge in the long run. Two years back there was this one question asked in **[Stack Overflow](https://stackoverflow.com/q/10851906/11646278)** about `UnboundLocalError`. The **[form](https://stackoverflow.com/q/10851906/11646278)** is now closed for answers because there are already tons of answers present. You can hop in there and try to answer it and understand it more clearly.\n",
        "\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TUD6SkaZlFuz",
        "colab_type": "text"
      },
      "source": [
        "# **Local Variables**\n",
        "## **Same old definition**\n",
        "In Python or any other programming languages, the definition of local variables remains the same, which is “***A variable declared inside the function is called local function***”. We can access a local variable inside but ***not*** outside the function.\n",
        "\n",
        "## **Creating a local variable and accessing it**\n",
        "We use the local variables inside a function and not try to access them outside those functions. Hence the name local. But the good part is we can access those variables within the functions itself."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n-qef2STIMAI",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 69
        },
        "outputId": "03882c4b-9810-42be-f63a-4fbfc8a86afd"
      },
      "source": [
        "#----------------------------------------------------------------------------#\n",
        "# Function:      Circle\n",
        "# Description:   This function calculates the area of circle which is Area = (PI * R^2) as simple as it is.\n",
        "# Parameters:    None\n",
        "# Author:        Tanu Nanda Prabhu\n",
        "#----------------------------------------------------------------------------#\n",
        "\n",
        "def circle():\n",
        "    pi = 3.142       # I could have also used \"math\" library (math.pi)\n",
        "    radius = 5       # Interger value for radius\n",
        "    area_of_circle = pi * (radius) ** 2\n",
        "    print(\"The area of the circle based on the given data is: \", area_of_circle)\n",
        "\n",
        "print(\"-------------------------------------------------------------------------------------\")\n",
        "circle()     # Accessing the global variables inside the function\n",
        "print(\"-------------------------------------------------------------------------------------\")\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "-------------------------------------------------------------------------------------\n",
            "The area of the circle based on the given data is:  78.55\n",
            "-------------------------------------------------------------------------------------\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GhEPY1Sald0W",
        "colab_type": "text"
      },
      "source": [
        "There you go this is the specialty of local variables. As seen in the above example I have used two common variables `pi` and `radius` to calculate the area of the circle which is declared inside a function. So accessing these variables will not create any problem. But what happens if we try to access them outside the function. See the next section below.\n",
        "\n",
        "\n",
        "## **Understanding \"NameError\" in detail**\n",
        "\n",
        "Let’s use the same example from above and access the variables declared inside the function:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YPpFLaEw36EJ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 253
        },
        "outputId": "a9f8afb4-4999-4a1b-a4c8-227a961980b1"
      },
      "source": [
        "#----------------------------------------------------------------------------#\n",
        "# Function:      Circle\n",
        "# Description:   This function calculates the area of circle which is Area = (PI * R^2) as simple as it is.\n",
        "# Parameters:    None\n",
        "# Author:        Tanu Nanda Prabhu\n",
        "#----------------------------------------------------------------------------#\n",
        "\n",
        "def circle():\n",
        "    \n",
        "    pi = 3.142       # I could have also used \"math\" library (math.pi)\n",
        "    radius = 5       # Interger value for radius\n",
        "    area_of_circle = pi * (radius) ** 2\n",
        "    print(\"The area of the circle based on the given data is: \", area_of_circle)\n",
        "\n",
        "circumference_of_circle = 2 * pi * radius\n",
        "print(\"-------------------------------------------------------------------------------------\")\n",
        "print(\"The circumference of the circle based on the given data is: \", circumference_of_circle)        # Accessing the global variables outside the function\n",
        "print(\"-------------------------------------------------------------------------------------\")\n",
        "circle()     # Accessing the global variables inside the function\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-1-d9575a7edd28>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     13\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"The area of the circle based on the given data is: \"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0marea_of_circle\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     14\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 15\u001b[0;31m \u001b[0mcircumference_of_circle\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m2\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mpi\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mradius\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     16\u001b[0m \u001b[0mprint\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[1;32m     17\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"The circumference of the circle based on the given data is: \"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcircumference_of_circle\u001b[0m\u001b[0;34m)\u001b[0m        \u001b[0;31m# Accessing the global variables outside the function\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mNameError\u001b[0m: name 'pi' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3V3CFB7TlrL5",
        "colab_type": "text"
      },
      "source": [
        "When you execute the above code, you will be prompted by a `NameError`. More likely the error looks as shown above.\n",
        "\n",
        "\n",
        "The reason for this error is as we are trying to access a local variable `pi` and `radius` in a global scope whereas the local variable only works inside `circle()` or local scope. There is a way to solve it by declaring `pi` and `radius` as global or declaring them outside the function. Where any function can access them.\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vU0t7lsyl7jR",
        "colab_type": "text"
      },
      "source": [
        "# **Nonlocal Variables**\n",
        "## **Same old definition**\n",
        "In Python or any other programming languages, we often use the nonlocal variable inside nested functions. Now, what do I mean by nested functions?\n",
        "## **Nested Functions**\n",
        "In general, a nested function is a set of functions declared inside another function. Given below is an example of a nested function."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zZyuCCrimbDj",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        },
        "outputId": "1f06a88e-bd02-4a6c-dd1b-632c2534a0af"
      },
      "source": [
        "#----------------------------------------------------------------------------#\n",
        "# Function:      Circle\n",
        "# Description:   This function calculates the area of circle which is Area = (PI * R^2) as simple as it is.\n",
        "# Parameters:    None\n",
        "# Author:        Tanu Nanda Prabhu\n",
        "#----------------------------------------------------------------------------#\n",
        "\n",
        "\n",
        "def circle():\n",
        "    pi = 3.142   # I could have also used \"math\" library (math.pi)\n",
        "    radius = 5   # Interger value for radius\n",
        "    area_of_circle = pi * (radius) ** 2\n",
        "\n",
        "    \n",
        "    #----------------------------------------------------------------------------#\n",
        "    # Function:      Circumference\n",
        "    # Description:   This function calculates the circumference of circle which is Area = (2 * Pi * r) as simple as it is.\n",
        "    # Parameters:    None\n",
        "    # Author:        Tanu Nanda Prabhu\n",
        "    #----------------------------------------------------------------------------#\n",
        "\n",
        "    def circumference():\n",
        "        # Formula for circumference\n",
        "        circumference_of_circle = 2 * pi * radius    \n",
        "        return circumference_of_circle\n",
        "    print(circumference())    # Calling the circumference function\n",
        "    \n",
        "    return area_of_circle\n",
        "\n",
        "print(circle())     # Calling the circle function"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "31.419999999999998\n",
            "78.55\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kOJ4pngzmGB_",
        "colab_type": "text"
      },
      "source": [
        "## **Creating a nonlocal variable and accessing it**\n",
        "Let us now try to update the radius by 2 (multiply by 2) inside the `circumference()`. The reason that I’m specifically insisting to do this because as soon as you write `radius = radius * 2` and run the code you will be prompted by `UnboundLocalError` seeing this you will change it to a global variable by saying global radius but this time you will get a new error as `NameError`. And now you will be baffled, don’t know what to do. There is a simple way to solve this “***Go read the definition of a nonlocal variable***”. Whenever there is a nested function you need to use a `nonlocal` variable. That’s it problem solved. Below is the way to create a nonlocal variable and access it."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "u_DptluIAoqV",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 87
        },
        "outputId": "a8571049-7dcd-45f3-f57c-bb29e2e7abd6"
      },
      "source": [
        "#----------------------------------------------------------------------------#\n",
        "# Function:      Circle\n",
        "# Description:   This function calculates the area of circle which is Area = (PI * R^2) as simple as it is.\n",
        "# Parameters:    None\n",
        "# Author:        Tanu Nanda Prabhu\n",
        "#----------------------------------------------------------------------------#\n",
        "\n",
        "def circle():\n",
        "\n",
        "    pi = 3.142       # I could have also used \"math\" library (math.pi)\n",
        "    radius = 5       # Interger value for radius\n",
        "    area_of_circle = pi * (radius) ** 2\n",
        "\n",
        "    #----------------------------------------------------------------------------#\n",
        "    # Function:      Circumference\n",
        "    # Description:   This function calculates the circumference of circle which is Area = (2 * Pi * r) as simple as it is.\n",
        "    # Parameters:    None\n",
        "    # Author:        Tanu Nanda Prabhu\n",
        "    #----------------------------------------------------------------------------#\n",
        "\n",
        "    def circumference():\n",
        "        nonlocal radius\n",
        "        radius = radius * 2\n",
        "        circumference_of_circle = 2 * pi * radius    # Formula for circumference\n",
        "\n",
        "        return circumference_of_circle\n",
        "\n",
        "    print(circumference())                # Calling the circumference function\n",
        "\n",
        "    return area_of_circle\n",
        "\n",
        "print(\"-------------------------------------------------------------------------------------\")\n",
        "print(circle())     # Calling the circle function\n",
        "print(\"-------------------------------------------------------------------------------------\")\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "-------------------------------------------------------------------------------------\n",
            "62.839999999999996\n",
            "78.55\n",
            "-------------------------------------------------------------------------------------\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eF5L8AGsm6E0",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "# **Conclusion**\n",
        "This is the end of the article titled “***Global, Local and Nonlocal variables in Python***”. I hope you guys learned a thing or two by reading this article. Through this article, you learned how to get rid of two important Python errors such as `NameError` and `UnboundLocalError` which were troubling you all these days or years or whatever. Now you can easily debug these two errors with a smile on your face without losing a sweat. If you have any comments or suggestions about this article, then the comment section is all yours. Stay tuned for more updates, until then goodbye. Stay safe and happy coding and see you next time.\n",
        "\n",
        "\n",
        "---"
      ]
    }
  ]
}