003_Python_Function_global_Keywords.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<small><small><i>\n",
    "All the IPython Notebooks in **Python Functions** lecture series by Dr. Milaan Parmar are available @ **[GitHub](https://github.com/milaan9/04_Python_Functions)**\n",
    "</i></small></small>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python `global` Keyword\n",
    "\n",
    "In this class, you’ll learn about the **`global`** keyword, global variable and when to use **`global`** keyword.\n",
    "\n",
    "Before reading this article, make sure you have got some basics of **[Python Global, Local and Nonlocal Variables](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Function_Global_Local_Nonlocal.ipynb)**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# What is `global` keyword?\n",
    "\n",
    "In Python, **`global`** keyword allows you to modify the variable outside of the current scope. It is used to create a global variable and make changes to the variable in a local context."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Rules of `global` Keyword\n",
    "\n",
    "The basic rules for **`global`** keyword in Python are:\n",
    "\n",
    "1. When we create a variable inside a function, it is local by default.\n",
    "2. When we define a variable outside of a function, it is global by default. You don't have to use **`global`** keyword.\n",
    "3. We use **`global`** keyword to read and write a global variable inside a function.\n",
    "4. Use of **`global`** keyword outside a function has no effect."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Use of `global` Keyword"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-13T14:27:02.042929Z",
     "start_time": "2021-06-13T14:27:02.025355Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "# Example 1: Accessing global Variable From Inside a Function\n",
    "\n",
    "a = 1 # global variable\n",
    "\n",
    "def add():\n",
    "    print(a)\n",
    "\n",
    "add()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, we may have some scenarios where we need to modify the global variable from inside a function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-13T14:27:05.239195Z",
     "start_time": "2021-06-13T14:27:04.904238Z"
    }
   },
   "outputs": [
    {
     "ename": "UnboundLocalError",
     "evalue": "local variable 'a' referenced before assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mUnboundLocalError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-2-515941f58fe7>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      7\u001b[0m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      8\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 9\u001b[1;33m \u001b[0madd\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<ipython-input-2-515941f58fe7>\u001b[0m in \u001b[0;36madd\u001b[1;34m()\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0madd\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 6\u001b[1;33m     \u001b[0ma\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0ma\u001b[0m \u001b[1;33m+\u001b[0m \u001b[1;36m3\u001b[0m \u001b[1;31m# increment a by 3 (modifying my global variable)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      7\u001b[0m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      8\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mUnboundLocalError\u001b[0m: local variable 'a' referenced before assignment"
     ]
    }
   ],
   "source": [
    "# Example 2: Modifying Global Variable From Inside the Function\n",
    "\n",
    "a = 1 # global variable\n",
    "    \n",
    "def add():\n",
    "    a = a + 3 # increment a by 3 (modifying my global variable)\n",
    "    print(a)\n",
    "\n",
    "add()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is because we can only access the global variable but cannot modify it from inside the function.\n",
    "\n",
    "The solution for this is to use the **`global`** keyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-13T14:27:06.885175Z",
     "start_time": "2021-06-13T14:27:06.863695Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Inside add(): 3\n",
      "In main: 3\n"
     ]
    }
   ],
   "source": [
    "# Example 2: Changing Global Variable From Inside a Function using global\n",
    "\n",
    "a = 0 # global variable\n",
    "\n",
    "def add():\n",
    "    global a  # using global variable inside my function\n",
    "    a = a + 3 # increment by 3\n",
    "    print(\"Inside add():\", a)\n",
    "\n",
    "add()\n",
    "print(\"In main:\", a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation:**\n",
    "\n",
    "In the above program, we define **`a`** as a global keyword inside the **`add()`** function.\n",
    "\n",
    "Then, we increment the variable **`a`** by 1, i.e **`a = a + 3`**. After that, we call the **`add()`** function. Finally, we print the global variable **`a`**.\n",
    "\n",
    "As we can see, change also occurred on the global variable outside the function, **`a = 3`**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let’s see another example where we don’t use **`global`** keyword to access the global variable in the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-13T14:27:09.262597Z",
     "start_time": "2021-06-13T14:27:09.239165Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Value in 1st function: 9\n",
      "Value in 2nd function: 999\n",
      "Value in 3rd function: 9\n"
     ]
    }
   ],
   "source": [
    "# Exercise 3: without `global` keyword.\n",
    "\n",
    "global_var = 9   # Global variable\n",
    "\n",
    "def fun1():\n",
    "    print(\"Value in 1st function:\", global_var)\n",
    "\n",
    "def fun2():\n",
    "    # Modify global variable\n",
    "    # function will treat it as a local variable\n",
    "    global_var = 999\n",
    "    print(\"Value in 2nd function:\", global_var)\n",
    "\n",
    "def fun3():\n",
    "    print(\"Value in 3rd function:\", global_var)\n",
    "\n",
    "fun1()\n",
    "fun2()\n",
    "fun3()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation:**\n",
    "\n",
    "As you can see, **`fun2()`** treated **`global_var`** as a new variable (local variable). To solve such issues or access/modify global variables inside a function, we use the **`global`** keyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-13T14:27:11.122937Z",
     "start_time": "2021-06-13T14:27:11.113174Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Value in 1st function: 9\n",
      "Value in 2nd function: 999\n",
      "Value in 3rd function: 999\n"
     ]
    }
   ],
   "source": [
    "# Exercise 3: use the `global` keyword.\n",
    "\n",
    "\n",
    "x = 9   # Global variable\n",
    "\n",
    "# defining 1st function\n",
    "def fun1():\n",
    "    print(\"Value in 1st function:\", x)\n",
    "\n",
    "# defining 2nd function\n",
    "def fun2():\n",
    "    # Modify global variable using global keyword\n",
    "    global x\n",
    "    x = 999\n",
    "    print(\"Value in 2nd function:\", x)\n",
    "\n",
    "# defining 3rd function\n",
    "def fun3():\n",
    "    print(\"Value in 3rd function:\", x)\n",
    "\n",
    "fun1()\n",
    "fun2()\n",
    "fun3()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Global Variables Across Python Modules\n",
    "\n",
    "In Python, we create a single module **config.py** to hold global variables and share information across Python modules within the same program.\n",
    "\n",
    "Here is how we can share global variables across the python modules."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example : Share a global Variable Across Python Modules\n",
    "\n",
    "Create a **config.py** file, to store global variables\n",
    "\n",
    "```python\n",
    ">>> a = 0\n",
    ">>> b = \"empty\"\n",
    "```\n",
    "\n",
    "Create a **update.py** file, to change global variables\n",
    "\n",
    "```python\n",
    ">>> import config  # import config.py here\n",
    "\n",
    ">>> config.a = 10  # change the value of 'a' from 0 to 10\n",
    ">>> config.b = \"alphabet\"  # change the value of 'b' from \"empty\" to \"alphabet\"\n",
    "```\n",
    "\n",
    "Create a **main1.py** file, to test changes in value\n",
    "\n",
    "```python\n",
    ">>> import config  # import config.py here\n",
    ">>> import update  # import update.py here\n",
    "\n",
    ">>> print(config.a)  # print the updated value of 'a'\n",
    ">>> print(config.b)  # print the updated value of 'b'\n",
    "```\n",
    "\n",
    "When we run the **main.py** file, the output will be\n",
    "\n",
    "`\n",
    "10\n",
    "alphabet\n",
    "`\n",
    "\n",
    "In the above, we have created three files: **config.py**, **update.py**, and **main.py**.\n",
    "\n",
    "The module **config.py** stores global variables of **`a`** and **`b`**. In the **update.py** file, we import the **config.py** module and modify the values of **`a`** and **`b`**. Similarly, in the **main.py** file, we import both **config.py** and **update.py** module. Finally, we print and test the values of global variables whether they are changed or not."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Global in Nested Functions\n",
    "\n",
    "Here is how you can use a global variable in nested function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-13T14:27:16.594081Z",
     "start_time": "2021-06-13T14:27:16.570649Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before calling bar function: 30\n",
      "Calling bar function now\n",
      "After calling bar function: 30\n",
      "x in main function: 66\n"
     ]
    }
   ],
   "source": [
    "# Example 1: Using a Global Variable in Nested Function\n",
    "\n",
    "def fun():  # main function\n",
    "    x = 30\n",
    "\n",
    "    def day():  # nested fucntion\n",
    "        global x\n",
    "        x = 66\n",
    "    \n",
    "    print(\"Before calling bar function:\", x)  # check indentation\n",
    "    print(\"Calling bar function now\")\n",
    "    day()\n",
    "    print(\"After calling bar function:\", x)\n",
    "\n",
    "fun()\n",
    "print(\"x in main function:\", x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation:**\n",
    "\n",
    "In the above program, we declared a global variable inside the nested function **`day()`**. Inside **`fun()`** function, **`x`** has no effect of the global keyword.\n",
    "\n",
    "Before and after calling **`day()`**, the variable **`x`** takes the value of local variable i.e **`x = 30`**. Outside of the **`fun()`** function, the variable **`x`** will take value defined in the **`day()`** function i.e **`x = 66`**. This is because we have used global keyword in **`x`** to create global variable inside the **`day()`** function (local scope).\n",
    "\n",
    "If we make any changes inside the **`day()`** function, the changes appear outside the local scope, i.e. **`fun()`**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.8.8"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}